MinIO: 入门指南

如何开始使用 MinIO 进行 S3 兼容的对象存储

👋 欢迎来到 Stackhero 文档！

Stackhero 提供即用型 MinIO Object Storage 解决方案，具有多种优势，包括：

无限传输。

简单、可预测且透明的定价。

使用 HTTPS 保护的可定制域名（例如，https://object-storage.your-company.com）。

只需点击即可轻松更新。

由私有和专用 VM提供的最佳性能和强大安全性。

在🇪🇺 欧洲和🇺🇸 美国均可用。

节省时间并简化您的生活：只需 5 分钟即可试用 Stackhero 的 MinIO Object Storage hosting 解决方案！

MinIO 是一个实现了 Amazon S3 协议的对象存储服务。任何兼容 Amazon S3 的客户端都可以连接到 MinIO，并无缝地与您的对象存储进行交互。几乎所有主要编程语言都有可用的 Amazon S3 客户端库，包括 Ruby、Node.js、Java、Python、Clojure 和 Erlang。

我们建议使用 MinIO SDK 来连接您的对象存储。您可以在 MinIO 官方文档中找到可用 SDK 的完整列表。

或者，您可以使用 MinIO CLI。它特别适合直接从终端管理大文件。有关使用 MinIO CLI 的详细指南，请参阅 MinIO CLI 官方文档。

使用 MinIO CLI

您的 Stackhero for MinIO 实例默认包含 MinIO Console Web UI。对于更高级的任务，您可以选择使用 MinIO CLI。

尝试 MinIO CLI 的最简单方法是运行其 Docker 容器。请按照以下步骤操作：

启动容器：

docker run -it --entrypoint=/bin/sh minio/mc

在容器内，使用以下命令添加您的服务器（相应替换占位符值）：

mc alias set minio https://<XXXXXX>.stackhero-network.com <ROOT_ACCESS_KEY> <MINIO_ROOT_SECRET_KEY>

创建一个名为 "test" 的存储桶以验证设置：
```
mc mb minio/test
```
列出您的存储桶：
```
mc ls minio
```

您可以通过运行 mc --help 查看更多 MinIO CLI 命令。

将 Ruby 连接到 MinIO

首先，安装 AWS SDK gem：

gem install aws-sdk
bundle install

下面是一个简单的示例，演示如何使用 AWS SDK 在 Ruby 中与 MinIO 交互：

require 'aws-sdk'

Aws.config.update(
  endpoint: 'https://<XXXXXX>.stackhero-network.com',
  access_key_id: 'YOUR_ACCESS_KEY',
  secret_access_key: 'YOUR_SECRET_KEY',
  force_path_style: true,
  region: 'us-east-1'
)

rubys3_client = Aws::S3::Client.new

# put_object 操作
rubys3_client.put_object(
  key: 'testobject',
  body: 'Hello from MinIO!',
  bucket: 'testbucket',
  content_type: 'text/plain'
)

# get_object 操作
rubys3_client.get_object(
  bucket: 'testbucket',
  key: 'testobject',
  response_target: 'download_testobject'
)

print "Downloaded 'testobject' as 'download_testobject'."

有关更多详细信息，请查看 MinIO Ruby 文档。

将 Python 连接到 MinIO

有两种主要方法可以将 Python 应用程序连接到 MinIO。

使用 AWS SDK (boto) 连接到 MinIO

首先，安装 AWS SDK 包 (boto3)：

pip install boto3
pip freeze > requirements.txt

以下示例演示如何使用 boto3 连接到 MinIO：

#!/usr/bin/env python
import os
import boto3
from botocore.client import Config

s3 = boto3.resource('s3',
                    endpoint_url='https://<XXXXXX>.stackhero-network.com',
                    aws_access_key_id='YOUR_ACCESS_KEY',
                    aws_secret_access_key='YOUR_SECRET_KEY',
                    config=Config(signature_version='s3v4'),
                    region_name='us-east-1')

# 上传本地文件 '/home/john/piano.mp3' 到存储桶 'songs'，对象名为 'piano.mp3'
s3.Bucket('songs').upload_file('/home/john/piano.mp3', 'piano.mp3')

# 从存储桶 'songs' 下载对象 'piano.mp3' 并本地保存为 '/tmp/classical.mp3'
s3.Bucket('songs').download_file('piano.mp3', '/tmp/classical.mp3')

print("'piano.mp3' downloaded as 'classical.mp3'.")

更多详细信息请参阅 MinIO Python 文档。

使用 MinIO SDK 连接到 MinIO

或者，您可以使用 MinIO SDK for Python。首先，安装 MinIO 包：

pip install minio
pip freeze > requirements.txt

下面是一个示例，展示如何使用 MinIO SDK 连接到 MinIO：

#!/usr/bin/env python
from minio import Minio
from minio.error import S3Error

def main():
  # 使用您的访问和密钥创建 MinIO 服务器的客户端
  client = Minio(
    endpoint='<XXXXXX>.stackhero-network.com:443',
    secure=True,
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
  )

  # 检查存储桶 'asiatrip' 是否存在，如果不存在则创建
  found = client.bucket_exists("asiatrip")
  if not found:
    client.make_bucket("asiatrip")
  else:
    print("Bucket 'asiatrip' already exists")

  # 上传 '/home/user/Photos/asiaphotos.zip' 为 'asiaphotos-2015.zip' 到存储桶 'asiatrip'
  client.fput_object(
    "asiatrip", "asiaphotos-2015.zip", "/home/user/Photos/asiaphotos.zip"
  )
  print(
    "'/home/user/Photos/asiaphotos.zip' has been successfully uploaded as "
    "object 'asiaphotos-2015.zip' to bucket 'asiatrip'."
  )


if __name__ == "__main__":
  try:
    main()
  except S3Error as exc:
    print("An error occurred.", exc)

有关更多信息，请参阅 MinIO Python SDK 文档。

将 PHP 连接到 MinIO

要将 PHP 连接到 MinIO，首先安装 AWS SDK for PHP 包：

composer require aws/aws-sdk-php

下面的示例展示了如何使用 AWS SDK 从 PHP 连接到 MinIO：

<?php

// 使用 Composer 自动加载器包含 SDK
date_default_timezone_set('America/Los_Angeles');
require 'vendor/autoload.php';

$s3 = new Aws\S3\S3Client([
  'version' => 'latest',
  'region'  => 'us-east-1',
  'endpoint' => 'https://<XXXXXX>.stackhero-network.com',
  'use_path_style_endpoint' => true,
  'credentials' => [
    'key'    => 'YOUR_ACCESS_KEY',
    'secret' => 'YOUR_SECRET_KEY'
  ],
]);

// 发送 PutObject 请求并获取结果。
$insert = $s3->putObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'Body'   => 'Hello from MinIO!'
]);

// 下载对象的内容。
$retrieve = $s3->getObject([
  'Bucket' => 'testbucket',
  'Key'    => 'testkey',
  'SaveAs' => 'testkey_local'
]);

// 打印检索结果的主体。
echo $retrieve['Body'];

将 Go 连接到 MinIO

有两种选择可以将 Go 应用程序连接到 MinIO。

使用 AWS SDK 连接到 MinIO

首先，安装 AWS SDK for Go 包：

go get github.com/aws/aws-sdk-go-v2
go get github.com/aws/aws-sdk-go-v2/config

下面是一个使用 AWS SDK 从 Go 连接到 MinIO 的示例：

package main

import (
  "fmt"
  "os"
  "strings"

  "github.com/aws/aws-sdk-go/aws"
  "github.com/aws/aws-sdk-go/aws/credentials"
  "github.com/aws/aws-sdk-go/aws/session"
  "github.com/aws/aws-sdk-go/service/s3"
  "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

func main() {
  bucket := aws.String("newbucket")
  key := aws.String("testobject")

  // 配置使用 MinIO 服务器
  s3Config := &aws.Config{
    Credentials:      credentials.NewStaticCredentials("YOUR_ACCESS_KEY", "YOUR_SECRET_KEY", ""),
    Endpoint:         aws.String("https://<XXXXXX>.stackhero-network.com"),
    Region:           aws.String("us-east-1"),
    DisableSSL:       aws.Bool(false),
    S3ForcePathStyle: aws.Bool(true),
  }
  newSession := session.New(s3Config)

  s3Client := s3.New(newSession)

  cparams := &s3.CreateBucketInput{
    Bucket: bucket,
  }

  // 创建一个新存储桶
  _, err := s3Client.CreateBucket(cparams)
  if err != nil {
    fmt.Println(err.Error())
    return
  }

  // 上传一个新对象，内容为 "Hello from MinIO!"
  _, err = s3Client.PutObject(&s3.PutObjectInput{
    Body:   strings.NewReader("Hello from MinIO!"),
    Bucket: bucket,
    Key:    key,
  })
  if err != nil {
    fmt.Printf("Failed to upload data to %s/%s, %s\n", *bucket, *key, err.Error())
    return
  }
  fmt.Printf("Successfully created bucket %s and uploaded data with key %s\n", *bucket, *key)

  // 检索我们的对象并本地存储
  file, err := os.Create("testobject_local")
  if err != nil {
    fmt.Println("Failed to create file", err)
    return
  }
  defer file.Close()

  downloader := s3manager.NewDownloader(newSession)
  numBytes, err := downloader.Download(file,
    &s3.GetObjectInput{
      Bucket: bucket,
      Key:    key,
    })
  if err != nil {
    fmt.Println("Failed to download file", err)
    return
  }
  fmt.Println("Downloaded file", file.Name(), numBytes, "bytes")
}

有关更多阅读，请访问 MinIO Go 文档。

使用 MinIO SDK 连接到 MinIO

要使用 MinIO SDK for Go，请安装以下包：

GO111MODULE=on go get github.com/minio/minio-go/v7

下面是一个示例，展示如何使用 MinIO SDK for Go 连接到 MinIO：

package main

import (
  "log"

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

func main() {
  endpoint := "<XXXXXX>.stackhero-network.com"
  accessKeyID := "YOUR_ACCESS_KEY"
  secretAccessKey := "YOUR_SECRET_KEY"
  useSSL := true

  // 初始化 MinIO 客户端
  minioClient, err := minio.New(endpoint, &minio.Options{
    Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
    Secure: useSSL,
  })
  if err != nil {
    log.Fatalln(err)
  }

  log.Printf("%#v\n", minioClient) // minioClient 现在已设置
}

有关更多信息，请参阅 MinIO Go SDK 文档。

将 Node.js 连接到 MinIO

有两种方法可以将 Node.js 应用程序连接到 MinIO。

使用 AWS SDK 连接到 MinIO

首先，安装 AWS SDK for Node.js 包：

npm install aws-sdk

下面是一个示例，展示如何使用 AWS SDK 连接到 MinIO：

const process = require('process');
const AWS = require('aws-sdk');

const s3 = new AWS.S3({
  accessKeyId: 'YOUR_ACCESS_KEY',
  secretAccessKey: 'YOUR_SECRET_KEY',
  endpoint: 'https://<XXXXXX>.stackhero-network.com',
  s3ForcePathStyle: true, // MinIO 需要
  signatureVersion: 'v4'
});

// putObject 操作
s3.putObject(
  { Bucket: 'testbucket', Key: 'testobject', Body: 'Hello from MinIO!' },
  (err, data) => {
    if (err)
      console.log(err);
    else
      console.log('Successfully uploaded data to testbucket/testobject');
  }
);

// getObject 操作
const file = require('fs').createWriteStream('/tmp/mykey');
s3.getObject({ Bucket: 'testbucket', Key: 'testobject' })
  .on('httpData', chunk => file.write(chunk))
  .on('httpDone', () => file.end())
  .send();

有关更多详细信息，请访问 MinIO Node.js 文档。

使用 MinIO SDK 连接到 MinIO

如果您更喜欢使用 MinIO SDK for Node.js，请使用 npm 安装：

npm install minio

下面是一个示例，展示如何使用 MinIO SDK for Node.js 连接到 MinIO：

const process = require('process');
const Minio = require('minio');

// 使用端点和访问密钥实例化 MinIO 客户端
const minioClient = new Minio.Client({
  endpoint: '<XXXXXX>.stackhero-network.com',
  port: 443,
  useSSL: true,
  accessKeyId: 'YOUR_ACCESS_KEY',
  secretAccessKey: 'YOUR_SECRET_KEY',
});

// 要上传的文件
const file = '/tmp/photos-europe.tar';

// 创建一个名为 'europetrip' 的存储桶
minioClient.makeBucket(
  'europetrip',
  'us-east-1',
  err => {
    if (err) return console.log(err);

    console.log('Bucket created successfully in "us-east-1".');

    const metaData = {
      'Content-Type': 'application/octet-stream',
      'X-Amz-Meta-Testing': 1234,
      'example': 5678
    };
    // 使用 fPutObject API 将文件上传到存储桶 'europetrip'
    minioClient.fPutObject(
      'europetrip',
      'photos-europe.tar',
      file,
      metaData,
      (err, etag) => {
        if (err) return console.log(err);
        console.log('File uploaded successfully.');
      }
    );
  }
);

有关更多信息，请参阅 MinIO Node.js SDK 文档。