docker部署MinIO

部署docker容器

docker run -p 9000:9000 -p 9090:9090 \ 
     --net=host \
     --name minio \
     -d --restart=always \
     -e "MINIO_ACCESS_KEY=minioadmin" \
     -e "MINIO_SECRET_KEY=minioadmin" \
     -v /data/minio/data:/data \
     -v /data/minio/config:/root/.minio \
     minio/minio server \
     /data --console-address ":9090" -address ":9000"

9090端口为后台端口，9000端口为提供服务的端口，MINIO_ACCESS_KEY和MINIO_SECRET_KEY为登录后台的初始账号密码

登录MinIO后台

访问IP地址:http://ip:9090/login 登录，使用上述设置的账号密码

创建存储桶，名称随意

创建密钥

整合Springboot

添加依赖

<dependency>  
    <groupId>io.minio</groupId>  
    <artifactId>minio</artifactId>  
    <version>8.2.2</version>  
</dependency>

设置Springboot配置文件

minio:  
  endpoint: http://ip:9000  
  access-key: 
  secret-key: ****  
  bucket-name: 存储桶名

创建属性类MinioProperties

@Component  
@ConfigurationProperties(prefix = "sky.minio")  
@Data  
public class MinioProperties {  
    private String bucketName;  
    private String endpoint;  
    private String accessKey;  
    private String secretKey;  
}

创建工具类

@Data  
@AllArgsConstructor  
@Slf4j  
public class MinioUtil {  
  
    private MinioClient minioClient;  
    private String bucketName;  
    private String endpoint;  
  
  
    public String upload(byte[] bytes, String objectName){  
  
        //创建put Object请求  
        try {  
            minioClient.putObject(PutObjectArgs.builder().bucket(bucketName)  
                                                         .object(objectName)  
                                                         .stream(new ByteArrayInputStream(bytes),bytes.length,-1)  
                                                         .build());  
        } catch (ErrorResponseException | InvalidKeyException | InsufficientDataException | InvalidResponseException |  
                 InternalException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {  
            throw new RuntimeException(e);  
        }  
        StringBuilder url = new StringBuilder();  
        url.append(endpoint)  
                .append("/")  
                .append(bucketName)  
                .append("/")  
                .append(objectName);  
  
        return url.toString();  
  
    }  
}

创建配置类

@Configuration  
@Slf4j  
public class MinioConfiguration {  
  
    @Bean  
    public MinioClient minioClient(MinioProperties minioProperties) {  
        return MinioClient.builder()  
                .endpoint(minioProperties.getEndpoint())  
                .credentials(minioProperties.getAccessKey(),minioProperties.getSecretKey())  
                .build();  
    }  
  
    @Bean  
    @ConditionalOnMissingBean    public MinioUtil minioUtil(MinioClient minioClient,MinioProperties minioProperties){  
        return new MinioUtil(minioClient,minioProperties.getBucketName(),minioProperties.getEndpoint());  
    }  
}

Controller中调用

@RestController  
@RequestMapping("/admin/common")  
@Api(tags = "通用接口")  
@Slf4j  
public class CommonController {  
  
    @Autowired  
    private MinioUtil minioUtil;  
  
    /**  
     * 文件上传  
     * @param file  
     * @return  
     */  
    @PostMapping("/upload")  
    public Result<String> upload(MultipartFile file){  
        log.info("文件上传:{}",file);  
  
        try {  
            String originalFilename = file.getOriginalFilename();  
            //截取后缀  
            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));  
            String objectName = UUID.randomUUID().toString() + extension;  
            String filePath = minioUtil.upload(file.getBytes(), objectName);  
            return Result.success(filePath);  
        } catch (IOException e) {  
            log.error("文件上传失败 {}",e);  
        }  
  
        return Result.error(MessageConstant.UPLOAD_FAILED);  
    }  
}