MinIO基础使用教程

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::my-bucket/*",
        "arn:aws:s3:::my-bucket"
      ]
    }
  ]
}

2. SDK使用示例

除了通过Web控制台，我们也可以通过各种编程语言的SDK与MinIO交互。

2.1 JavaScript (Node.js)

首先安装MinIO客户端:

npm install minio

基本使用示例:

const Minio = require('minio');

// 初始化MinIO客户端
const minioClient = new Minio.Client({
  endPoint: '10.102.3.42',  // 服务器IP
  port: 9000,               // API端口
  useSSL: false,            // 是否使用HTTPS
  accessKey: 'admin',       // 访问密钥
  secretKey: '12345678'     // 秘密密钥
});

// 列出所有存储桶
async function listBuckets() {
  try {
    const buckets = await minioClient.listBuckets();
    console.log('Buckets:');
    buckets.forEach(bucket => console.log(bucket.name));
  } catch (err) {
    console.error('Error listing buckets:', err);
  }
}

// 上传文件
async function uploadFile(bucketName, objectName, filePath) {
  try {
    await minioClient.fPutObject(bucketName, objectName, filePath);
    console.log(`File ${filePath} uploaded successfully as ${objectName} to ${bucketName}`);
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

// 下载文件
async function downloadFile(bucketName, objectName, filePath) {
  try {
    await minioClient.fGetObject(bucketName, objectName, filePath);
    console.log(`File ${objectName} downloaded successfully to ${filePath}`);
  } catch (err) {
    console.error('Error downloading file:', err);
  }
}

// 删除文件
async function deleteFile(bucketName, objectName) {
  try {
    await minioClient.removeObject(bucketName, objectName);
    console.log(`File ${objectName} deleted successfully from ${bucketName}`);
  } catch (err) {
    console.error('Error deleting file:', err);
  }
}

// 示例使用
(async () => {
  await listBuckets();
  // 上传示例
  // await uploadFile('my-bucket', 'test-file.txt', './local-file.txt');
})();

2.2 Java

首先添加Maven依赖:

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

基本使用示例:

import io.minio.*;
import io.minio.messages.Bucket;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.List;

public class MinioExample {

    public static void main(String[] args) {
        try {
            // 初始化MinIO客户端
            MinioClient minioClient = MinioClient.builder()
                    .endpoint("http://10.102.3.42:9000")
                    .credentials("admin", "12345678")
                    .build();

            // 列出所有存储桶
            listBuckets(minioClient);
            
            // 上传文件示例
            // uploadFile(minioClient, "my-bucket", "test-file.txt", "C:\\path\\to\\local-file.txt");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 列出所有存储桶
    private static void listBuckets(MinioClient minioClient) throws Exception {
        List<Bucket> bucketList = minioClient.listBuckets();
        System.out.println("Buckets:");
        for (Bucket bucket : bucketList) {
            System.out.println(bucket.name());
        }
    }

    // 上传文件
    private static void uploadFile(MinioClient minioClient, String bucketName, 
                                  String objectName, String filePath) throws Exception {
        // 检查存储桶是否存在
        boolean found = minioClient.bucketExists(BucketExistsArgs.builder()
                .bucket(bucketName).build());
        if (!found) {
            // 创建存储桶
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName).build());
            System.out.println("Bucket " + bucketName + " created");
        }

        // 上传文件
        minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(filePath)
                        .build());
        System.out.println("File " + filePath + " uploaded successfully as " 
                          + objectName + " to " + bucketName);
    }

    // 下载文件
    private static void downloadFile(MinioClient minioClient, String bucketName, 
                                    String objectName, String filePath) throws Exception {
        minioClient.downloadObject(
                DownloadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(filePath)
                        .build());
        System.out.println("File " + objectName + " downloaded successfully to " + filePath);
    }

    // 删除文件
    private static void deleteFile(MinioClient minioClient, String bucketName, 
                                  String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
        System.out.println("File " + objectName + " deleted successfully from " + bucketName);
    }
}

2.3 Python

首先安装MinIO客户端:

pip install minio

基本使用示例:

from minio import Minio
from minio.error import S3Error

# 初始化MinIO客户端
client = Minio(
    "10.102.3.42:9000",
    access_key="admin",
    secret_key="12345678",
    secure=False  # 是否使用HTTPS
)

# 列出所有存储桶
def list_buckets():
    try:
        buckets = client.list_buckets()
        print("Buckets:")
        for bucket in buckets:
            print(f" - {bucket.name}")
    except S3Error as e:
        print(f"Error listing buckets: {e}")

# 上传文件
def upload_file(bucket_name, object_name, file_path):
    try:
        # 检查存储桶是否存在
        if not client.bucket_exists(bucket_name):
            # 创建存储桶
            client.make_bucket(bucket_name)
            print(f"Bucket {bucket_name} created")
        
        # 上传文件
        client.fput_object(bucket_name, object_name, file_path)
        print(f"File {file_path} uploaded successfully as {object_name} to {bucket_name}")
    except S3Error as e:
        print(f"Error uploading file: {e}")

# 下载文件
def download_file(bucket_name, object_name, file_path):
    try:
        client.fget_object(bucket_name, object_name, file_path)
        print(f"File {object_name} downloaded successfully to {file_path}")
    except S3Error as e:
        print(f"Error downloading file: {e}")

# 删除文件
def delete_file(bucket_name, object_name):
    try:
        client.remove_object(bucket_name, object_name)
        print(f"File {object_name} deleted successfully from {bucket_name}")
    except S3Error as e:
        print(f"Error deleting file: {e}")

# 示例使用
if __name__ == "__main__":
    list_buckets()
    # 上传示例
    # upload_file("my-bucket", "test-file.txt", "./local-file.txt")

3. 高级使用技巧

3.1 预签名URL

预签名URL允许临时访问私有对象，无需提供额外认证。

Node.js示例:

// 生成有效期为1小时的下载链接
async function getPresignedUrl(bucketName, objectName) {
  try {
    const url = await minioClient.presignedGetObject(bucketName, objectName, 3600); // 3600秒(1小时)
    console.log('Presigned URL:', url);
    return url;
  } catch (err) {
    console.error('Error generating presigned URL:', err);
  }
}

// 生成有效期为10分钟的上传链接
async function getPresignedPutUrl(bucketName, objectName) {
  try {
    const url = await minioClient.presignedPutObject(bucketName, objectName, 600); // 600秒(10分钟)
    console.log('Presigned Put URL:', url);
    return url;
  } catch (err) {
    console.error('Error generating presigned put URL:', err);
  }
}

3.2 对象加密

MinIO支持服务端加密(SSE)和客户端加密:

服务端加密配置(启动时):

Windows环境:

set MINIO_KMS_KES_ENDPOINT=https://kes-server:7373
set MINIO_KMS_KES_KEY_FILE=path/to/key.key
set MINIO_KMS_KES_CERT_FILE=path/to/cert.cert
set MINIO_KMS_KES_CA_PATH=path/to/ca.cert

Linux环境:

export MINIO_KMS_KES_ENDPOINT=https://kes-server:7373
export MINIO_KMS_KES_KEY_FILE=path/to/key.key
export MINIO_KMS_KES_CERT_FILE=path/to/cert.cert
export MINIO_KMS_KES_CA_PATH=path/to/ca.cert

3.3 对象生命周期管理

通过生命周期规则自动管理对象:

控制台配置:

进入存储桶管理页面
选择"Management"选项卡
点击"Lifecycle"
点击"Create lifecycle rule"按钮
配置规则:
- 规则名称
- 过滤前缀(可选)
- 过期时间(如30天后)
- 转换到低成本存储(可选)

通过API配置示例(Node.js):

const lifecycleConfig = {
  Rules: [
    {
      ID: "expire-rule",
      Status: "Enabled",
      Prefix: "logs/",
      Expiration: {
        Days: 30
      }
    }
  ]
};

async function setLifecyclePolicy(bucketName) {
  try {
    await minioClient.setBucketLifecycle(bucketName, lifecycleConfig);
    console.log(`Lifecycle policy set for bucket ${bucketName}`);
  } catch (err) {
    console.error('Error setting lifecycle policy:', err);
  }
}

3.4 事件通知

MinIO可以发送对象变化的事件通知到各种目标(如Kafka、NATS、MySQL等):

配置示例(控制台):

进入存储桶管理页面
选择"Events"选项卡
点击"Add Event Notification"
配置事件:
- 事件类型(如PUT, DELETE等)
- 前缀/后缀过滤器(可选)
- 通知目标(如Kafka, NATS, MySQL等)

通过API配置(Node.js):

const arn = "arn:minio:sqs::primary:kafka";
const events = ['s3:ObjectCreated:*', 's3:ObjectRemoved:*'];
const pattern = 'images/*';

async function configureEventNotification(bucketName) {
  try {
    await minioClient.setBucketNotification(bucketName, {
      QueueConfigurations: [
        {
          Queue: arn,
          Events: events,
          Filter: {
            Key: {
              FilterRules: [
                {
                  Name: 'prefix',
                  Value: pattern
                }
              ]
            }
          }
        }
      ]
    });
    console.log(`Event notification configured for bucket ${bucketName}`);
  } catch (err) {
    console.error('Error configuring event notification:', err);
  }
}

4. 性能优化建议

4.1 客户端优化

并行上传：使用分片上传和并行处理加速大文件上传
连接池：保持连接重用，避免频繁建立新连接
合理设置超时：根据网络情况调整连接和读写超时
压缩：对文本文件考虑使用gzip压缩后再上传

4.2 网络优化

本地部署：尽可能将MinIO部署在应用服务器同一内网
带宽监控：监控网络带宽使用，避免瓶颈
负载均衡：使用负载均衡器分配请求

4.3 应用实践

批量操作：尽可能使用批量操作API减少请求次数
CDN集成：对频繁访问的静态内容考虑结合CDN使用
缓存策略：实现客户端缓存策略，减少重复请求

总结

本教程介绍了MinIO的基本使用方法，包括Web控制台操作和各种编程语言的SDK使用示例。MinIO作为高性能的对象存储服务，提供了丰富的功能和灵活的访问方式，可以满足各种应用场景的需求。

通过合理配置和优化，MinIO可以成为您应用架构中可靠的存储基础设施，无论是用于图片、视频存储，还是作为数据备份和归档的解决方案。