docker compose up -d

version: '3.8'

services:
  minio:
    image: quay.io/minio/minio
    container_name: minio
    restart: unless-stopped
    env_file:
      - dev.env
    volumes:
      - minio-data:/data
    ports:
      - '9000:9000'
      - '9001:9001'
    command: server /data --console-address ":9001"

volumes:
  minio-data:
    driver: local

mkdir -p ~/minio/data

docker run \
   -p 9000:9000 \
   -p 9001:9001 \
   --name minio \
   -v ~/minio/data:/data \
   -e "MINIO_ROOT_USER=admin" \
   -e "MINIO_ROOT_PASSWORD=Admin@123" \
   quay.io/minio/minio server /data --console-address ":9001"

~/Desktop/code/spring/minio init_project +1 ❯ docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED          STATUS          PORTS                              NAMES
a14adce9ba2b   quay.io/minio/minio   "/usr/bin/docker-ent…"   24 minutes ago   Up 24 minutes   0.0.0.0:9000-9001->9000-9001/tcp   minio

~/Desktop/code/spring/minio init_project +1 ❯ docker logs -t minio
2025-02-23T02:19:35.793744676Z MinIO Object Storage Server
2025-02-23T02:19:35.793805218Z Copyright: 2015-2025 MinIO, Inc.
2025-02-23T02:19:35.793809009Z License: GNU AGPLv3 - https://www.gnu.org/licenses/agpl-3.0.html
2025-02-23T02:19:35.793810968Z Version: RELEASE.2025-02-18T16-25-55Z (go1.23.6 linux/arm64)
2025-02-23T02:19:35.793813093Z
2025-02-23T02:19:35.793815134Z API: http://172.24.0.2:9000  http://127.0.0.1:9000
2025-02-23T02:19:35.793817218Z WebUI: http://172.24.0.2:9001 http://127.0.0.1:9001
2025-02-23T02:19:35.793819051Z
2025-02-23T02:19:35.793820676Z Docs: https://docs.min.io

<properties>
	<minio.version>8.5.7</minio.version>
</properties>

<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>${minio.version}</version>
</dependency>

spring:
  application:
    name: Spring Boot and MinIO Integration
  profiles:
    active: minio
  servlet:
    multipart:
      max-file-size: 5GB # Giới hạn dung lượng tối đa của một tệp tải lên (5GB)
      max-request-size: 50GB # Giới hạn tổng dung lượng của tất cả các tệp trong một request (5GB)

minio:
  url: http://localhost:9000 # URL của MinIO server
  key:
    access: admin # Access key để kết nối MinIO
    secret: Admin@123 # Secret key để xác thực với MinIO
  bucket:
    default: demo # Tên bucket mặc định để lưu trữ file

server:
  port: 9005

package com.davidnguyen.demo.minio.config;

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MinIoConfig {
    @Value("${minio.url}")
    private String minioUrl;

    @Value("${minio.key.access}")
    private String accessKey;

    @Value("${minio.key.secret}")
    private String secretKey;

    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(minioUrl)
                .credentials(accessKey, secretKey)
                .build();
    }
}

package com.davidnguyen.demo.minio.service;

import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.List;

@Service
public interface StorageService {
    void upload(List<MultipartFile> files);

    InputStream download(String fileName);

    String getURL(String fileName);
}

package com.davidnguyen.demo.minio.service;

import io.minio.*;
import io.minio.http.Method;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Service
@RequiredArgsConstructor
@Profile("minio")
public class MinIOStorageService implements StorageService {
    private final MinioClient minioClient;

    @Value("${minio.bucket.default}")
    private String bucketName;

    @Override
    public void upload(List<MultipartFile> files) {
        this.ensureBucketExists(bucketName);

        for (MultipartFile file : files) {
            try (InputStream inputStream = file.getInputStream()) {
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(bucketName)
                                .object(file.getOriginalFilename())
                                .stream(inputStream, file.getSize(), -1)
                                .contentType(file.getContentType())
                                .build()
                );
            } catch (Exception e) {
                throw new RuntimeException("Failed to upload file: " + file.getOriginalFilename(), e);
            }
        }
    }

    private void ensureBucketExists(String bucketName) {
        try {
            boolean found = minioClient.bucketExists(
                    BucketExistsArgs.builder().bucket(bucketName).build()
            );
            if (!found) {
                minioClient.makeBucket(
                        MakeBucketArgs.builder().bucket(bucketName).build()
                );
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to ensure bucket exists: " + bucketName, e);
        }
    }

    @Override
    public InputStream download(String fileName) {
        try {
            return minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("Error downloading file: " + e.getMessage());
        }
    }

    @Override
    public String getURL(String fileName) {
        try {
            return minioClient.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .method(Method.GET)
                            .expiry(30, TimeUnit.DAYS)
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("Error generating pre-signed URL: " + e.getMessage());
        }
    }
}

package com.davidnguyen.demo.minio.controller;

import com.davidnguyen.demo.minio.service.MinIOStorageService;
import com.davidnguyen.demo.minio.service.StorageService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.List;

@RestController
@RequestMapping("/api/v1/storage")
@RequiredArgsConstructor
public class StorageController {
    /**
     * Upload files to storage.
     */
    @PostMapping("/upload")
    public ResponseEntity<Void> uploadFile(
            @RequestPart("files") List<MultipartFile> files
    ) {
        storageService.upload(files);
        return ResponseEntity.ok().build();
    }

    private final StorageService storageService;

    /**
     * Download file from storage.
     */
    @GetMapping("/download/{fileName}")
    public ResponseEntity<byte[]> download(
            @PathVariable String fileName
    ) {
        try {
            InputStream stream = storageService.download(fileName);
            byte[] content = stream.readAllBytes();
            return ResponseEntity.ok()
                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"")
                    .body(content);
        } catch (Exception e) {
            return ResponseEntity.internalServerError().body(null);
        }
    }

    /**
     * Get pre-signed URL for accessing a file.
     */
    @GetMapping("/pre-signed-url/{fileName}")
    public ResponseEntity<String> getPreSignedUrl(@PathVariable String fileName) {
        return ResponseEntity.ok(storageService.getURL(fileName));
    }
}

@Override
public void upload(List<MultipartFile> files) {
    this.ensureBucketExists(bucketName);

    for (MultipartFile file : files) {
        String fileName = this.generateFileName(file);
        //String fileName = UUID.randomUUID() + "/" + file.getOriginalFilename(); //Folders for versioning
        try (InputStream inputStream = file.getInputStream()) {
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .stream(inputStream, file.getSize(), -1)
                            .contentType(file.getContentType())
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("Failed to upload file: " + file.getOriginalFilename(), e);
        }
    }
}

private String generateFileName(MultipartFile file) {
    String originalFilename = file.getOriginalFilename();
    if (originalFilename == null) {
        throw new IllegalArgumentException("File name cannot be null");
    }

    String extension = "";
    int dotIndex = originalFilename.lastIndexOf(".");

    if (dotIndex != -1) {
        extension = originalFilename.substring(dotIndex);
        originalFilename = originalFilename.substring(0, dotIndex);
    }

    long timestamp = System.currentTimeMillis();
    return originalFilename + "_" + timestamp + extension;
}