开发

• 1: Go 快速入门指南
• 2: Python 快速入门指南
• 3: .NET 快速入门指南
• 4: Java 快速入门指南
• 5: MinIO Operator 的 Security Token Service (STS)
• 6: JavaScript 快速入门指南
• 7: Haskell 快速入门指南
• 8: Rust 快速入门指南
• 9: 软件开发工具包（SDK）
• 10: Security Token Service (STS)
  • 10.1: AssumeRoleWithCustomToken
  • 10.2: AssumeRoleWithLDAPIdentity
  • 10.3: AssumeRoleWithWebIdentity
• 11: 使用 Object Lambda 进行转换
• 12: 文件传输协议 (FTP/SFTP)

1 - Go 快速入门指南

MinIO Go SDK

SILO 实现兼容 S3 的服务端契约，因此 Go 应用可以直接使用上游 MinIO Go SDK。当前主版本的模块路径为 github.com/minio/minio-go/v7。

安装模块

在现有 Go 模块中执行：

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

配置连接

export S3_ENDPOINT=127.0.0.1:9000
export S3_ACCESS_KEY=silo-admin
export S3_SECRET_KEY=replace-with-a-strong-secret
export S3_USE_SSL=false

S3_ENDPOINT 只填写主机名和可选端口，不带 http:// 或 https:// 前缀。请把凭据保存在源码仓库之外；端点启用 TLS 时，将 S3_USE_SSL 设为 true。

创建存储桶并上传对象

将以下内容保存为 main.go：

package main

import (
	"bytes"
	"context"
	"fmt"
	"log"
	"os"

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

func required(name string) string {
	value := os.Getenv(name)
	if value == "" {
		log.Fatalf("%s is required", name)
	}
	return value
}

func main() {
	ctx := context.Background()
	client, err := minio.New(required("S3_ENDPOINT"), &minio.Options{
		Creds: credentials.NewStaticV4(
			required("S3_ACCESS_KEY"),
			required("S3_SECRET_KEY"),
			"",
		),
		Secure: os.Getenv("S3_USE_SSL") == "true",
	})
	if err != nil {
		log.Fatal(err)
	}

	const bucket = "go-quickstart"
	const object = "hello.txt"

	exists, err := client.BucketExists(ctx, bucket)
	if err != nil {
		log.Fatal(err)
	}
	if !exists {
		if err = client.MakeBucket(ctx, bucket, minio.MakeBucketOptions{
			Region: "us-east-1",
		}); err != nil {
			log.Fatal(err)
		}
	}

	payload := []byte("hello from SILO\n")
	info, err := client.PutObject(
		ctx,
		bucket,
		object,
		bytes.NewReader(payload),
		int64(len(payload)),
		minio.PutObjectOptions{ContentType: "text/plain"},
	)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Uploaded %s: %d bytes\n", info.Key, info.Size)
}

运行示例：

go run .

预签名 URL、对象锁定、加密、通知、分段上传等操作见 SDK 的 API 文档与维护中示例。

生产检查清单

• 启用 TLS，并验证服务端证书。
• 从密钥管理系统或受保护的环境中加载凭据。
• 只授予应用实际需要的存储桶与对象权限。
• 同时固定并验证 SDK 与 Go 版本。
• 为请求设置截止时间，并显式处理重试、取消与未完成的分段上传。

服务端策略配置见身份与访问管理。

2 - Python 快速入门指南

MinIO Python SDK

SILO 实现兼容 S3 的服务端契约，因此 Python 应用可以直接使用上游 MinIO Python SDK。

安装软件包

在虚拟环境中安装 minio：

python3 -m venv .venv
source .venv/bin/activate
python -m pip install minio

配置连接

export S3_ENDPOINT=127.0.0.1:9000
export S3_ACCESS_KEY=silo-admin
export S3_SECRET_KEY=replace-with-a-strong-secret
export S3_USE_SSL=false

S3_ENDPOINT 只填写主机名和可选端口，不带 http:// 或 https:// 前缀。请把凭据保存在源码仓库之外；端点启用 TLS 时，将 S3_USE_SSL 设为 true。

创建存储桶并上传对象

将以下内容保存为 quickstart.py：

import io
import os

from minio import Minio


def required(name: str) -> str:
    value = os.environ.get(name)
    if not value:
        raise RuntimeError(f"{name} is required")
    return value


client = Minio(
    required("S3_ENDPOINT"),
    access_key=required("S3_ACCESS_KEY"),
    secret_key=required("S3_SECRET_KEY"),
    secure=os.environ.get("S3_USE_SSL", "false").lower() == "true",
)

bucket = "python-quickstart"
object_name = "hello.txt"
payload = b"hello from SILO\n"

if not client.bucket_exists(bucket):
    client.make_bucket(bucket)

client.put_object(
    bucket,
    object_name,
    io.BytesIO(payload),
    length=len(payload),
    content_type="text/plain",
)

stat = client.stat_object(bucket, object_name)
print(f"Uploaded {object_name}: {stat.size} bytes")

运行示例：

python quickstart.py

预签名 URL、服务端加密、通知、对象锁定、分段上传等操作见仓库的 API 参考与维护中示例。

生产检查清单

• 启用 TLS，并验证服务端证书。
• 从密钥管理系统或受保护的环境中加载凭据。
• 只授予应用实际需要的存储桶与对象权限。
• 同时固定并验证 Python 运行时、SDK 与 HTTP 依赖。
• 定义超时，并显式处理 SDK 异常、重试、流资源与未完成的分段上传。

服务端策略配置见身份与访问管理。

3 - .NET 快速入门指南

MinIO .NET SDK

SILO 实现兼容 S3 的服务端契约，因此应用可以直接使用上游 MinIO .NET SDK，无需 SILO 专用客户端分支。本指南使用稳定的 NuGet 软件包，并通过环境变量传入凭据。

安装软件包

在现有 .NET 项目中添加 Minio 软件包：

dotnet add package Minio

配置连接

设置 SILO 部署的端点与凭据，不要把密钥写进源码仓库。

export S3_ENDPOINT=127.0.0.1:9000
export S3_ACCESS_KEY=silo-admin
export S3_SECRET_KEY=replace-with-a-strong-secret
export S3_USE_SSL=false

S3_ENDPOINT 只填写主机名和可选端口，不带 http:// 或 https:// 前缀。端点启用 TLS 时，将 S3_USE_SSL 设为 true。

创建存储桶并上传对象

using Minio;
using Minio.DataModel.Args;

var endpoint = Environment.GetEnvironmentVariable("S3_ENDPOINT")
    ?? throw new InvalidOperationException("S3_ENDPOINT is required");
var accessKey = Environment.GetEnvironmentVariable("S3_ACCESS_KEY")
    ?? throw new InvalidOperationException("S3_ACCESS_KEY is required");
var secretKey = Environment.GetEnvironmentVariable("S3_SECRET_KEY")
    ?? throw new InvalidOperationException("S3_SECRET_KEY is required");
var useSsl = bool.TryParse(Environment.GetEnvironmentVariable("S3_USE_SSL"), out var ssl)
    && ssl;

var client = new MinioClient()
    .WithEndpoint(endpoint)
    .WithCredentials(accessKey, secretKey)
    .WithSSL(useSsl)
    .Build();

const string bucket = "dotnet-quickstart";
const string objectName = "hello.txt";
const string filePath = "hello.txt";

var exists = await client.BucketExistsAsync(
    new BucketExistsArgs().WithBucket(bucket));

if (!exists)
{
    await client.MakeBucketAsync(
        new MakeBucketArgs().WithBucket(bucket));
}

await client.PutObjectAsync(
    new PutObjectArgs()
        .WithBucket(bucket)
        .WithObject(objectName)
        .WithFileName(filePath)
        .WithContentType("text/plain"));

Console.WriteLine($"Uploaded {objectName} to {bucket}");

创建 hello.txt，然后运行项目：

dotnet run

ASP.NET Core 依赖注入与更多操作见 SDK 的当前 README。维护分支还提供简单控制台示例和基于 Host 的示例；把代码复制到固定版本的应用前，请先核对示例所在分支与软件包版本。

生产检查清单

• 启用 TLS，并验证服务端证书。
• 从密钥管理系统或受保护的环境中加载凭据，不要写入源码。
• 只授予应用实际需要的存储桶与对象权限。
• 把 SDK 版本固定与验证纳入应用自身的依赖生命周期。
• 显式处理 SDK 异常、请求取消、重试与分段上传清理。

服务端策略配置见身份与访问管理。

4 - Java 快速入门指南

MinIO Java SDK

SILO 实现兼容 S3 的服务端契约，因此 Java 应用可以直接使用上游 MinIO Java SDK。SDK 支持 Java 8 及更高版本；请同时考虑应用框架对运行时的支持范围。

安装软件包

在 Maven 中添加依赖：

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

或在 Gradle 中添加：

implementation("io.minio:minio:9.0.3")

配置连接

export S3_ENDPOINT=http://127.0.0.1:9000
export S3_ACCESS_KEY=silo-admin
export S3_SECRET_KEY=replace-with-a-strong-secret

与部分 MinIO SDK 不同，Java 构造器接受完整的端点 URL，需要包含 http:// 或 https:// 协议。请把凭据保存在源码仓库之外。

创建存储桶并上传对象

import io.minio.BucketExistsArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;

public final class Quickstart {
  private static String required(String name) {
    String value = System.getenv(name);
    if (value == null || value.isBlank()) {
      throw new IllegalStateException(name + " is required");
    }
    return value;
  }

  public static void main(String[] args) throws Exception {
    MinioClient client =
        MinioClient.builder()
            .endpoint(required("S3_ENDPOINT"))
            .credentials(required("S3_ACCESS_KEY"), required("S3_SECRET_KEY"))
            .build();

    String bucket = "java-quickstart";
    String object = "hello.txt";
    byte[] payload = "hello from SILO\n".getBytes(StandardCharsets.UTF_8);

    boolean exists =
        client.bucketExists(BucketExistsArgs.builder().bucket(bucket).build());
    if (!exists) {
      client.makeBucket(MakeBucketArgs.builder().bucket(bucket).build());
    }

    try (ByteArrayInputStream stream = new ByteArrayInputStream(payload)) {
      client.putObject(
          PutObjectArgs.builder()
              .bucket(bucket)
              .object(object)
              .stream(stream, payload.length, -1)
              .contentType("text/plain")
              .build());
    }

    System.out.printf("Uploaded %s: %d bytes%n", object, payload.length);
  }
}

预签名 URL、加密、通知、对象锁定、分段上传等操作见 SDK 的 Javadoc与维护中示例。

生产检查清单

• 启用 TLS，并验证服务端证书与信任库。
• 从密钥管理系统或受保护的环境中加载凭据。
• 只授予应用实际需要的存储桶与对象权限。
• 同时固定并验证 JDK、SDK、HTTP 客户端与应用框架版本。
• 配置超时，并显式处理 SDK 异常、重试、流资源与未完成的分段上传。

服务端策略配置见身份与访问管理。

5 - MinIO Operator 的 Security Token Service (STS)

概述

MinIO Operator 的 STS 具有以下优势：

• STS 凭证 允许应用程序访问 MinIO Tenant 上的对象，而无需在租户上为该应用创建凭证。

• 允许应用程序使用 Kubernetes 原生认证机制访问 MinIO 租户中的对象。

  Service Account 或 Service Account Token 是 Kubernetes 中 Role-Based Access Control (RBAC) authentication 的核心概念。

• 为 MinIO Operator 实现 STS 后，你可以通过租户 custom resource definition (CRD) 和 MinIO PolicyBinding CRD，利用基础设施即代码的原则与配置方式。

Kubernetes 中 STS 授权的工作方式

应用程序可以使用包含 Kubernetes Service Account JWT 的 AssumeRoleWithWebIdentity 调用，向 MinIO Operator 请求临时凭证。 当该 Service Account 关联到 Pod 时（例如通过 deployment 的 .spec.spec.serviceAccountName 字段），Kubernetes 会从已知位置挂载该 Service Account 的 JWT，例如 /var/run/secrets/kubernetes.io/serviceaccount/token。 Pod 可以从该位置访问这些 Service Account。

Operator 会检查请求有效性，检索该应用的策略，从租户获取凭证，然后将凭证返回给应用程序。 应用程序使用签发的凭证在该租户上执行对象存储操作。

完整流程包括以下步骤：

1. 应用程序向 MinIO Operator 发送 AssumeRoleWithWebidentity API 请求，其中包含租户命名空间和要使用的 Service Account。
2. MinIO Operator 使用 Kubernetes API 检查应用请求中与 service account 关联的 JSON Web Token (JWT) 是否有效。
3. Kubernetes API 返回其有效性检查结果。
4. MinIO Operator 检查与应用程序匹配的 Policy Bindings。
5. PolicyBinding CRD 返回与请求匹配的策略（如果有）。
6. MinIO Operator 将该应用程序的合并策略信息发送给 MinIO Tenant。
7. 租户为该请求创建与策略匹配的临时凭证，并将其返回给 MinIO Operator。
8. MinIO Operator 将临时凭证转发回应用程序。
9. 应用程序使用该凭证向 MinIO Tenant 发起对象存储调用。

要求

MinIO Operator 的 STS 需要满足以下条件：

• MinIO Operator v5.0.0 或更高版本。
• 部署 必须 配置 TLS。
• （Operator v5.0.0 - 5.0.10 必需）OPERATOR_STS_ENABLED 环境变量设置为 on。

步骤

1. 为部署启用 STS 功能

   说明

   说明

   对于 Operator 5.0.11 及更高版本，此步骤是可选的。

   kubectl -n minio-operator set env deployment/minio-operator OPERATOR_STS_ENABLED=on

   • 将 minio-operator 替换为你的部署命名空间。

   • 将 deployment/minio-operator 替换为你的部署中 MinIO Operator 的值。

     你可以运行 kubectl get deployments -n <namespace> 查找 deployment 值，其中 <namespace> 需替换为 MinIO Operator 的命名空间。 你的 MinIO Operator 命名空间通常是 minio-operator，但该值在安装过程中可能发生变化。

2. 确保 MinIO Tenant 上存在适用于该应用程序的 policy （一个或多个）

   下一步会使用 YAML 文档，通过名为 PolicyBinding 的 custom resource 将一个或多个现有租户策略映射到 Service Account。

3. 为 Service Account 和 Policy Binding 创建 YAML 资源：

   • 在 MinIO Tenant 中创建供应用程序使用的 Service Account。

     关于 Kubernetes 中 Service Account 的更多信息，请参见 Kubernetes 文档。

   • 在目标租户命名空间中创建 Policy Binding，将应用程序关联到 MinIO Tenant 的一个或多个策略。

4. 将 YAML 文件应用到部署以创建资源

   kubectl apply -k path/to/yaml/file.yaml

5. 使用支持 AssumeRoleWithWebIdentity 类行为的 SDK，从你的应用程序向部署发送调用

   STS API 要求 Kubernetes 环境中存在该 Service Account 的 JWT。 当该 Service Account 关联到 Pod 时（例如通过 deployment 的 .spec.spec.serviceAccountName 字段），Kubernetes 会从已知位置挂载该 Service Account 的 JWT，例如 /var/run/secrets/kubernetes.io/serviceaccount/token。

   或者，你也可以将 token 路径定义为环境变量：

   AWS_WEB_IDENTITY_TOKEN_FILE=/var/run/secrets/kubernetes.io/serviceaccount/token

   以下 MinIO SDK 支持 AssumeRoleRoleWithWebIdentity：

   • Golang
   • Java
   • JavaScript
   • .NET
   • Python

   关于使用 SDK Assume role 的示例，请参见 Operator v7.1.1 示例。

示例资源

Service Account（服务账户）

Service Account 是一种 Kubernetes 资源类型，允许外部应用程序与 Kubernetes 部署交互。 当该 Service Account 关联到 Pod 时（例如通过 deployment 的 .spec.spec.serviceAccountName 字段），Kubernetes 会从已知位置挂载该 Service Account 的 JWT，例如 /var/run/secrets/kubernetes.io/serviceaccount/token。

以下 YAML 会在 sts-client 命名空间中创建名为 stsclient-sa 的 Service Account。

apiVersion: v1
kind: ServiceAccount
metadata:
  namespace: sts-client # The namespace to add the service account to. Usually a tenant, but can be any namespace in the deployment.
  name: stsclient-sa # The name to use for the service account.

Policy Binding（策略绑定）

PolicyBinding 是 Kubernetes 中 MinIO 特有的 custom resource 类型，用于将 application 关联到一组策略。

在其所属租户的命名空间中创建 Policy Binding。

在 MinIO Operator 的语境下，application 是指任何使用特定 Service Account 和租户命名空间进行标识的请求资源。 PolicyBinding 资源将该 application 关联到该命名空间中租户的一个或多个策略。

下面的 YAML 创建了一个 PolicyBinding，将位于 sts-client 命名空间中、使用 Service Account stsclient-sa 的 application，关联到位于 minio-tenant-1 命名空间的目标租户中的策略 test-bucket-rw。 YAML 定义中授予的策略 必须 已存在于 MinIO Tenant 上。

apiVersion: sts.min.io/v1alpha1
kind: PolicyBinding
metadata:
  name: binding-1
  namespace: minio-tenant-1 # The namespace of the tenant this binding is for
spec:
  application:
    namespace: sts-client # The namespace that contains the service account for the application
    serviceaccount: stsclient-sa # The service account to use for the application
  policies:
    - test-bucket-rw # A policy that already exists in the tenant
    # - test-bucket-policy-2 # Add as many policies as needed

参考

• 按 SDK 分类的 STS 示例
• Kubernetes Service Account 文档
• MinIO STS API

6 - JavaScript 快速入门指南

MinIO JavaScript SDK

SILO 实现兼容 S3 的服务端契约，因此 Node.js 应用可以直接使用上游 MinIO JavaScript SDK。请选择受所用软件包版本支持、且仍在维护的 Node.js 版本。

安装软件包

npm install minio

该软件包已内置 TypeScript 类型声明，不要再安装旧的 @types/minio 软件包。

配置连接

export S3_ENDPOINT=127.0.0.1
export S3_PORT=9000
export S3_ACCESS_KEY=silo-admin
export S3_SECRET_KEY=replace-with-a-strong-secret
export S3_USE_SSL=false

不要把凭据写进源码仓库。连接启用 TLS 的部署时，请将 S3_USE_SSL 设为 true，并使用对应的 TLS 服务端口。

创建存储桶并上传对象

将下面的内容保存为 quickstart.mjs：

import * as Minio from 'minio'

const required = (name) => {
  const value = process.env[name]
  if (!value) throw new Error(`${name} is required`)
  return value
}

const client = new Minio.Client({
  endPoint: required('S3_ENDPOINT'),
  port: Number(process.env.S3_PORT || 9000),
  useSSL: process.env.S3_USE_SSL === 'true',
  accessKey: required('S3_ACCESS_KEY'),
  secretKey: required('S3_SECRET_KEY'),
})

const bucket = 'javascript-quickstart'
const objectName = 'hello.txt'

if (!(await client.bucketExists(bucket))) {
  await client.makeBucket(bucket, 'us-east-1')
}

await client.putObject(
  bucket,
  objectName,
  Buffer.from('hello from SILO\n'),
  { 'Content-Type': 'text/plain' },
)

const stat = await client.statObject(bucket, objectName)
console.log(`Uploaded ${objectName}: ${stat.size} bytes`)

运行：

node quickstart.mjs

存储桶策略、通知、对象锁、预签名 URL、分段操作与其他 API 见仓库的 API 参考和持续维护的示例目录。长期文档应优先链接稳定目录，而不是持续复制单个示例文件名的假设。

生产检查清单

• 启用 TLS，并验证服务端证书。
• 从密钥管理系统或受保护的环境中加载凭据。
• 只授予应用实际需要的存储桶与对象权限。
• 一并固定并验证 SDK 版本、Node.js 运行时、超时行为与重试策略。
• 显式处理数据流、请求错误、未完成的分段上传与进程退出。

服务端策略配置见身份与访问管理。

7 - Haskell 快速入门指南

MinIO Haskell SDK

SILO 实现兼容 S3 的服务端契约，因此 Haskell 应用可以直接使用上游 minio-hs 软件包。

安装软件包

将 minio-hs 加入 Cabal 软件包的 build-depends，或加入 package.yaml 的依赖列表。要交互式查看已安装 API，可执行：

cabal repl

然后在 GHCi 中运行 :browse Network.Minio。

配置连接

1.7.0 提供的 fromMinioEnv 会读取以下凭据变量：

export S3_ENDPOINT=http://127.0.0.1:9000
export MINIO_ACCESS_KEY=silo-admin
export MINIO_SECRET_KEY=replace-with-a-strong-secret

S3_ENDPOINT 是包含 http:// 或 https:// 协议的完整 URL。请把凭据保存在源码仓库之外。

创建存储桶并上传对象

将以下内容保存为 Main.hs：

{-# LANGUAGE OverloadedStrings #-}

import Control.Monad (unless)
import Data.String (fromString)
import Network.Minio
import System.Environment (getEnv)

main :: IO ()
main = do
  endpoint <- getEnv "S3_ENDPOINT"
  connection <-
    setCredsFrom [fromMinioEnv] (fromString endpoint :: ConnectInfo)

  result <- runMinio connection $ do
    let bucket = "haskell-quickstart"
        object = "hello.txt"

    exists <- bucketExists bucket
    unless exists $ makeBucket bucket Nothing
    fPutObject bucket object "hello.txt" defaultPutObjectOptions

  case result of
    Left err -> putStrLn $ "Upload failed: " ++ show err
    Right () -> putStrLn "Uploaded hello.txt"

创建 hello.txt，然后使用项目选定的构建工具与 resolver 运行程序。仓库的示例目录与 API 参考涵盖流处理、预签名 URL、加密、通知、对象锁定等操作。

生产检查清单

• 启用 TLS 并验证服务端证书，不要关闭证书校验。
• 从密钥管理系统或受保护的环境中加载凭据。
• 只授予应用实际需要的存储桶与对象权限。
• 同时固定并验证 GHC、resolver、SDK、TLS 与 HTTP 依赖版本。
• 定义超时，并显式处理 MinioErr、重试、资源清理与未完成的分段上传。

服务端策略配置见身份与访问管理。

8 - Rust 快速入门指南

MinIO Rust SDK

SILO 实现兼容 S3 的服务端契约，因此 Rust 应用可以直接使用上游 MinIO Rust SDK。该 crate 提供异步、强类型的请求构建器 API。

安装软件包

在 Cargo.toml 中加入 SDK 与 Tokio 运行时：

[dependencies]
minio = "0.4.0"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

配置连接

export S3_ENDPOINT=http://127.0.0.1:9000
export S3_ACCESS_KEY=silo-admin
export S3_SECRET_KEY=replace-with-a-strong-secret

S3_ENDPOINT 是包含 http:// 或 https:// 协议的完整 URL。请把凭据保存在源码仓库之外。

创建存储桶并上传对象

use minio::s3::builders::ObjectContent;
use minio::s3::creds::StaticProvider;
use minio::s3::http::BaseUrl;
use minio::s3::response::BucketExistsResponse;
use minio::s3::types::{BucketName, ObjectKey, S3Api};
use minio::s3::{MinioClient, MinioClientBuilder};
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let endpoint = env::var("S3_ENDPOINT")?;
    let access_key = env::var("S3_ACCESS_KEY")?;
    let secret_key = env::var("S3_SECRET_KEY")?;

    let base_url = endpoint.parse::<BaseUrl>()?;
    let provider = StaticProvider::new(&access_key, &secret_key, None);
    let client: MinioClient = MinioClientBuilder::new(base_url)
        .provider(Some(provider))
        .build()?;

    let bucket = BucketName::new("rust-quickstart")?;
    let object = ObjectKey::new("hello.txt")?;

    let exists: BucketExistsResponse = client
        .bucket_exists(bucket.clone())?
        .build()
        .send()
        .await?;

    if !exists.exists() {
        client
            .create_bucket(bucket.clone())?
            .build()
            .send()
            .await?;
    }

    client
        .put_object_content(
            bucket,
            object,
            ObjectContent::from("hello from SILO\n"),
        )?
        .build()
        .send()
        .await?;

    println!("Uploaded hello.txt");
    Ok(())
}

使用 cargo run 运行示例。仓库的维护中示例与 API 文档涵盖文件上传、流处理、加密、通知、对象锁定等操作。

生产检查清单

• 启用 TLS，并验证服务端证书。
• 从密钥管理系统或受保护的环境中加载凭据。
• 只授予应用实际需要的存储桶与对象权限。
• 同时固定并验证 Rust 工具链、SDK、Tokio、HTTP、TLS 与密码学特性。
• 定义超时，并显式处理错误、重试、任务取消与未完成的分段上传。

服务端策略配置见身份与访问管理。

9 - 软件开发工具包（SDK）

MinIO 提供以下软件开发工具包（SDK）：

• Go
• Python
• Java
• .NET
• JavaScript
• Haskell
• C++
• Rust

Go

GitHub: minio/minio-go

最新版本：GOVERSION

快速入门：Go 快速入门指南

参考：MinIO Go SDK API

通过 GitHub 下载

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

Python

GitHub: minio/minio-py

最新版本：PYTHONVERSION

快速入门：Python 快速入门指南

参考：MinIO Python SDK

安装

• pip

  pip3 install minio

• 源码

  git clone https://github.com/minio/minio-py
  cd minio-py
  python setup.py install

Java

GitHub: minio/minio-java

最新版本：JAVAVERSION

快速入门：Java 快速入门指南

参考：MinIO Java SDK

安装

• Maven

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

• Gradle

  dependencies {
      implementation("io.minio:minio:JAVAVERSION")
  }

• JAR

  从 Sonatype Maven Central Repository 下载与 SDK 版本 JAVAVERSION 对应的最新 JAR 文件。

.NET

GitHub: minio/minio-dotnet

最新版本：DOTNETVERSION

快速入门：.NET 快速入门指南

参考：MinIO .NET SDK

从 NuGet 下载

在 NuGet Package Manager Console 中运行以下命令。

PM> Install-Package Minio

JavaScript

GitHub: minio/minio-js

最新版本：JAVASCRIPTVERSION

快速入门：JavaScript 快速入门指南

参考：MinIO JavaScript SDK

安装

• NPM

  npm install --save minio

• 源码

  git clone https://github.com/minio/minio-js
  cd minio-js
  npm install
  npm install -g

Haskell

GitHub: minio/minio-hs

最新版本：HASKELLVERSION

快速入门：Haskell 快速入门指南

安装

将 minio-hs 添加到项目 .cabal 的 dependencies 部分。

或

如果你使用 hpack，请将 minio-hs 添加到 package.yaml 文件中。

C++

GitHub: minio/minio-cpp

参考：MinIO C++ SDK Reference

安装

• vcpkg

  vcpkg install minio-cpp

• 源码

  git clone https://github.com/minio/minio-cpp
  cd minio-cpp
  wget --quiet -O vcpkg-master.zip https://github.com/microsoft/vcpkg/archive/refs/heads/master.zip
  unzip -qq vcpkg-master.zip
  ./vcpkg-master/bootstrap-vcpkg.sh
  ./vcpkg-master/vcpkg integrate install
  cmake -B ./build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=./vcpkg-master/scripts/buildsystems/vcpkg.cmake
  cmake --build ./build --config Debug

Rust

GitHub: minio/minio-rs

最新版本

RUSTVERSION

参考：MinIO Rust SDK Reference

快速入门：Rust 快速入门指南

10 - Security Token Service (STS)

MinIO Security Token Service (STS) APIs 允许应用程序生成用于访问 MinIO 部署的临时凭证。

对于配置为使用外部身份管理器的 MinIO 部署，STS API 是 必需 的，因为该 API 可将外部 IDP 凭证转换为兼容 AWS Signature v4 的凭证。

STS API 端点

MinIO 支持以下 STS API 端点：

10.1 - AssumeRoleWithCustomToken

MinIO Security Token Service (STS) 的 AssumeRoleWithCustomToken API 端点会生成一个令牌，用于配合 MinIO External Identity Management Plugin 使用。

请求端点

AssumeRoleWithCustomToken 端点的格式如下：

POST https://minio.example.net?Action=AssumeRoleWithCustomToken[&ARGS]

以下示例使用了所有受支持的参数。 请将 minio.example.net 主机名替换为你的 MinIO 集群对应 URL：

POST https://minio.example.net?Action=AssumeRoleWithCustomToken
&Token=TOKEN
&Version=2011-06-15
&DurationSeconds=86000
&RoleArn="external-auth-provider"

请求查询参数

此端点支持以下查询参数：

响应元素

MinIO 返回一个 AssumeRoleWithCustomTokenResult 对象，其中 AssumedRoleUser.Credentials 对象包含 MinIO 生成的临时凭证：

• AccessKeyId - 应用程序用于认证的访问密钥。
• SecretKeyId - 应用程序用于认证的 Secret Key。
• Expiration - 凭证过期的 RFC3339 日期和时间。
• SessionToken - 应用程序用于认证的会话令牌。某些 SDK 在使用临时凭证时可能要求此字段。

以下示例与 MinIO STS AssumeRoleWithCustomToken 端点返回的响应类似：

<?xml version="1.0" encoding="UTF-8"?>
<AssumeRoleWithCustomTokenResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
<AssumeRoleWithCustomTokenResult>
   <Credentials>
      <AccessKeyId>ACCESS_KEY</AccessKeyId>
      <SecretAccessKey>SECRET_KEY</SecretAccessKey>
      <Expiration>YYYY-MM-DDTHH:MM:SSZ</Expiration>
      <SessionToken>TOKEN</SessionToken>
   </Credentials>
   <AssumedUser>custom:Alice</AssumedUser>
</AssumeRoleWithCustomTokenResult>
<ResponseMetadata>
   <RequestId>UNIQUE_ID</RequestId>
</ResponseMetadata>
</AssumeRoleWithCustomTokenResponse>

错误元素

此 API 端点的 XML 错误响应与 AWS AssumeRoleWithWebIdentity response 类似。

10.2 - AssumeRoleWithLDAPIdentity

MinIO Security Token Service (STS) AssumeRoleWithLDAPIdentity API 端点使用 Active Directory 或 LDAP 用户凭据生成临时访问凭据。本文档介绍 MinIO 服务端 AssumeRoleWithLDAPIdentity 端点。有关如何使用兼容 S3 的 SDK 实现 STS，请参考对应 SDK 的文档。

MinIO STS AssumeRoleWithLDAPIdentity API 端点以 AWS AssumeRoleWithWebIdentity 端点为模型，并共享部分请求/响应元素。本文档介绍 MinIO 特有的语法，并为 所有共享元素提供指向 AWS 参考文档的链接。

请求端点

AssumeRoleWithLDAPIdentity 端点格式如下：

POST https://minio.example.net?Action=AssumeRoleWithLDAPIdentity[&ARGS]

以下示例使用了所有受支持参数。请将 minio.example.net 主机名替换为你的 MinIO 集群对应的 URL：

POST https://minio.example.net?Action=AssumeRoleWithLDAPIdentity
&LDAPUsername=USERNAME
&LDAPPassword=PASSWORD
&Version=2011-06-15
&Policy={}

请求查询参数

该端点支持以下查询参数：

响应元素

此 API 端点的 XML 响应与 AWS 的 AssumeRoleWithLDAPIdentity response. 类似。具体而言，MinIO 返回 AssumeRoleWithLDAPIdentityResult 对象，其中 AssumedRoleUser.Credentials 对象包含 MinIO 生成的临时凭据：

• AccessKeyId - 应用用于认证的访问密钥。
• SecretKeyId - 应用用于认证的密钥。
• Expiration - 凭据过期时间，采用 RFC3339 日期时间格式。
• SessionToken - 应用用于认证的会话令牌。某些 SDK 在使用临时凭据时可能需要此字段。

以下示例与 MinIO STS AssumeRoleWithLDAPIdentity 端点返回的响应类似：

<?xml version="1.0" encoding="UTF-8"?>
<AssumeRoleWithLDAPIdentityResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
<AssumeRoleWithLDAPIdentityResult>
   <AssumedRoleUser>
      <Arn/>
      <AssumeRoleId/>
   </AssumedRoleUser>
   <Credentials>
      <AccessKeyId>Y4RJU1RNFGK48LGO9I2S</AccessKeyId>
      <SecretAccessKey>sYLRKS1Z7hSjluf6gEbb9066hnx315wHTiACPAjg</SecretAccessKey>
      <Expiration>2019-08-08T20:26:12Z</Expiration>
      <SessionToken>eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3NLZXkiOiJZNFJKVTFSTkZHSzQ4TEdPOUkyUyIsImF1ZCI6IlBvRWdYUDZ1Vk80NUlzRU5SbmdEWGo1QXU1WWEiLCJhenAiOiJQb0VnWFA2dVZPNDVJc0VOUm5nRFhqNUF1NVlhIiwiZXhwIjoxNTQxODExMDcxLCJpYXQiOjE1NDE4MDc0NzEsImlzcyI6Imh0dHBzOi8vbG9jYWxob3N0Ojk0NDMvb2F1dGgyL3Rva2VuIiwianRpIjoiYTBiMjc2MjktZWUxYS00M2JmLTg3MzktZjMzNzRhNGNkYmMwIn0.ewHqKVFTaP-j_kgZrcOEKroNUjk10GEp8bqQjxBbYVovV0nHO985VnRESFbcT6XMDDKHZiWqN2vi_ETX_u3Q-w</SessionToken>
   </Credentials>
</AssumeRoleWithLDAPIdentityResult>
<ResponseMetadata/>
</AssumeRoleWithLDAPIdentityResponse>

错误元素

此 API 端点的 XML 错误响应与 AWS 的 AssumeRoleWithLDAPIdentity response.

10.3 - AssumeRoleWithWebIdentity

MinIO Security Token Service (STS) AssumeRoleWithWebIdentity API 端点使用由 已配置的 OpenID Identity Provider (IDP) 返回的 JSON Web Token (JWT) 生成临时访问凭证。本文档说明 MinIO 服务器的 AssumeRoleWithWebIdentity 端点。关于如何使用 S3 兼容 SDK 实现 STS，请参阅对应 SDK 的文档。

MinIO STS AssumeRoleWithWebIdentity API 端点参考了 AWS AssumeRoleWithWebIdentity 端点，并共享部分请求/响应元素。本文档说明 MinIO 特有语法，并链接到 AWS 参考文档以获取 所有共享元素的说明。

请求端点

AssumeRoleWithWebIdentity 端点格式如下：

POST https://minio.example.net?Action=AssumeRoleWithWebIdentity[&ARGS]

以下示例使用了所有受支持参数。请将 minio.example.net 主机名替换为你的 MinIO 集群对应 URL：

POST https://minio.example.net?Action=AssumeRoleWithWebIdentity
&WebIdentityToken=TOKEN
&Version=2011-06-15
&DurationSeconds=86000
&Policy={}

请求查询参数

该端点支持以下查询参数：

响应元素

该 API 端点的 XML 响应与 AWS AssumeRoleWithWebIdentity response 类似。具体而言，MinIO 返回 AssumeRoleWithWebIdentityResult 对象， 其中 AssumedRoleUser.Credentials 对象包含 MinIO 生成的临时 凭证：

• AccessKeyId - 应用用于认证的访问密钥。
• SecretKeyId - 应用用于认证的 Secret Key。
• Expiration - 凭证过期的 RFC3339 日期和时间。
• SessionToken - 应用用于认证的会话 token。某些 SDK 在使用临时凭证时可能需要此字段。

以下示例与 MinIO STS AssumeRoleWithWebIdentity 端点返回的响应类似：

<?xml version="1.0" encoding="UTF-8"?>
<AssumeRoleWithWebIdentityResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
<AssumeRoleWithWebIdentityResult>
   <AssumedRoleUser>
      <Arn/>
      <AssumeRoleId/>
   </AssumedRoleUser>
   <Credentials>
      <AccessKeyId>Y4RJU1RNFGK48LGO9I2S</AccessKeyId>
      <SecretAccessKey>sYLRKS1Z7hSjluf6gEbb9066hnx315wHTiACPAjg</SecretAccessKey>
      <Expiration>2019-08-08T20:26:12Z</Expiration>
      <SessionToken>eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3NLZXkiOiJZNFJKVTFSTkZHSzQ4TEdPOUkyUyIsImF1ZCI6IlBvRWdYUDZ1Vk80NUlzRU5SbmdEWGo1QXU1WWEiLCJhenAiOiJQb0VnWFA2dVZPNDVJc0VOUm5nRFhqNUF1NVlhIiwiZXhwIjoxNTQxODExMDcxLCJpYXQiOjE1NDE4MDc0NzEsImlzcyI6Imh0dHBzOi8vbG9jYWxob3N0Ojk0NDMvb2F1dGgyL3Rva2VuIiwianRpIjoiYTBiMjc2MjktZWUxYS00M2JmLTg3MzktZjMzNzRhNGNkYmMwIn0.ewHqKVFTaP-j_kgZrcOEKroNUjk10GEp8bqQjxBbYVovV0nHO985VnRESFbcT6XMDDKHZiWqN2vi_ETX_u3Q-w</SessionToken>
   </Credentials>
</AssumeRoleWithWebIdentityResult>
<ResponseMetadata/>
</AssumeRoleWithWebIdentityResponse>

错误元素

该 API 端点的 XML 错误响应与 AWS AssumeRoleWithWebIdentity response 类似。

11 - 使用 Object Lambda 进行转换

MinIO 的 Object Lambda 使开发者能够按需以编程方式转换对象。 你可以根据具体用例按需转换对象，例如脱敏个人身份信息（PII）、使用其他来源的信息增强数据，或在不同格式之间进行转换。

概述

Object Lambda handler 是一个小型代码模块，用于转换对象内容并返回结果。 与 Amazon S3 Object Lambda functions 类似，你可以从应用程序发起 GET 请求来触发 MinIO Object Lambda handler 函数。 handler 从 MinIO 获取请求的对象，执行转换后将修改后的数据返回给 MinIO，再由 MinIO 发送回原始应用程序。 原始对象保持不变。

每个 handler 都是独立进程，且多个 handler 可以转换同一份数据。 这使你可以将同一个对象用于不同目的，而无需维护原始对象的多个版本。

Object Lambda Handlers

你可以使用任何能够发送和接收 HTTP 请求的语言编写 handler 函数。 该函数必须能够：

• 监听 HTTP POST 请求。
• 使用 URL 获取原始对象。
• 返回转换后的内容和授权令牌。

创建函数

handler 函数应执行以下步骤：

1. 从传入的 POST 请求中提取对象详细信息。

   JSON 请求负载中的 getObjectContext 属性包含原始对象的详细信息。 要构造响应，你需要以下值：

   值	说明
   inputS3Url	原始对象的 presigned URL。 调用应用程序会生成该 URL，并在原始请求中发送它。 这使 handler 无需通常所需的 MinIO 凭证即可访问原始对象。 该 URL 的有效期为一小时。
   outputRoute	允许 MinIO 验证转换后对象目标位置的令牌。 在响应中的 x-amz-request-route header 返回该值。
   outputToken	允许 MinIO 验证响应的令牌。 在响应中的 x-amz-request-token header 返回该值。

2. 从 MinIO 获取原始对象。

   使用 presigned URL 从 MinIO 部署中获取对象。 对象内容位于响应体中。

3. 按需转换对象。

   执行生成转换后对象所需的任意操作。 由于调用应用程序正在等待响应，你可能希望避免潜在的长时间运行操作。

4. 构造包含以下信息的响应：

   • 转换后对象的内容。
   • 带有 outputRoute 令牌的 x-amz-request-route header。
   • 带有 outputToken 令牌的 x-amz-request-token header。

5. 将响应返回给 Object Lambda。

   MinIO 会验证响应，并将转换后的数据发送回原始调用应用程序。

注册 Handler

要使 MinIO 能够调用 handler，请使用以下 MinIO server Object Lambda environment variables 将 handler 函数注册为 webhook：

MINIO_LAMBDA_WEBHOOK_ENABLE_functionname

为某个 handler 函数启用或禁用 Object Lambda。 对于多个 handler，请为每个函数名设置该环境变量。

MINIO_LAMBDA_WEBHOOK_ENDPOINT_functionname

为某个 handler 函数注册 endpoint。 对于多个 handler，请为每个函数 endpoint 设置该环境变量。

MinIO 还支持以下用于已认证 webhook endpoint 的环境变量：

MINIO_LAMBDA_WEBHOOK_AUTH_TOKEN_functionanme

指定用于 webhook 认证的 opaque string 或 JWT 授权令牌。

MINIO_LAMBDA_WEBHOOK_CLIENT_CERT_functionname

指定用于 webhook mTLS 认证的客户端证书。

MINIO_LAMBDA_WEBHOOK_CLIENT_KEY_functionname

指定用于 webhook mTLS 认证的私钥。

重启 MinIO 以应用更改。

或者，也可以通过 MinIO Client 命令行工具配置 Object Lambda。 更多信息请参见 Object Lambda 函数设置。

从应用程序触发

要从应用程序请求转换后的对象：

1. 连接到 MinIO 部署。

2. 通过添加 lambdaArn 参数并设置目标 handler 的 ARN，设置 Object Lambda 目标。

3. 为原始对象生成 presigned URL。

4. 使用生成的 URL 获取转换后的对象。

   MinIO 将请求发送到目标 Object Lambda handler。 handler 将转换后的内容返回给 MinIO，MinIO 会验证该响应并将其返回给应用程序。

示例

使用 Python、Go 和 curl 转换对象内容：

• 创建并注册一个 Object Lambda handler。
• 创建一个存储桶和要转换的对象。
• 请求并显示转换后的对象内容。

前提条件：

• 已存在的 MinIO 部署
• 可用的 Python（3.8+）和 Golang 开发环境
• The MinIO Go SDK

创建 Handler

示例 handler 使用 Python 编写，使用调用方生成的 presigned URL 获取目标对象。 随后，handler 转换对象内容并返回新文本。 它使用 Flask web framework 和 Python 3.8+。

以下命令安装 Flask 和其他所需依赖：

pip install flask requests

handler 调用 swapcase() 来切换原始文本中每个字母的大小写。 随后它将结果发送回 MinIO，再由 MinIO 返回给调用方。

from flask import Flask, request, abort, make_response
import requests

app = Flask(__name__)
@app.route('/', methods=['POST'])
def get_webhook():
   if request.method == 'POST':
      # Get the request event from the 'POST' call
      event = request.json

      # Get the object context
      object_context = event["getObjectContext"]

      # Get the presigned URL
      # Used to fetch the original object from MinIO
      s3_url = object_context["inputS3Url"]

      # Extract the route and request tokens from the input context
      request_route = object_context["outputRoute"]
      request_token = object_context["outputToken"]

      # Get the original S3 object using the presigned URL
      r = requests.get(s3_url)
      original_object = r.content.decode('utf-8')

      # Transform the text in the object by swapping the case of each char
      transformed_object = original_object.swapcase()

      # Return the object back to Object Lambda, with required headers
      # This sends the transformed data to MinIO
      # and then to the user
      resp = make_response(transformed_object, 200)
      resp.headers['x-amz-request-route'] = request_route
      resp.headers['x-amz-request-token'] = request_token
      return resp

   else:
      abort(400)

if __name__ == '__main__':
   app.run()

启动 Handler

使用以下命令在本地开发环境中启动 handler：

python lambda_handler.py

输出类似如下：

 * Serving Flask app 'lambda_handler'
 * Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit

启动 MinIO

handler 运行后，使用 MINIO_LAMBDA_WEBHOOK_ENABLE 和 MINIO_LAMBDA_WEBHOOK_ENDPOINT 环境变量启动 MinIO，以将该函数注册到 MinIO。 要标识具体的 Object Lambda handler，请将函数名追加到环境变量名后。

以下命令在本地开发环境中启动 MinIO：

MINIO_LAMBDA_WEBHOOK_ENABLE_myfunction=on MINIO_LAMBDA_WEBHOOK_ENDPOINT_myfunction=http://localhost:5000 minio server /data

将 myfunction 替换为你的 handler 函数名，并将 /data 替换为本地部署中 MinIO 目录的位置。 输出类似如下：

MinIO Object Storage Server
Copyright: 2015-2023 MinIO, Inc.
License: GNU AGPLv3 <https://www.gnu.org/licenses/agpl-3.0.html>
Version: RELEASE.2023-03-24T21-41-23Z (go1.19.7 linux/arm64)

Status:         1 Online, 0 Offline.
API: http://192.168.64.21:9000  http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin
Object Lambda ARNs: arn:minio:s3-object-lambda::myfunction:webhook

测试 Handler

要测试 Lambda handler 函数，请先创建一个待转换对象。 然后调用 handler，本例中使用 Go 函数生成的 presigned URL 配合 curl 调用。

1. 创建供 handler 转换的存储桶和对象。

   mc alias set myminio/ http://localhost:9000 minioadmin minioadmin
   mc mb myminio/myfunctionbucket
   cat > testobject << EOF
   Hello, World!
   EOF
   mc cp testobject myminio/myfunctionbucket/

2. 调用 Handler

   以下 Go 代码使用 The MinIO Go SDK 生成 presigned URL 并打印到 stdout。

   package main
   
   import (
      "context"
      "log"
      "net/url"
      "time"
      "fmt"
   
      "github.com/minio/minio-go/v7"
      "github.com/minio/minio-go/v7/pkg/credentials"
   )
   
   func main() {
   
      // Connect to the MinIO deployment
      s3Client, err := minio.New("localhost:9000", &minio.Options{
         Creds:  credentials.NewStaticV4("my_admin_user", "my_admin_password", ""),
         Secure: false,
      })
      if err != nil {
         log.Fatalln(err)
      }
   
      // Set the Lambda function target using its ARN
      reqParams := make(url.Values)
      reqParams.Set("lambdaArn", "arn:minio:s3-object-lambda::myfunction:webhook")
   
      // Generate a presigned url to access the original object
      presignedURL, err := s3Client.PresignedGetObject(context.Background(), "myfunctionbucket", "testobject", time.Duration(1000)*time.Second, reqParams)
      if err != nil {
         log.Fatalln(err)
      }
   
      // Print the URL to stdout
      fmt.Println(presignedURL)
   }

   在上述代码中，替换以下值：

   • 将 my_admin_user 和 my_admin_password 替换为 MinIO 部署的用户凭证。
   • 将 myfunction 替换为在 MINIO_LAMBDA_WEBHOOK_ENABLE 和 MINIO_LAMBDA_WEBHOOK_ENDPOINT 环境变量中设置的相同函数名。

   要获取转换后的对象，执行该 Go 代码并使用 curl 生成 GET 请求：

   curl -v $(go run presigned.go)

   curl 会运行 Go 代码，然后通过对 presigned URL 发起 GET 请求来获取对象。 输出类似如下：

   *   Trying 127.0.0.1:9000...
   * Connected to localhost (127.0.0.1) port 9000 (#0)
   > GET /myfunctionbucket/testobject?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=minioadmin%2F20230406%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20230406T184749Z&X-Amz-Expires=1000&X-Amz-SignedHeaders=host&lambdaArn=arn%3Aminio%3As3-object-lambda%3A%3Amyfunction%3Awebhook&X-Amz-Signature=68fe7e03929a7c0da38255121b2ae09c302840c06654d1b79d7907d942f69915 HTTP/1.1
   > Host: localhost:9000
   > User-Agent: curl/7.81.0
   > Accept: */*
   >
   * Mark bundle as not supporting multiuse
   < HTTP/1.1 200 OK
   < Content-Security-Policy: block-all-mixed-content
   < Strict-Transport-Security: max-age=31536000; includeSubDomains
   < Vary: Origin
   < Vary: Accept-Encoding
   < X-Amz-Id-2: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
   < X-Amz-Request-Id: 17536CF16130630E
   < X-Content-Type-Options: nosniff
   < X-Xss-Protection: 1; mode=block
   < Date: Thu, 06 Apr 2023 18:47:49 GMT
   < Content-Length: 14
   < Content-Type: text/plain; charset=utf-8
   <
   hELLO, wORLD!
   * Connection #0 to host localhost left intact

12 - 文件传输协议 (FTP/SFTP)

• 使用 FTP 和 SFTP 与 MinIO 进行文件传输

支持的协议

支持的命令

启用后，MinIO 支持以下 SFTP 操作：

• get
• put
• ls
• mkdir
• rmdir
• delete

MinIO 不支持 append 或 rename 操作。

注意事项

版本控制

SFTP 客户端只能操作对象的 当前版本。 具体来说：

• 对于读取操作，MinIO 只会向 SFTP 客户端返回所请求对象的最新版本。
• 对于写入操作，MinIO 会应用正常的版本控制行为，并在指定命名空间中创建新的对象版本。 rm 和 rmdir 操作会创建 DeleteMarker 对象。

身份验证与访问控制

SFTP 访问与其他 S3 客户端一样，使用相同的身份验证机制。 MinIO 支持以下身份验证提供方：

• MinIO IDP 用户及其服务账户
• Active Directory/LDAP 用户及其服务账户
• OpenID/OIDC 服务账户

STS 凭证 不能 通过 SFTP 访问存储桶或对象。

已通过身份验证的用户可依据分配给该用户或其父用户账号的 策略 访问存储桶和对象。

SFTP 协议不需要任何 admin:* 权限。 你不能通过 SFTP 执行其他 MinIO 管理操作。

前提条件

操作步骤

kubectl get tenants/my-tenant -n my-tenant-ns -o yaml | yq '.spec.features'

enableSFTP: true

minio server http://server{1...4}/disk{1...4} \
--ftp="address=:8021"                         \
--ftp="passive-port-range=30000-40000"        \
--ftp="tls-private-key=path/to/private.key"   \
--ftp="tls-public-cert=path/to/public.crt"    \
...

minio server http://server{1...4}/disk{1...4}        \
--ftp="address=:8021"                                \
--ftp="passive-port-range=30000-40000"               \
--sftp="address=:8022"                               \
--sftp="ssh-private-key=/home/miniouser/.ssh/id_rsa" \
...

MinIO FTP Server listening on :8021
MinIO SFTP Server listening on :8022

> sftp -P 8022 minio@localhost
minio@localhost's password:
Connected to localhost.
sftp> ls runner/
chunkdocs  testdir

> ftp localhost -P 8021
Connected to localhost.
220 Welcome to MinIO FTP Server
Name (localhost:user): minio
331 User name ok, password required
Password:
230 Password ok, continue
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> ls runner/
229 Entering Extended Passive Mode (|||39155|)
150 Opening ASCII mode data connection for file list
drwxrwxrwx 1 nobody nobody            0 Jan  1 00:00 chunkdocs/
drwxrwxrwx 1 nobody nobody            0 Jan  1 00:00 testdir/
...

> sftp -P 8022 minio@localhost
minio@localhost's password:
Connected to localhost.
sftp> ls runner/
chunkdocs  testdir
sftp> get runner/chunkdocs/metadata metadata
Fetching /runner/chunkdocs/metadata to metadata
metadata                               100%  226    16.6KB/s   00:00
sftp>

> ftp localhost -P 8021
Connected to localhost.
220 Welcome to MinIO FTP Server
Name (localhost:user): minio
331 User name ok, password required
Password:
230 Password ok, continue
Remote system type is UNIX.
Using binary mode to transfer files.ftp> ls runner/chunkdocs/metadata
229 Entering Extended Passive Mode (|||44269|)
150 Opening ASCII mode data connection for file list
-rwxrwxrwx 1 nobody nobody           45 Apr  1 06:13 chunkdocs/metadata
226 Closing data connection, sent 75 bytes
ftp> get
(remote-file) runner/chunkdocs/metadata
(local-file) test
local: test remote: runner/chunkdocs/metadata
229 Entering Extended Passive Mode (|||37785|)
150 Data transfer starting 45 bytes
   45        3.58 KiB/s
226 Closing data connection, sent 45 bytes
45 bytes received in 00:00 (3.55 KiB/s)
...