MinIO 对象存储从入门到进阶：最全客户端教程来了[【四】

原创于 2025-07-11 20:30:00 发布 · 170 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#minio #MC #存储 #云原生

MinIO客户端使用教程

概述

MinIO是一个高性能的对象存储服务，兼容Amazon S3 API。本教程将详细介绍如何使用MinIO客户端进行对象存储操作，包括命令行客户端mc和各种编程语言的SDK。

前提准备

1、一个minio集群

如果没有可以使用docker进行快速安装：

mkdir -p ~/minio/data
docker run \
   -p 9000:9000 \
   -p 9001:9001 \
   --name minio \
   -v ~/minio/data:/data \
   -e "MINIO_ROOT_USER=ROOTNAME" \
   -e "MINIO_ROOT_PASSWORD=CHANGEME123" \
   quay.io/minio/minio server /data --console-address ":9001"

mc命令行客户端

安装mc客户端

Linux/macOS:

# 下载mc客户端
curl https://dl.min.io/client/mc/release/linux-amd64/mc \
  --create-dirs \
  -o $HOME/minio-binaries/mc

# 添加执行权限
chmod +x $HOME/minio-binaries/mc

# 添加到PATH（可选）
export PATH=$PATH:$HOME/minio-binaries/

Windows:

# 使用PowerShell下载
Invoke-WebRequest -Uri "https://dl.min.io/client/mc/release/windows-amd64/mc.exe" -OutFile "mc.exe"

配置mc客户端

# 添加MinIO服务器配置 
mc alias set myminio http://localhost:9000 ROOTNAME CHANGEME123



# 查看已配置的服务器
mc alias list

基本操作命令

存储桶管理:

# 创建存储桶
mc mb myminio/mybucket

# 列出存储桶
mc ls myminio

# 删除存储桶
mc rb myminio/mybucket

对象操作:

# 生成一个4k大小的文件
truncate -s 4K 4kb_file.bin
# 上传文件
mc cp 4kb_file.bin myminio/mybucket/

# 删除当前文件
rm -rf 4kb_file.bin
# 下载文件
mc cp myminio/mybucket/4kb_file.bin .

# 列出对象
mc ls myminio/mybucket/

# 删除对象
mc rm myminio/mybucket/4kb_file.bin

# 批量生成一些待测试文件
mkdir -p batch && for i in {1..100000}; do truncate -s 4K batch/file_$i.bin; done


# 批量操作
mc cp ./batch/ myminio/mybucket/ --recursive

同步操作:

# 同步本地文件夹到MinIO
mc mirror /local/folder myminio/mybucket/

# 同步MinIO到本地
mc mirror myminio/mybucket/ /local/folder/

Python SDK使用

安装Python SDK

pip install minio

基本使用示例

from minio import Minio
from minio.error import S3Error
import os

# 创建MinIO客户端
client = Minio(
    "101.37.236.242:9000",
    access_key="ROOTNAME",
    secret_key="CHANGEME123",
    secure=False  # 如果使用HTTPS，设置为True
)

# 检查存储桶是否存在
bucket_name = "mybucket"
found = client.bucket_exists(bucket_name)
if not found:
    client.make_bucket(bucket_name)
    print(f"Created bucket {bucket_name}")
else:
    print(f"Bucket {bucket_name} already exists")

# 上传文件
try:
    client.fput_object(
        bucket_name,
        "test-file.txt",
        "E:\\Users\\admin\\llm\\1.txt"
    )
    print("File uploaded successfully")
except S3Error as err:
    print(f"Error occurred: {err}")

# 下载文件
try:
    client.fget_object(
        bucket_name,
        "test-file.txt",
        "file.txt"
    )
    print("File downloaded successfully")
except S3Error as err:
    print(f"Error occurred: {err}")

# 列出对象
try:
    objects = client.list_objects(bucket_name)
    for obj in objects:
        print(f"Object: {obj.object_name}, Size: {obj.size}")
except S3Error as err:
    print(f"Error occurred: {err}")

Java SDK使用

添加Maven依赖

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

基本使用示例

package com.stdio.minioexample;

import io.minio.*;
import io.minio.messages.Item;



public class MinIOExample {
    public static void main(String[] args) throws Exception {
        // 创建MinIO客户端
        MinioClient minioClient = MinioClient.builder()
                .endpoint("http://101.37.236.242:9000")
                .credentials("ROOTNAME", "CHANGEME123")
                .build();

        // 检查存储桶是否存在
        String bucketName = "mybucket";
        boolean found = minioClient.bucketExists(
                BucketExistsArgs.builder()
                        .bucket(bucketName)
                        .build()
        );

        if (!found) {
            minioClient.makeBucket(
                    MakeBucketArgs.builder()
                            .bucket(bucketName)
                            .build()
            );
            System.out.println("Bucket created successfully");
        }

        // 上传文件
        minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object("test-file-java.txt")
                        .filename("file.txt")
                        .build()
        );
        System.out.println("File uploaded successfully");

        // 下载文件
        minioClient.downloadObject(
                DownloadObjectArgs.builder()
                        .bucket(bucketName)
                        .object("test-file-java.txt")
                        .filename("file-down.txt")
                        .build()
        );
        System.out.println("File downloaded successfully");

        // 列出对象
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .build()
        );

        for (Result<Item> result : results) {
            Item item = result.get();
            System.out.println("Object: " + item.objectName() + ", Size: " + item.size());
        }

    }
}

Node.js SDK使用

安装Node.js SDK

npm install minio

基本使用示例

const Minio = require('minio');

// 创建MinIO客户端
const minioClient = new Minio.Client({
    endPoint: '101.37.236.242',
    port: 9000,
    useSSL: false,
    accessKey: 'ROOTNAME',
    secretKey: 'CHANGEME123'
});

const bucketName = 'mybucket';

// 检查存储桶是否存在
minioClient.bucketExists(bucketName, (err, exists) => {
    if (err) {
        return console.log('Error checking bucket:', err);
    }
    
    if (exists) {
        console.log('Bucket exists');
    } else {
        // 创建存储桶
        minioClient.makeBucket(bucketName, 'us-east-1', (err) => {
            if (err) {
                return console.log('Error creating bucket:', err);
            }
            console.log('Bucket created successfully');
        });
    }
});

// 上传文件
minioClient.fPutObject(bucketName, 'test-file.txt', 'file.txt', (err, etag) => {
    if (err) {
        return console.log('Error uploading file:', err);
    }
    console.log('File uploaded successfully, etag:', etag);
});

// 下载文件
minioClient.fGetObject(bucketName, 'test-file.txt', 'file-down.txt', (err) => {
    if (err) {
        return console.log('Error downloading file:', err);
    }
    console.log('File downloaded successfully');
});

// 列出对象
const objectsStream = minioClient.listObjects(bucketName, '', true);
objectsStream.on('data', (obj) => {
    console.log('Object:', obj.name, 'Size:', obj.size);
});
objectsStream.on('error', (err) => {
    console.log('Error listing objects:', err);
});

Go SDK使用

安装Go SDK

go get github.com/minio/minio-go/v7

基本使用示例

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/minio/minio-go/v7"
    "github.com/minio/minio-go/v7/pkg/credentials"
)

func main() {
    // 创建MinIO客户端
    minioClient, err := minio.New("101.37.236.242:9000", &minio.Options{
        Creds:  credentials.NewStaticV4("ROOTNAME", "CHANGEME123", ""),
        Secure: false,
    })
    if err != nil {
        log.Fatalln(err)
    }

    ctx := context.Background()
    bucketName := "mybucket"

    // 检查存储桶是否存在
    exists, err := minioClient.BucketExists(ctx, bucketName)
    if err != nil {
        log.Fatalln(err)
    }

    if !exists {
        // 创建存储桶
        err = minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{})
        if err != nil {
            log.Fatalln(err)
        }
        fmt.Println("Bucket created successfully")
    } else {
        fmt.Println("Bucket already exists")
    }

    // 上传文件
    objectName := "test-file.txt"
    filePath := "file.txt"
    contentType := "text/plain"

    info, err := minioClient.FPutObject(ctx, bucketName, objectName, filePath, minio.PutObjectOptions{
        ContentType: contentType,
    })
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Printf("File uploaded successfully. Size: %d\n", info.Size)

    // 下载文件
    err = minioClient.FGetObject(ctx, bucketName, objectName, "file-down.txt", minio.GetObjectOptions{})
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println("File downloaded successfully")

    // 列出对象
    objectCh := minioClient.ListObjects(ctx, bucketName, minio.ListObjectsOptions{})
    for object := range objectCh {
        if object.Err != nil {
            log.Fatalln(object.Err)
        }
        fmt.Printf("Object: %s, Size: %d\n", object.Key, object.Size)
    }
}