MyFavMirrors/minio
1
0
Fork 0
mirror of https://github.com/minio/minio.git synced 2024-12-24 06:05:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add chinese translation docs. (#5224)

Browse Source
This commit is contained in:
Harshavardhana 2017-11-22 15:15:40 -08:00 committed by Dee Koder
parent 8b4d7048f8
commit 135a6a7bb4
32 changed files with 3460 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
README_zh_CN.md Normal file
View File

@ -0,0 +1,116 @@
# Minio Quickstart Guide [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。
Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
## Docker 容器
### 稳定版
```
docker pull minio/minio
docker run -p 9000:9000 minio/minio server /data
```
### 尝鲜版
```
docker pull minio/minio:edge
docker run -p 9000:9000 minio/minio:edge server /data
```
更多Docker部署信息请访问 [这里](https://docs.minio.io/docs/minio-docker-quickstart-guide)
## macOS
### Homebrew
使用 [Homebrew](http://brew.sh/)安装minio
```sh
brew install minio/stable/minio
minio server /data
```
#### Note
如果你之前使用 `brew install minio`安装过minio, 可以用 `minio/stable/minio` 官方镜像进行重装. 由于golang 1.8的bug,homebrew版本不太稳定。
```
brew uninstall minio
brew install minio/stable/minio
```
### 下载二进制文件
| 操作系统| CPU架构 | 地址|
| ----------| -------- | ------|
|Apple macOS|64-bit Intel|https://dl.minio.io/server/minio/release/darwin-amd64/minio |
```sh
chmod 755 minio
./minio server /data
```
## GNU/Linux
### 下载二进制文件
| 操作系统| CPU架构 | 地址|
| ----------| -------- | ------|
|GNU/Linux|64-bit Intel|https://dl.minio.io/server/minio/release/linux-amd64/minio |
```sh
chmod +x minio
./minio server /data
```
### 快照版
你可以下载最新版 `minio` [快照](https://snapcraft.io), 并且帮助我们一起验证master分支上[所有支持的Linux发行版](https://snapcraft.io/docs/core/install) 的一些最新修改:
```sh
sudo snap install minio --edge
```
每次有最新的 `minio` 被推送到服务器,你都会自动更新下来.
你需要允许minio snap来观察其安装:
```sh
sudo snap connect minio:mount-observe
```
## 微软Windows系统
### 下载二进制文件
| 操作系统| CPU架构 | 地址|
| ----------| -------- | ------|
|微软Windows系统|64位|https://dl.minio.io/server/minio/release/windows-amd64/minio.exe |
```sh
minio.exe server D:\Photos
```
## FreeBSD
### Port
使用 [pkg](https://github.com/freebsd/pkg)进行安装。
```sh
pkg install minio
sysrc minio_enable=yes
sysrc minio_disks=/home/user/Photos
service minio start
```
## 使用源码安装
采用源码安装仅供开发人员和高级用户使用,如果你还没有Golang环境， 请参考 [How to install Golang](https://docs.minio.io/docs/how-to-install-golang).
```sh
go get -u github.com/minio/minio
```
## 使用Minio浏览器进行验证
安装后使用浏览器访问[http://127.0.0.1:9000](http://127.0.0.1:9000)，如果可以访问，则表示minio已经安装成功。
![Screenshot](https://github.com/minio/minio/blob/master/docs/screenshots/minio-browser.jpg?raw=true)
## 使用Minio客户端 `mc`进行验证
`mc` 提供了一些UNIX常用命令的替代品，像ls, cat, cp, mirror, diff这些。 它支持文件系统和亚马逊S3云存储服务。 更多信息请参考 [mc快速入门](https://docs.minio.io/docs/minio-client-quickstart-guide) 。
## 了解更多
- [Minio纠删码入门](https://docs.minio.io/docs/minio-erasure-code-quickstart-guide)
- [`mc`快速入门](https://docs.minio.io/docs/minio-client-quickstart-guide)
- [使用 `aws-cli`](https://docs.minio.io/docs/aws-cli-with-minio)
- [使用 `s3cmd`](https://docs.minio.io/docs/s3cmd-with-minio)
- [使用 `minio-go` SDK](https://docs.minio.io/docs/golang-client-quickstart-guide)
- [Minio文档](https://docs.minio.io)
## 如何参与到Minio项目
请参考 [贡献者指南](https://github.com/minio/minio/blob/master/CONTRIBUTING.md)。欢迎各位中国程序员加到Minio项目中。

76
docs/zh_CN/FreeBSD.md Normal file
View File

@ -0,0 +1,76 @@
# Minio FreeBSD 快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
### Minio with ZFS backend - FreeBSD
此示例假设你已经有正在运行的FreeBSD 11.x。
#### 启动 ZFS service
```sh
sysrc zfs_enable="YES"
```
启动 ZFS service
```sh
service zfs start
```
在 `/zfs` 文件上配置一个回环设备`loopback device `。
```sh
dd if=/dev/zero of=/zfs bs=1M count=4000
mdconfig -a -t vnode -f /zfs
```
创建zfs池
```sh
zpool create minio-example /dev/md0
```
```sh
df /minio-example
Filesystem 512-blocks Used Avail Capacity Mounted on
minio-example 7872440 38 7872402 0% /minio-example
```
验证其是否可写
```sh
touch /minio-example/testfile
ls -l /minio-example/testfile
-rw-r--r-- 1 root wheel 0 Apr 26 00:51 /minio-example/testfile
```
现在您已经成功创建了一个ZFS池，了解更多，请参考 [ZFS 快速入门](https://www.freebsd.org/doc/handbook/zfs-quickstart.html)
不过，这个池并没有利用ZFS的任何特性。我们可以在这个池上创建一个带有压缩功能的ZFS文件系统，ZFS支持多种压缩算法: [`lzjb`, `gzip`, `zle`, `lz4`]。`lz4` 在数据压缩和系统开销方面通常是最最优的算法。
```sh
zfs create minio-example/compressed-objects
zfs set compression=lz4 minio-example/compressed-objects
```
监控池是否健康
```sh
zpool status -x
all pools are healthy
```
#### 启动Minio服务
从FreeBSD port安装 [Minio](https://minio.io)。
```sh
pkg install minio
```
配置Minio,让其使用挂载在`/minio-example/compressed-objects`的ZFS卷。
```
sysrc minio_enable=yes
sysrc minio_disks=/minio-example/compressed-objects
```
启动Mino。
```
service minio start
```
现在你已经成功的让Minio运行在ZFS上，你上传的对象都获得了磁盘级别的压缩功能，访问 http://localhost:9000。
#### 关闭Minio服务
```sh
service minio stop
```

131
docs/zh_CN/admin-api/README.md Normal file
View File

@ -0,0 +1,131 @@
# 管理REST API
## 认证
- AWS signatureV4
- 我们使用`minio`作为区域。 这里区域仅用于签名计算。
##管理接口
- Service
- Restart
- Status
- SetCredentials
- Locks
- List
- Clear
- Healing
### 服务管理接口
* Restart
- POST /?service
- x-minio-operation: restart
- Response: On success 200
* Status
- GET /?service
- x-minio-operation: status
- Response: On success 200, return json formatted object which contains StorageInfo and ServerVersion structures
* SetCredentials
- GET /?service
- x-minio-operation: set-credentials
- Response: Success 200
- Possible error responses
- ErrMethodNotAllowed
```xml
<Error>
<Code>MethodNotAllowed</Code>
<Message>The specified method is not allowed against this resource.</Message>
<Key></Key>
<BucketName></BucketName>
<Resource>/</Resource>
<RequestId>3L137</RequestId>
<HostId>3L137</HostId>
</Error>
```
- ErrAdminBadCred
```xml
<Error>
<Code>XMinioBadCred</Code>
<Message>XMinioBadCred</Message>
<Key></Key>
<BucketName></BucketName>
<Resource>/</Resource>
<RequestId>3L137</RequestId>
<HostId>3L137</HostId>
</Error>
```
- ErrInternalError
```xml
<Error>
<Code>InternalError</Code>
<Message>We encountered an internal error, please try again.</Message>
<Key></Key>
<BucketName></BucketName>
<Resource>/</Resource>
<RequestId>3L137</RequestId>
<HostId>3L137</HostId>
</Error>
```
### 锁管理API
* ListLocks
- GET /?lock&bucket=mybucket&prefix=myprefix&duration=duration
- x-minio-operation: list
- Response: On success 200, json encoded response containing all locks held, for longer than duration.
- Possible error responses
- ErrInvalidBucketName
```xml
<Error>
<Code>InvalidBucketName</Code>
<Message>The specified bucket is not valid.</Message>
<Key></Key>
<BucketName></BucketName>
<Resource>/</Resource>
<RequestId>3L137</RequestId>
<HostId>3L137</HostId>
</Error>
```
- ErrInvalidObjectName
```xml
<Error>
<Code>XMinioInvalidObjectName</Code>
<Message>Object name contains unsupported characters. Unsupported characters are `^*|\&#34;</Message>
<Key></Key>
<BucketName></BucketName>
<Resource>/</Resource>
<RequestId>3L137</RequestId>
<HostId>3L137</HostId>
</Error>
```
- ErrInvalidDuration
```xml
<Error>
<Code>InvalidDuration</Code>
<Message>Duration provided in the request is invalid.</Message>
<Key></Key>
<BucketName></BucketName>
<Resource>/</Resource>
<RequestId>3L137</RequestId>
<HostId>3L137</HostId>
</Error>
```
* ClearLocks
- POST /?lock&bucket=mybucket&prefix=myprefix&duration=duration
- x-minio-operation: clear
- Response: On success 200, json encoded response containing all locks cleared, for longer than duration.
- Possible error responses, similar to errors listed in ListLocks.
- ErrInvalidBucketName
- ErrInvalidObjectName
- ErrInvalidDuration
### 修复
* ListBucketsHeal
- GET /?heal
- x-minio-operation: list-buckets

8
docs/zh_CN/backend/README.md Normal file
View File

@ -0,0 +1,8 @@
## 后端
Minio目前支持两种类型的后端。
| Minio | FS | Erasure | Stability |
|:-----------:|:----:|:----:|:---:|
| Standalone | x | x | Stable |
| Distributed | x | x | Stable |

24
docs/zh_CN/backend/fs/README.md Normal file
View File

@ -0,0 +1,24 @@
### Backend format `fs.json`
```go
// objectPartInfo Info of each part kept in the multipart metadata
// file after CompleteMultipartUpload() is called.
type objectPartInfo struct {
Number int `json:"number"`
Name string `json:"name"`
ETag string `json:"etag"`
Size int64 `json:"size"`
}
// A fsMetaV1 represents a metadata header mapping keys to sets of values.
type fsMetaV1 struct {
Version string `json:"version"`
Format string `json:"format"`
Minio struct {
Release string `json:"release"`
} `json:"minio"`
// Metadata map for current object `fs.json`.
Meta map[string]string `json:"meta,omitempty"`
Parts []objectPartInfo `json:"parts,omitempty"`
}
```

54
docs/zh_CN/backend/xl/README.md Normal file
View File

@ -0,0 +1,54 @@
### Backend format `xl.json`
```go
// objectPartInfo Info of each part kept in the multipart metadata
// file after CompleteMultipartUpload() is called.
type objectPartInfo struct {
Number int `json:"number"`
Name string `json:"name"`
ETag string `json:"etag"`
Size int64 `json:"size"`
}
// checkSumInfo - carries checksums of individual scattered parts per disk.
type checkSumInfo struct {
Name string `json:"name"`
Algorithm string `json:"algorithm"`
Hash string `json:"hash"`
}
// erasureInfo - carries erasure coding related information, block
// distribution and checksums.
type erasureInfo struct {
Algorithm string `json:"algorithm"`
DataBlocks int `json:"data"`
ParityBlocks int `json:"parity"`
BlockSize int64 `json:"blockSize"`
Index int `json:"index"`
Distribution []int `json:"distribution"`
Checksum []checkSumInfo `json:"checksum,omitempty"`
}
// statInfo - carries stat information of the object.
type statInfo struct {
Size int64 `json:"size"` // Size of the object `xl.json`.
ModTime time.Time `json:"modTime"` // ModTime of the object `xl.json`.
}
// A xlMetaV1 represents `xl.json` metadata header.
type xlMetaV1 struct {
Version string `json:"version"` // Version of the current `xl.json`.
Format string `json:"format"` // Format of the current `xl.json`.
Stat statInfo `json:"stat"` // Stat of the current object `xl.json`.
// Erasure coded info for the current object `xl.json`.
Erasure erasureInfo `json:"erasure"`
// Minio release tag for current object `xl.json`.
Minio struct {
Release string `json:"release"`
} `json:"minio"`
// Metadata map for current object `xl.json`.
Meta map[string]string `json:"meta,omitempty"`
// Captures all the individual object `xl.json`.
Parts []objectPartInfo `json:"parts,omitempty"`
}
```

39
docs/zh_CN/browser/README.md Normal file
View File

@ -0,0 +1,39 @@
## Minio Browser
Minio Browser使用Json Web Token来验证JSON RPC请求。
初使请求为用户提供的`AccessKey`和`SecretKey`生成一个token令牌
<blockquote>
目前这些令牌在10小时后到期，这是不可配置的。
</blockquote>
### 启动minio server
```
minio server /data
```
### JSON RPC APIs.
JSON RPC命名空间是`Web`.
#### 服务器操作
* ServerInfo -获取当前服务器信息，包括内存统计，minio二进制版本，golang运行时版本等。
* StorageInfo - 获取磁盘空间可用空间(Total/Free)，类型，磁盘在线/脱机状态，以及ReadQuorum和WriteQuorum计数。
#### 认证操作
* Login - 等待用户名密码输入，成功回复一个新的Json Web Token（JWT）。
* SetAuth - 使用新的用户名，密码更改访问凭据。
* GetAuth - 从服务器获取当前的身份验证。
#### Bucket/Object operations.
* ListBuckets - 列出所有的存储桶，需要有合法的token令牌。
* ListObjects - 列出存储对象, 需要有合法的token令牌。
* MakeBucket - 创建一个新的存储桶, 需要有合法的token令牌。
* RemoveObject - 从存储桶中移除一个对象,需要有合法的token令牌。
* Upload - 通过浏览器上传一个新的对象,需要有合法的token令牌。
* Download - 从存储桶中下载一个对象, 需要有合法的token令牌。

963
docs/zh_CN/bucket/notifications/README.md Normal file
View File

@ -0,0 +1,963 @@
# Minio存储桶通知指南 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
存储桶（Bucket）如果发生改变,比如上传对象和删除对象，可以使用存储桶事件通知机制进行监控，并通过以下方式发布出去:
| Notification Targets|
|:---|
| [`AMQP`](#AMQP) |
| [`MQTT`](#MQTT) |
| [`Elasticsearch`](#Elasticsearch) |
| [`Redis`](#Redis) |
| [`NATS`](#NATS) |
| [`PostgreSQL`](#PostgreSQL) |
| [`MySQL`](#MySQL) |
| [`Apache Kafka`](#apache-kafka) |
| [`Webhooks`](#webhooks) |
## 前提条件
* 从[这里](http://docs.minio.io/docs/zh_CN/minio-quickstart-guide)下载并安装Minio Server。
* 从[这里](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)下载并安装Minio Client。
<a name="AMQP"></a>
## 使用AMQP发布Minio事件
从[这里](https://www.rabbitmq.com/)下载安装RabbitMQ。
### 第一步: 将AMQP endpoint添加到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。AMQP配置信息是在`notify`这个节点下的`amqp`节点下，在这里为你的AMQP实例创建配置信息键值对，key是你的AMQP endpoint的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
| `enable` | _bool_ | (必须) 此AMQP server endpoint是否可用 |
| `url` | _string_ | (必须) AMQP server endpoint, 例如. `amqp://myuser:mypassword@localhost:5672` |
| `exchange` | _string_ | exchange名称 |
| `routingKey` | _string_ | 发布用的Routing key |
| `exchangeType` | _string_ | exchange类型 |
| `deliveryMode` | _uint8_ | 发布方式。 0或1 - 瞬态; 2 - 持久。|
| `mandatory` | _bool_ | Publishing related bool. |
| `immediate` | _bool_ | Publishing related bool. |
| `durable` | _bool_ | Exchange declaration related bool. |
| `internal` | _bool_ | Exchange declaration related bool. |
| `noWait` | _bool_ | Exchange declaration related bool. |
| `autoDeleted` | _bool_ | Exchange declaration related bool. |
下面展示的是RabbitMQ的配置示例:
```json
"amqp": {
"1": {
"enable": true,
"url": "amqp://myuser:mypassword@localhost:5672",
"exchange": "bucketevents",
"routingKey": "bucketlogs",
"exchangeType": "fanout",
"deliveryMode": 0,
"mandatory": false,
"immediate": false,
"durable": false,
"internal": false,
"noWait": false,
"autoDeleted": false
}
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:amqp`。
Minio支持[RabbitMQ](https://www.rabbitmq.com/)中所有的交换方式，这次我们采用 ``fanout`` 交换。
注意一下，你可以听从你内心的想法，想配几个AMQP服务就配几个，只要每个AMQP服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第二步: 使用Minio客户端启用bucket通知
如果一个JPEG图片上传到``myminio`` server里的``images`` 存储桶或者从桶中删除，一个存储桶事件通知就会被触发。 这里ARN值是``arn:minio:sqs:us-east-1:1:amqp``，想了解更多关于ARN的信息，请参考[AWS ARN](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) documentation.
```
mc mb myminio/images
mc events add myminio/images arn:minio:sqs:us-east-1:1:amqp --suffix .jpg
mc events list myminio/images
arn:minio:sqs:us-east-1:1:amqp s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第三步:在RabbitMQ上进行验证
下面将要出场的python程序会等待队列交换T``bucketevents``并在控制台中输出事件通知。我们使用的是[Pika Python Client](https://www.rabbitmq.com/tutorials/tutorial-three-python.html) 来实现此功能。
```py
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='bucketevents',
type='fanout')
result = channel.queue_declare(exclusive=False)
queue_name = result.method.queue
channel.queue_bind(exchange='bucketevents',
queue=queue_name)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r" % body)
channel.basic_consume(callback,
queue=queue_name,
no_ack=False)
channel.start_consuming()
```
执行示例中的python程序来观察RabbitMQ事件。
```py
python rabbit.py
```
另开一个terminal终端并上传一张JPEG图片到``images``存储桶。
```
mc cp myphoto.jpg myminio/images
```
一旦上传完毕，你应该会通过RabbitMQ收到下面的事件通知。
```py
python rabbit.py
‘{“Records”:[{“eventVersion”:”2.0",”eventSource”:”aws:s3",”awsRegion”:”us-east-1",”eventTime”:”2016–09–08T22:34:38.226Z”,”eventName”:”s3:ObjectCreated:Put”,”userIdentity”:{“principalId”:”minio”},”requestParameters”:{“sourceIPAddress”:”10.1.10.150:44576"},”responseElements”:{},”s3":{“s3SchemaVersion”:”1.0",”configurationId”:”Config”,”bucket”:{“name”:”images”,”ownerIdentity”:{“principalId”:”minio”},”arn”:”arn:aws:s3:::images”},”object”:{“key”:”myphoto.jpg”,”size”:200436,”sequencer”:”147279EAF9F40933"}}}],”level”:”info”,”msg”:””,”time”:”2016–09–08T15:34:38–07:00"}\n
```
<a name="MQTT"></a>
## 使用MQTT发布Minio事件
从 [这里](https://mosquitto.org/)安装MQTT Broker。
### 第一步: 添加MQTT endpoint到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MQTT配置信息是在`notify`这个节点下的`mqtt`节点下，在这里为你的MQTT实例创建配置信息键值对，key是你的MQTT endpoint的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
| `enable` | _bool_ | (必须) 这个 server endpoint是否可用? |
| `broker` | _string_ | (必须) MQTT server endpoint, 例如. `tcp://localhost:1883` |
| `topic` | _string_ | (必须) 要发布的MQTT主题的名称, 例如. `minio` |
| `qos` | _int_ | 设置服务质量级别 |
| `clientId` | _string_ | MQTT代理识别Minio的唯一ID |
| `username` | _string_ | 连接MQTT server的用户名 (如果需要的话) |
| `password` | _string_ | 链接MQTT server的密码 (如果需要的话) |
以下是一个MQTT的配置示例:
```json
"mqtt": {
"1": {
"enable": true,
"broker": "tcp://localhost:1883",
"topic": "minio",
"qos": 1,
"clientId": "minio",
"username": "",
"password": ""
}
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:mqtt`。
Minio支持任何支持MQTT 3.1或3.1.1的MQTT服务器，并且可以通过TCP，TLS或Websocket连接使用``tcp://``, ``tls://``, or ``ws://``分别作为代理URL的方案。 更多信息，请参考 [Go Client](http://www.eclipse.org/paho/clients/golang/)。
注意一下，你还是和之前AMQP一样可以听从你内心的想法，想配几个MQTT服务就配几个，只要每个MQTT服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第二步: 使用Minio客户端启用bucket通知
如果一个JPEG图片上传到``myminio`` server里的``images`` 存储桶或者从桶中删除，一个存储桶事件通知就会被触发。 这里ARN值是``arn:minio:sqs:us-east-1:1:mqtt``。
```
mc mb myminio/images
mc events add myminio/images arn:minio:sqs:us-east-1:1:mqtt --suffix .jpg
mc events list myminio/images
arn:minio:sqs:us-east-1:1:amqp s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第三步：验证MQTT
下面的python程序等待mqtt主题``/ minio``，并在控制台上打印事件通知。 我们使用[paho-mqtt](https://pypi.python.org/pypi/paho-mqtt/)库来执行此操作。
```py
#!/usr/bin/env python
from __future__ import print_function
import paho.mqtt.client as mqtt
# The callback for when the client receives a CONNACK response from the server.
def on_connect(client, userdata, flags, rc):
print("Connected with result code", rc)
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
client.subscribe("/minio")
# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
print(msg.payload)
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect("localhost:1883", 1883, 60)
# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
# Other loop*() functions are available that give a threaded interface and a
# manual interface.
client.loop_forever()
```
执行这个python示例程序来观察MQTT事件。
```py
python mqtt.py
```
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
一旦上传完毕，你应该会通过MQTT收到下面的事件通知。
```py
python mqtt.py
{“Records”:[{“eventVersion”:”2.0",”eventSource”:”aws:s3",”awsRegion”:”us-east-1",”eventTime”:”2016–09–08T22:34:38.226Z”,”eventName”:”s3:ObjectCreated:Put”,”userIdentity”:{“principalId”:”minio”},”requestParameters”:{“sourceIPAddress”:”10.1.10.150:44576"},”responseElements”:{},”s3":{“s3SchemaVersion”:”1.0",”configurationId”:”Config”,”bucket”:{“name”:”images”,”ownerIdentity”:{“principalId”:”minio”},”arn”:”arn:aws:s3:::images”},”object”:{“key”:”myphoto.jpg”,”size”:200436,”sequencer”:”147279EAF9F40933"}}}],”level”:”info”,”msg”:””,”time”:”2016–09–08T15:34:38–07:00"}
```
<a name="Elasticsearch"></a>
## 使用Elasticsearch发布Minio事件
安装 [Elasticsearch](https://www.elastic.co/downloads/elasticsearch) 。
这个通知目标支持两种格式: _namespace_ and _access_。
如果使用的是 _namespace_ 格式, Minio将桶中的对象与索引中的文档进行同步。对于Minio的每一个事件，ES都会创建一个document,这个document的ID就是存储桶以及存储对象的名称。事件的其他细节存储在document的正文中。因此，如果一个已经存在的对象在Minio中被覆盖，在ES中的相对应的document也会被更新。如果一个对象被删除，相对应的document也会从index中删除。
如果使用的是_access_格式，Minio将事件作为document加到ES的index中。对于每一个事件，ES同样会创建一个document,这个document包含事件的所有细节，document的时间戳设置为事件的时间戳，并将该document加到ES的index中。这个document的ID是由ES随机生成的。在_access_格式下，没有文档会被删除或者修改，对于一个对象的操作，都会生成新的document附加到index中。
下面的步骤展示的是在`namespace`格式下，如何使用通知目标。另一种格式和这个很类似，为了不让你们说我墨迹，就不再赘述了。
### 第一步：确保至少满足第低要求
Minio要求使用的是ES 5.X系统版本。如果使用的是低版本的ES，也没关系，ES官方支持升级迁移，详情请看[这里](https://www.elastic.co/guide/en/elasticsearch/reference/current/setup-upgrade.html)。
### 第二步：把ES集成到Minio中
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。ES配置信息是在`notify`这个节点下的`elasticsearch`节点下，在这里为你的ES实例创建配置信息键值对，key是你的ES的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
| `enable` | _bool_ | (必须) 是否启用这个配置? |
| `format` | _string_ | (必须) 是`namespace` 还是 `access` |
| `url` | _string_ | (必须) ES地址，比如: `http://localhost:9200` |
| `index` | _string_ | (必须) 给Minio用的index |
以下是ES的一个配置示例:
```json
"elasticsearch": {
"1": {
"enable": true,
"format": "namespace",
"url": "http://127.0.0.1:9200",
"index": "minio_events"
}
},
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:elasticsearch`。
注意一下，你又可以再一次听从你内心的想法，想配几个ES服务就配几个，只要每个ES服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第三步：使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知。一旦有文件被创建或者覆盖，一个新的ES的document会被创建或者更新到之前咱配的index里。如果一个已经存在的对象被删除，这个对应的document也会从index中删除。因此，这个ES index里的行，就映射着`images`存储桶里的对象。
要配置这种存储桶通知，我们需要用到前面步骤Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
```
mc mb myminio/images
mc events add myminio/images arn:minio:sqs:us-east-1:1:elasticsearch --suffix .jpg
mc events list myminio/images
arn:minio:sqs:us-east-1:1:elasticsearch s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第四步：验证ES
上传一张图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
使用curl查到``minio_events`` index中的内容。
```
$ curl "http://localhost:9200/minio_events/_search?pretty=true"
{
"took" : 40,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"failed" : 0
},
"hits" : {
"total" : 1,
"max_score" : 1.0,
"hits" : [
{
"_index" : "minio_events",
"_type" : "event",
"_id" : "images/myphoto.jpg",
"_score" : 1.0,
"_source" : {
"Records" : [
{
"eventVersion" : "2.0",
"eventSource" : "minio:s3",
"awsRegion" : "us-east-1",
"eventTime" : "2017-03-30T08:00:41Z",
"eventName" : "s3:ObjectCreated:Put",
"userIdentity" : {
"principalId" : "minio"
},
"requestParameters" : {
"sourceIPAddress" : "127.0.0.1:38062"
},
"responseElements" : {
"x-amz-request-id" : "14B09A09703FC47B",
"x-minio-origin-endpoint" : "http://192.168.86.115:9000"
},
"s3" : {
"s3SchemaVersion" : "1.0",
"configurationId" : "Config",
"bucket" : {
"name" : "images",
"ownerIdentity" : {
"principalId" : "minio"
},
"arn" : "arn:aws:s3:::images"
},
"object" : {
"key" : "myphoto.jpg",
"size" : 6474,
"eTag" : "a3410f4f8788b510d6f19c5067e60a90",
"sequencer" : "14B09A09703FC47B"
}
},
"source" : {
"host" : "127.0.0.1",
"port" : "38062",
"userAgent" : "Minio (linux; amd64) minio-go/2.0.3 mc/2017-02-15T17:57:25Z"
}
}
]
}
}
]
}
}
```
这个输出显示在ES中为这个事件创建了一个document。
这里我们可以看到这个document ID就是存储桶和对象的名称。如果用的是`access`格式，这个document ID就是由ES随机生成的。
<a name="Redis"></a>
## 使用Redis发布Minio事件
安装 [Redis](http://redis.io/download)。为了演示，我们将数据库密码设为"yoursecret"。
这咱通知目标支持两种格式: _namespace_ 和 _access_。
如果用的是_namespacee_格式，Minio将存储桶里的对象同步成Redis hash中的条目。对于每一个条目，对对应一个存储桶里的对象，其key都被设为"存储桶名称/对象名称"，value都是一个有关这个Minio对象的JSON格式的事件数据。如果对象更新或者删除，hash中对象的条目也会相应的更新或者删除。
如果使用的是_access_,Minio使用[RPUSH](https://redis.io/commands/rpush)将事件添加到list中。这个list中每一个元素都是一个JSON格式的list,这个list中又有两个元素，第一个元素是时间戳的字符串，第二个元素是一个含有在这个存储桶上进行操作的事件数据的JSON对象。在这种格式下，list中的元素不会更更新或者删除。
下面的步骤展示的是如何在`namespace`和`access`格式下使用通知目标。
### 第一步：集成Redis到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。Redis配置信息是在`notify`这个节点下的`redis`节点下，在这里为你的Redis实例创建配置信息键值对，key是你的Redis的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
| `enable` | _bool_ | (必须) 这个配置是否可用? |
| `format` | _string_ | (必须) 是 `namespace` 还是 `access` |
| `address` | _string_ | (必须) Redis服务地址，比如: `localhost:6379` |
| `password` | _string_ | (可选) Redis服务密码 |
| `key` | _string_ | (必须) 事件要存储到redis key的名称。如果用的是`namespace`格式的话，则是一个hash,如果是`access`格式的话，则是一个list|
下面是一个Redis配置示例:
```json
"redis": {
"1": {
"enable": true,
"address": "127.0.0.1:6379",
"password": "yoursecret",
"key": "bucketevents"
}
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:redis`。
注意一下，你永远都可以听从你内心的想法，想配几个Redis服务就配几个，只要每个Redis服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第二步: 使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知。一旦有文件被创建或者覆盖，一个新的key会被创建,或者一个已经存在的key就会被更新到之前咱配的redis hash里。如果一个已经存在的对象被删除，这个对应的key也会从hash中删除。因此，这个Redis hash里的行，就映射着`images`存储桶里的对象。
要配置这种存储桶通知，我们需要用到前面步骤Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
```
mc mb myminio/images
mc events add myminio/images arn:minio:sqs:us-east-1:1:redis --suffix .jpg
mc events list myminio/images
arn:minio:sqs:us-east-1:1:redis s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第三步：验证Redis
启动`redis-cli`这个Redis客户端程序来检查Redis中的内容. 运行`monitor`Redis命令。 这将打印在Redis上执行的每个操作。
```
redis-cli -a yoursecret
127.0.0.1:6379> monitor
OK
```
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
在上一个终端中，你将看到Minio在Redis上执行的操作：
```
127.0.0.1:6379> monitor
OK
1490686879.650649 [0 172.17.0.1:44710] "PING"
1490686879.651061 [0 172.17.0.1:44710] "HSET" "minio_events" "images/myphoto.jpg" "{\"Records\":[{\"eventVersion\":\"2.0\",\"eventSource\":\"minio:s3\",\"awsRegion\":\"us-east-1\",\"eventTime\":\"2017-03-28T07:41:19Z\",\"eventName\":\"s3:ObjectCreated:Put\",\"userIdentity\":{\"principalId\":\"minio\"},\"requestParameters\":{\"sourceIPAddress\":\"127.0.0.1:52234\"},\"responseElements\":{\"x-amz-request-id\":\"14AFFBD1ACE5F632\",\"x-minio-origin-endpoint\":\"http://192.168.86.115:9000\"},\"s3\":{\"s3SchemaVersion\":\"1.0\",\"configurationId\":\"Config\",\"bucket\":{\"name\":\"images\",\"ownerIdentity\":{\"principalId\":\"minio\"},\"arn\":\"arn:aws:s3:::images\"},\"object\":{\"key\":\"myphoto.jpg\",\"size\":2586,\"eTag\":\"5d284463f9da279f060f0ea4d11af098\",\"sequencer\":\"14AFFBD1ACE5F632\"}},\"source\":{\"host\":\"127.0.0.1\",\"port\":\"52234\",\"userAgent\":\"Minio (linux; amd64) minio-go/2.0.3 mc/2017-02-15T17:57:25Z\"}}]}"
```
在这我看看到了Minio在`minio_events`这个key上执行了`HSET`命令。
如果用的是`access`格式，那么`minio_events`就是一个list,Minio就会调用`RPUSH`添加到list中。这个list的消费者会使用`BLPOP`从list的最左端删除list元素。
<a name="NATS"></a>
## 使用NATS发布Minio事件
安装 [NATS](http://nats.io/).
### 第一步：集成NATS到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例修改NATS的配置:
```
"nats": {
"1": {
"enable": true,
"address": "0.0.0.0:4222",
"subject": "bucketevents",
"username": "yourusername",
"password": "yoursecret",
"token": "",
"secure": false,
"pingInterval": 0
"streaming": {
"enable": false,
"clusterID": "",
"clientID": "",
"async": false,
"maxPubAcksInflight": 0
}
}
},
```
更新完配置文件后，重启Minio Server让配置生效。``bucketevents``是NATS在这个例子中使用的主题。
Minio服务也支持 [NATS Streaming mode](http://nats.io/documentation/streaming/nats-streaming-intro/) ，这种模式额外提供了像 `Message/event persistence`, `At-least-once-delivery`, 以及 `Publisher rate limiting`这样的功能。如果想让Minio服务发送通知到NATS Streaming server,参考下面示面进行配置：
```
"nats": {
"1": {
"enable": true,
"address": "0.0.0.0:4222",
"subject": "bucketevents",
"username": "yourusername",
"password": "yoursecret",
"token": "",
"secure": false,
"pingInterval": 0
"streaming": {
"enable": true,
"clusterID": "test-cluster",
"clientID": "minio-client",
"async": true,
"maxPubAcksInflight": 10
}
}
},
```
更多关于 `clusterID`, `clientID` 的信息，请看 [NATS documentation](https://github.com/nats-io/nats-streaming-server/blob/master/README.md). 关于 `maxPubAcksInflight` ，请看 [这里](https://github.com/nats-io/go-nats-streaming#publisher-rate-limiting).
### 第二步: 使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦``myminio`` server上有文件 从``images``存储桶里删除或者上传到存储桶中，事件即被触发。在这里，ARN的值是``arn:minio:sqs:us-east-1:1:nats``。 更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
```
mc mb myminio/images
mc events add myminio/images arn:minio:sqs:us-east-1:1:nats --suffix .jpg
mc events list myminio/images
arn:minio:sqs:us-east-1:1:nats s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第三步：验证NATS
如果你用的是NATS server，请查看下面的示例程序来记录添加到NATS的存储桶通知。
```go
package main
// Import Go and NATS packages
import (
"log"
"runtime"
"github.com/nats-io/nats"
)
func main() {
// Create server connection
natsConnection, _ := nats.Connect("nats://yourusername:yoursecret@localhost:4222")
log.Println("Connected")
// Subscribe to subject
log.Printf("Subscribing to subject 'bucketevents'\n")
natsConnection.Subscribe("bucketevents", func(msg *nats.Msg) {
// Handle the message
log.Printf("Received message '%s\n", string(msg.Data)+"'")
})
// Keep the connection alive
runtime.Goexit()
}
```
```
go run nats.go
2016/10/12 06:39:18 Connected
2016/10/12 06:39:18 Subscribing to subject 'bucketevents'
```
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
``nats.go``示例程序将事件通知打印到控制台。
```
go run nats.go
2016/10/12 06:51:26 Connected
2016/10/12 06:51:26 Subscribing to subject 'bucketevents'
2016/10/12 06:51:33 Received message '{"EventType":"s3:ObjectCreated:Put","Key":"images/myphoto.jpg","Records":[{"eventVersion":"2.0","eventSource":"aws:s3","awsRegion":"us-east-1","eventTime":"2016-10-12T13:51:33Z","eventName":"s3:ObjectCreated:Put","userIdentity":{"principalId":"minio"},"requestParameters":{"sourceIPAddress":"[::1]:57106"},"responseElements":{},"s3":{"s3SchemaVersion":"1.0","configurationId":"Config","bucket":{"name":"images","ownerIdentity":{"principalId":"minio"},"arn":"arn:aws:s3:::images"},"object":{"key":"myphoto.jpg","size":56060,"eTag":"1d97bf45ecb37f7a7b699418070df08f","sequencer":"147CCD1AE054BFD0"}}}],"level":"info","msg":"","time":"2016-10-12T06:51:33-07:00"}
```
如果你用的是NATS Streaming server,请查看下面的示例程序来记录添加到NATS的存储桶通知。
```go
package main
// Import Go and NATS packages
import (
"fmt"
"runtime"
"github.com/nats-io/go-nats-streaming"
)
func main() {
natsConnection, _ := stan.Connect("test-cluster", "test-client")
log.Println("Connected")
// Subscribe to subject
log.Printf("Subscribing to subject 'bucketevents'\n")
natsConnection.Subscribe("bucketevents", func(m *stan.Msg) {
// Handle the message
fmt.Printf("Received a message: %s\n", string(m.Data))
})
// Keep the connection alive
runtime.Goexit()
}
```
```
go run nats.go
2017/07/07 11:47:40 Connected
2017/07/07 11:47:40 Subscribing to subject 'bucketevents'
```
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
``nats.go``示例程序将事件通知打印到控制台。
```
Received a message: {"EventType":"s3:ObjectCreated:Put","Key":"images/myphoto.jpg","Records":[{"eventVersion":"2.0","eventSource":"minio:s3","awsRegion":"","eventTime":"2017-07-07T18:46:37Z","eventName":"s3:ObjectCreated:Put","userIdentity":{"principalId":"minio"},"requestParameters":{"sourceIPAddress":"192.168.1.80:55328"},"responseElements":{"x-amz-request-id":"14CF20BD1EFD5B93","x-minio-origin-endpoint":"http://127.0.0.1:9000"},"s3":{"s3SchemaVersion":"1.0","configurationId":"Config","bucket":{"name":"images","ownerIdentity":{"principalId":"minio"},"arn":"arn:aws:s3:::images"},"object":{"key":"myphoto.jpg","size":248682,"eTag":"f1671feacb8bbf7b0397c6e9364e8c92","contentType":"image/jpeg","userDefined":{"content-type":"image/jpeg"},"versionId":"1","sequencer":"14CF20BD1EFD5B93"}},"source":{"host":"192.168.1.80","port":"55328","userAgent":"Minio (linux; amd64) minio-go/2.0.4 mc/DEVELOPMENT.GOGET"}}],"level":"info","msg":"","time":"2017-07-07T11:46:37-07:00"}
```
<a name="PostgreSQL"></a>
## 使用PostgreSQL发布Minio事件
安装 [PostgreSQL](https://www.postgresql.org/) 数据库。为了演示，我们将"postgres"用户的密码设为`password`，并且创建了一个`minio_events`数据库来存储事件信息。
这个通知目标支持两种格式: _namespace_ and _access_。
如果使用的是_namespace_格式，Minio将存储桶里的对象同步成数据库表中的行。每一行有两列：key和value。key是这个对象的存储桶名字加上对象名，value都是一个有关这个Minio对象的JSON格式的事件数据。如果对象更新或者删除，表中相应的行也会相应的更新或者删除。
如果使用的是_access_,Minio将将事件添加到表里，行有两列：event_time 和 event_data。event_time是事件在Minio server里发生的时间，event_data是有关这个Minio对象的JSON格式的事件数据。在这种格式下，不会有行会被删除或者修改。
下面的步骤展示的是如何在`namespace`格式下使用通知目标，`_access_`差不多，不再赘述，我相信你可以触类旁通，举一反三，不要让我失望哦。
### 第一步：确保确保至少满足第低要求
Minio要求PostgresSQL9.5版本及以上。 Minio用了PostgreSQL9.5引入的[`INSERT ON CONFLICT`](https://www.postgresql.org/docs/9.5/static/sql-insert.html#SQL-ON-CONFLICT) (aka UPSERT) 特性,以及9.4引入的 [JSONB](https://www.postgresql.org/docs/9.4/static/datatype-json.html) 数据类型。
### 第二步：集成PostgreSQL到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。PostgreSQL配置信息是在`notify`这个节点下的`postgresql`节点下，在这里为你的PostgreSQL实例创建配置信息键值对，key是你的PostgreSQL的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
| `enable` | _bool_ | (必须)此配置是否启用 |
| `format` | _string_ | (必须) 是 `namespace` 还是 `access`|
| `connectionString` | _string_ | (可选) PostgreSQL的[连接参数](https://godoc.org/github.com/lib/pq#hdr-Connection_String_Parameters) 。比如可以用来设置 `sslmode` |
| `table` | _string_ | (必须) 事件对应的表名，如果该表不存在，Mniio server会在启动时创建。|
| `host` | _string_ | (可选) PostgresSQL的主机名，默认是`localhost`|
| `port` | _string_ | (可选) PostgreSQL的端口号，默认是`5432` |
| `user` | _string_ | (可选)数据库用户名，默认是运行Minio server进程的用户|
| `password` | _string_ | (可选) 数据库密码 |
| `database` | _string_ | (可选)库名 |
下面是一个PostgreSQL配置示例:
```
"postgresql": {
"1": {
"enable": true,
"format": "namespace",
"connectionString": "sslmode=disable",
"table": "bucketevents",
"host": "127.0.0.1",
"port": "5432",
"user": "postgres",
"password": "password",
"database": "minio_events"
}
}
```
注意一下，为了演示，咱们这把SSL禁掉了，但是为了安全起见，不建议在生产环境这么弄。
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:postgresql`。
和之前描述的一样，你也可以添加多个PostreSQL实例，只要ID不重复就行。
### 第三步：使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦上有文件上传到存储桶中，PostgreSQL中会insert一条新的记录或者一条已经存在的记录会被update，如果一个存在对象被删除，一条对应的记录也会从PostgreSQL表中删除。因此，PostgreSQL表中的行，对应的就是存储桶里的一个对象。
要配置这种存储桶通知，我们需要用到前面步骤Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
```
# Create bucket named `images` in myminio
mc mb myminio/images
# Add notification configuration on the `images` bucket using the MySQL ARN. The --suffix argument filters events.
mc events add myminio/images arn:minio:sqs:us-east-1:1:postgresql --suffix .jpg
# Print out the notification configuration on the `images` bucket.
mc events list myminio/images
mc events list myminio/images
arn:minio:sqs:us-east-1:1:postgresql s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第四步：验证PostgreSQL
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
打开一个PostgreSQL终端列出表 `bucketevents` 中所有的记录。
```
$ psql -h 127.0.0.1 -U postgres -d minio_events
minio_events=# select * from bucketevents;
key | value
--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
images/myphoto.jpg | {"Records": [{"s3": {"bucket": {"arn": "arn:aws:s3:::images", "name": "images", "ownerIdentity": {"principalId": "minio"}}, "object": {"key": "myphoto.jpg", "eTag": "1d97bf45ecb37f7a7b699418070df08f", "size": 56060, "sequencer": "147CE57C70B31931"}, "configurationId": "Config", "s3SchemaVersion": "1.0"}, "awsRegion": "us-east-1", "eventName": "s3:ObjectCreated:Put", "eventTime": "2016-10-12T21:18:20Z", "eventSource": "aws:s3", "eventVersion": "2.0", "userIdentity": {"principalId": "minio"}, "responseElements": {}, "requestParameters": {"sourceIPAddress": "[::1]:39706"}}]}
(1 row)
```
<a name="MySQL"></a>
## 使用MySQL发布Minio事件
安装 [MySQL](https://dev.mysql.com/downloads/mysql/). 为了演示，我们将"postgres"用户的密码设为`password`，并且创建了一个`miniodb`数据库来存储事件信息。
这个通知目标支持两种格式: _namespace_ and _access_。
如果使用的是_namespace_格式，Minio将存储桶里的对象同步成数据库表中的行。每一行有两列：key_name和value。key_name是这个对象的存储桶名字加上对象名，value都是一个有关这个Minio对象的JSON格式的事件数据。如果对象更新或者删除，表中相应的行也会相应的更新或者删除。
如果使用的是_access_,Minio将将事件添加到表里，行有两列：event_time 和 event_data。event_time是事件在Minio server里发生的时间，event_data是有关这个Minio对象的JSON格式的事件数据。在这种格式下，不会有行会被删除或者修改。
下面的步骤展示的是如何在`namespace`格式下使用通知目标，`_access_`差不多，不再赘述。
### 第一步：确保确保至少满足第低要求
Minio要求MySQL 版本 5.7.8及以上，Minio使用了MySQL5.7.8版本引入的 [JSON](https://dev.mysql.com/doc/refman/5.7/en/json.html) 数据类型。我们使用的是MySQL5.7.17进行的测试。
### 第二步：集成MySQL到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MySQL配置信息是在`notify`这个节点下的`mysql`节点下，在这里为你的MySQL实例创建配置信息键值对，key是你的PostgreSQL的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
| `enable` | _bool_ | (必须)此配置是否启用？ |
| `format` | _string_ | (必须)是 `namespace` 还是 `access` |
| `dsnString` | _string_ | (可选)MySQL的 [Data-Source-Name连接串](https://github.com/go-sql-driver/mysql#dsn-data-source-name) 。如果没设值，连接信息将使用下列参数： `host`, `port`, `user`, `password` 以及 `database` |
| `table` | _string_ | (必须) 事件对应的表名，如果该表不存在，Mniio server会在启动时创建。|
| `host` | _string_ | MySQL server主机名 (如果 `dsnString` 是空才会使用此配置)。 |
| `port` | _string_ | MySQL server端口号 (如果 `dsnString` 是空才会使用此配置)。 |
| `user` | _string_ | 数据库用户名 (如果 `dsnString` 是空才会使用此配置)。 |
| `password` | _string_ |数据库密码(如果 `dsnString` 是空才会使用此配置)。 |
| `database` | _string_ |数据库名(如果 `dsnString` 是空才会使用此配置)。 |
下面是一个MySQL配置示例:
```
"mysql": {
"1": {
"enable": true,
"dsnString": "",
"table": "minio_images",
"host": "172.17.0.1",
"port": "3306",
"user": "root",
"password": "password",
"database": "miniodb"
}
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:mysql`。
和之前描述的一样，你也可以添加多个MySQL实例，只要ID不重复就行。
### 第三步：使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦上有文件上传到存储桶中，MySQL中会insert一条新的记录或者一条已经存在的记录会被update，如果一个存在对象被删除，一条对应的记录也会从MySQL表中删除。因此，MySQL表中的行，对应的就是存储桶里的一个对象。
要配置这种存储桶通知，我们需要用到前面步骤Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
```
# Create bucket named `images` in myminio
mc mb myminio/images
# Add notification configuration on the `images` bucket using the MySQL ARN. The --suffix argument filters events.
mc events add myminio/images arn:minio:sqs:us-east-1:1:postgresql --suffix .jpg
# Print out the notification configuration on the `images` bucket.
mc events list myminio/images
arn:minio:sqs:us-east-1:1:postgresql s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第四步：验证MySQL
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
打开一个MySQL终端列出表 `minio_images` 中所有的记录。
```
$ mysql -h 172.17.0.1 -P 3306 -u root -p miniodb
mysql> select * from minio_images;
+--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| key_name | value |
+--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| images/myphoto.jpg | {"Records": [{"s3": {"bucket": {"arn": "arn:aws:s3:::images", "name": "images", "ownerIdentity": {"principalId": "minio"}}, "object": {"key": "myphoto.jpg", "eTag": "467886be95c8ecfd71a2900e3f461b4f", "size": 26, "sequencer": "14AC59476F809FD3"}, "configurationId": "Config", "s3SchemaVersion": "1.0"}, "awsRegion": "us-east-1", "eventName": "s3:ObjectCreated:Put", "eventTime": "2017-03-16T11:29:00Z", "eventSource": "aws:s3", "eventVersion": "2.0", "userIdentity": {"principalId": "minio"}, "responseElements": {"x-amz-request-id": "14AC59476F809FD3", "x-minio-origin-endpoint": "http://192.168.86.110:9000"}, "requestParameters": {"sourceIPAddress": "127.0.0.1:38260"}}]} |
+--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.01 sec)
```
<a name="apache-kafka"></a>
## 使用Kafka发布Minio事件
安装[ Apache Kafka](http://kafka.apache.org/).
### 第一步：确保确保至少满足第低要求
Minio要求Kafka版本0.10或者0.9.Minio内部使用了 [Shopify/sarama](https://github.com/Shopify/sarama/) 库，因此需要和该库有同样的版本兼容性。
###第二步：集成Kafka到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例更新Kafka配置：
```
"kafka": {
"1": {
"enable": true,
"brokers": ["localhost:9092"],
"topic": "bucketevents"
}
}
```
重启Minio server让配置生效。``bucketevents``是本示例用到的Kafka主题（topic）。
### 第三步：使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦上有文件上传到存储桶中，事件将被触发。在这里，ARN的值是``arn:minio:sqs:us-east-1:1:kafka``。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
```
mc mb myminio/images
mc events add myminio/images arn:minio:sqs:us-east-1:1:kafka --suffix .jpg
mc events list myminio/images
arn:minio:sqs:us-east-1:1:kafka s3:ObjectCreated:*,s3:ObjectRemoved:* Filter: suffix=”.jpg”
```
### 第四步：验证Kafka
我们使用 [kafkacat](https://github.com/edenhill/kafkacat) 将所有的通知输出到控制台。
```
kafkacat -C -b localhost:9092 -t bucketevents
```
打开一个新的terminal终端并上传一张JPEG图片到``images`` 存储桶。
```
mc cp myphoto.jpg myminio/images
```
``kafkacat`` 输出事件通知到控制台。
```
kafkacat -b localhost:9092 -t bucketevents
{"EventType":"s3:ObjectCreated:Put","Key":"images/myphoto.jpg","Records":[{"eventVersion":"2.0","eventSource":"aws:s3","awsRegion":"us-east-1","eventTime":"2017-01-31T10:01:51Z","eventName":"s3:ObjectCreated:Put","userIdentity":{"principalId":"88QR09S7IOT4X1IBAQ9B"},"requestParameters":{"sourceIPAddress":"192.173.5.2:57904"},"responseElements":{"x-amz-request-id":"149ED2FD25589220","x-minio-origin-endpoint":"http://192.173.5.2:9000"},"s3":{"s3SchemaVersion":"1.0","configurationId":"Config","bucket":{"name":"images","ownerIdentity":{"principalId":"88QR09S7IOT4X1IBAQ9B"},"arn":"arn:aws:s3:::images"},"object":{"key":"myphoto.jpg","size":541596,"eTag":"04451d05b4faf4d62f3d538156115e2a","sequencer":"149ED2FD25589220"}}}],"level":"info","msg":"","time":"2017-01-31T15:31:51+05:30"}
```
<a name="webhooks"></a>
## 使用Webhook发布Minio事件
[Webhooks](https://en.wikipedia.org/wiki/Webhook) 采用推的方式获取数据，而不是一直去拉取。
### 第一步：集成MySQL到Minio
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例更新Webhook配置：
```
"webhook": {
"1": {
"enable": true,
"endpoint": "http://localhost:3000/"
}
```
endpoint是监听webhook通知的服务。保存配置文件并重启Minio服务让配配置生效。注意一下，在重启Minio时，这个endpoint必须是启动并且可访问到。
### 第二步：使用Minio客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦上有文件上传到存储桶中，事件将被触发。在这里，ARN的值是``arn:minio:sqs:us-east-1:1:webhook``。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
```
mc mb myminio/images
mc mb myminio/images-thumbnail
mc events add myminio/images arn:minio:sqs:us-east-1:1:webhook --events put --suffix .jpg
```
验证事件通知是否配置正确：
```
mc events list myminio/images
```
你应该可以收到如下的响应：
```
arn:minio:sqs:us-east-1:1:webhook s3:ObjectCreated:* Filter: suffix=".jpg"
```
### 第三步：采用Thumbnailer进行验证
我们使用 [Thumbnailer](https://github.com/minio/thumbnailer) 来监听Minio通知。如果有文件上传于是Minio服务，Thumnailer监听到该通知，生成一个缩略图并上传到Minio服务。
安装Thumbnailer:
```
git clone https://github.com/minio/thumbnailer/
npm install
```
然后打开Thumbnailer的``config/webhook.json``配置文件，添加有关Minio server的配置，使用下面的方式启动Thumbnailer:
```
NODE_ENV=webhook node thumbnail-webhook.js
```
Thumbnailer运行在``http://localhost:3000/``。下一步，配置Minio server,让其发送消息到这个URL（第一步提到的），并使用 ``mc`` 来设置存储桶通知（第二步提到的）。然后上传一张图片到Minio server:
```
mc cp ~/images.jpg myminio/images
.../images.jpg: 8.31 KB / 8.31 KB ┃▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓┃ 100.00% 59.42 KB/s 0s
```
稍等片刻，然后使用mc ls检查存储桶的内容 -，你将看到有个缩略图出现了。
```
mc ls myminio/images-thumbnail
[2017-02-08 11:39:40 IST] 992B images-thumbnail.jpg
```
*注意* 如果你用的是 [distributed Minio](https://docs.minio.io/docs/zh_CN/distributed-minio-quickstart-guide),请修改所有节点的 ``~/.minio/config.json``。

39
docs/zh_CN/bucket/policy/README.md Normal file
View File

@ -0,0 +1,39 @@
## 访问策略
该包实现基于访问策略语言规范（Access Policy Language specification）的解析和验证存储桶访问策略 - http://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html
### 支持以下效果
Allow
Deny
### 支持以下操作
s3:GetObject
s3:ListBucket
s3:PutObject
s3:GetBucketLocation
s3:DeleteObject
s3:AbortMultipartUpload
s3:ListBucketMultipartUploads
s3:ListMultipartUploadParts
### 支持下列条件
StringEquals
StringNotEquals
StringLike
StringNotLike
IpAddress
NotIpAddress
每个条件支持的key
s3:prefix
s3:max-keys
aws:Referer
aws:SourceIp
### 是否支持嵌套策略
不支持嵌套策略

20
docs/zh_CN/caching/README.md Normal file
View File

@ -0,0 +1,20 @@
## 对象缓存
默认情况下，对象缓存处于以下设置状态
- 缓存大小是你内存大小的一半，不过如果你的内存小于8G的话，缓存是不开启的。
- 缓存对象的过期时间是72小时。
- 每次过期时间的1/4时间点（每18小时）出发一次过期对象垃圾回收清理。
注意：上述配置不支持手动修改。
### 特性
GET和PUT操作都会进行缓存。
- GET 如果缓存中没有，则将新对象进行缓存，否则直接取缓存中的对象返回。
- PUT/POST 对所有上传成功的对象进行缓存，如果之前存在同名（同一个bucket下同名）对象的缓存，则替换之。
注意：缓存会按之前阐述的过期配置在一定周期后自动过期，经常访问的对象会因为每次缓存命中而延长生命，在缓存中活的很久很久。

96
docs/zh_CN/config/README.md Normal file
View File

@ -0,0 +1,96 @@
# Minio Server `config.json` (v18) 指南 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Minio server在默认情况下会将所有配置信息存到 `${HOME}/.minio/config.json` 文件中。 以下部分提供每个字段的详细说明以及如何自定义它们。一个完整的 `config.json` 在 [这里](https://raw.githubusercontent.com/minio/minio/master/docs/config/config.sample.json)
## 配置目录
默认的配置目录是 `${HOME}/.minio`，你可以使用`--config-dir`命令行选项重写之。 You can override the default configuration directory using `--config-dir` command-line option. Minio server在首次启动时会生成一个新的`config.json`，里面带有自动生成的访问凭据。
```sh
minio server --config-dir /etc/minio /data
```
### 证书目录
TLS证书存在``${HOME}/.minio/certs``目录下，你需要将证书放在该目录下来启用`HTTPS` 。如果你是一个乐学上进的好青年，这里有一本免费的秘籍传授一你: [如何使用TLS安全的访问minio](http://docs.minio.io/docs/zh_CN/how-to-secure-access-to-minio-server-with-tls).
以下是一个带来TLS证书的Minio server的目录结构。
```sh
$ tree ~/.minio
/home/user1/.minio
├── certs
│ ├── CAs
│ ├── private.key
│ └── public.crt
└── config.json
```
### 配置参数
#### 版本
|参数|类型|描述|
|:---|:---|:---|
|``version``|_string_| `version`决定了配置文件的格式，任何老版本都会在启动时自动迁移到新版本中。 [请勿手动修改]|
#### 凭据
|参数|类型|描述|
|:---|:---|:---|
|``credential``| |对象存储和Web访问的验证凭据。|
|``credential.accessKey`` | _string_ | Access key长度最小是5个字符，你可以通过 `MINIO_ACCESS_KEY`环境变量进行修改|
|``credential.secretKey`` | _string_ | Secret key长度最小是8个字符，你可以通过`MINIO_SECRET_KEY`环境变量进行修改|
示例:
```sh
export MINIO_ACCESS_KEY=admin
export MINIO_SECRET_KEY=password
minio server /data
```
#### 区域（Region）
|参数|类型|描述|
|:---|:---|:---|
|``region``| _string_ | `region`描述的是服务器的物理位置，默认是`us-east-1`（美国东区1）,这也是亚马逊S3的默认区域。你可以通过`MINIO_REGION` 环境变量进行修改。如果不了解这块，建议不要随意修改|
示例:
```sh
export MINIO_REGION="中国华北一区"
minio server /data
```
#### 浏览器
|参数|类型|描述|
|:---|:---|:---|
|``browser``| _string_ | 开启或关闭浏览器访问，默认是开启的，你可以通过``MINIO_BROWSER``环境变量进行修改|
示例:
```sh
export MINIO_BROWSER=off
minio server /data
```
#### 日志记录
|参数|类型|描述|
|:---|:---|:---|
|``logger ``| |服务通过logger记录error或者fatal(致命)错误，你可以同时开启多个logger。|
|``logger.console``| |将日志信息发送到控制台|
|``logger.console.enable``| _bool_ | 是否开启控制台日志输出，默认是开启|
|``logger.file``| |发送日志信息到文件|
|``logger.file.enable``| _bool_ | 是否开启文件日志记录，默认是关闭。|
|``logger.file.filename``| _string_ |文件日志的输出路径， 比如: _/var/log/minio.log_ |
#### 通知
|参数|类型|描述|
|:---|:---|:---|
|``notify``| |通知通过以下方式开启存储桶事件通知，用于lambda计算|
|``notify.amqp``| |[通过AMQP发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#AMQP)|
|``notify.mqtt``| |[通过MQTT发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#MQTT)|
|``notify.elasticsearch``| |[通过Elasticsearch发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#Elasticsearch)|
|``notify.redis``| |[通过Redis发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#Redis)|
|``notify.nats``| |[通过NATS发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#NATS)|
|``notify.postgresql``| |[通过PostgreSQL发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#PostgreSQL)|
|``notify.kafka``| |[通过Apache Kafka发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#apache-kafka)|
|``notify.webhook``| |[通过Webhooks发布Minio事件](http://docs.minio.io/docs/zh_CN/minio-bucket-notification-guide#webhooks)|
## 了解更多
* [Minio Quickstart Guide](https://docs.minio.io/docs/minio-quickstart-guide)

71
docs/zh_CN/deployment/kernel-tuning/README.md Normal file
View File

@ -0,0 +1,71 @@
# Linux服务器上Minio生产环境的内核调优 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
## 调优网络参数
以下网络参数设置可帮助确保Minio服务器在生产环境负载上的最佳性能。
- *`tcp_fin_timeout`* : 一个socket连接大约需要1.5KB的内存，关闭未使用的socket连接可以减少内存占用，避免出现内存泄露。即使另一方由于某种原因没有关闭socket连接，系统本身也会在到达超时时间时断开连接。 `tcp_fin_timeout`参数定义了内核保持sockets在FIN-WAIT-2状态的超时时间。我们建议设成20，你可以按下面的示例进行设置。
```sh
sysctl -w net.ipv4.tcp_fin_timeout=30
```
- *`tcp_keepalive_probes`* : 这个参数定义了经过几次无回应的探测之后，认为连接断开了。你可以按下面的示例进行设置。
```sh
sysctl -w net.ipv4.tcp_keepalive_probes=5
```
- *`wmem_max`*: 这个参数定义了针对所有类型的连接，操作系统的最大发送buffer大小。
```sh
sysctl -w net.core.wmem_max=540000
```
- *`rmem_max`*: 这个参数定义了针对所有类型的连接，操作系统最大接收buffer大小。
```sh
sysctl -w net.core.rmem_max=540000
```
## 调优虚拟内存
下面是推荐的虚拟内存设置。
- *`swappiness`* : 此参数控制了交换运行时内存的相对权重，而不是从page缓存中删除page。取值范围是[0,100],我们建议设成10。
```sh
sysctl -w vm.swappiness=10
```
- *`dirty_background_ratio`*: 这个是`脏`页可以占系统内存的百分比，内存页仍需要写到磁盘上。我们建议要尽早将数据写到磁盘上，越早越好。为了达到这个目的，将 `dirty_background_ratio` 设成1。
```sh
sysctl -w vm.dirty_background_ratio=1
```
- *`dirty_ratio`*: 这定义了在所有事务必须提交到磁盘之前，可以用脏页填充的系统内存的绝对最大数量。
```sh
sysctl -w vm.dirty_ratio=5
```
## 调优调度程序
正确的调度程序配置确保Minio进程获得足够的CPU时间。 以下是推荐的调度程序设置。
- *`sched_min_granularity_ns`*: 此参数定义了一个任务在被其它任务抢占时，可在CPU一次运行的最短时间，我们建议设成10ms。
```sh
sysctl -w kernel.sched_min_granularity_ns=10000000
```
- *`sched_wakeup_granularity_ns`*: 降低该参数值可以减少唤醒延迟，提高吞吐量。
```sh
sysctl -w kernel.sched_wakeup_granularity_ns=15000000
```
## 调优磁盘
我们将磁盘调优的建议整合到了注释完备的 [shell script](https://github.com/minio/minio/blob/master/docs/deployment/kernel-tuning/disk-tuning.sh)，敬请查看。

119
docs/zh_CN/distributed/README.md Normal file
View File

@ -0,0 +1,119 @@
# 分布式Minio快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
分布式Minio可以让你将多块硬盘（甚至在不同的机器上）组成一个对象存储服务。由于硬盘分布在不同的节点上，分布式Minio避免了单点故障。
## 分布式Minio有什么好处?
在大数据领域，通常的设计理念都是无中心和分布式。Minio分布式模式可以帮助你搭建一个高可用的对象存储服务，你可以使用这些存储设备，而不用考虑其真实物理位置。
### 数据保护
分布式Minio采用 [erasure code](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)来防范多个节点宕机和[位衰减`bit rot`](https://github.com/minio/minio/blob/master/docs/zh_CN/erasure/README.md#what-is-bit-rot-protection)。
分布式Minio至少需要4个节点，使用分布式Minio自动引入了纠删码功能。
### 高可用
单机Minio服务存在单点故障，相反，如果是一个N节点的分布式Minio,只要有N/2节点在线，你的数据就是安全的。不过你需要至少有N/2+1个节点 [Quorum](https://github.com/minio/dsync#lock-process) 来创建新的对象。
例如，一个8节点的Minio集群，每个节点一块盘，就算4个节点宕机，这个集群仍然是可读的，不过你需要5个节点才能写数据。
### 限制
分布式Minio单租户存在最少4个盘最多16个盘的限制（受限于纠删码）。这种限制确保了Minio的简洁，同时仍拥有伸缩性。如果你需要搭建一个多租户环境，你可以轻松的使用编排工具（Kubernetes）来管理多个Minio实例。
注意，只要遵守分布式Minio的限制，你可以组合不同的节点和每个节点几块盘。比如，你可以使用2个节点，每个节点4块盘，也可以使用4个节点，每个节点两块盘，诸如此类。
### 一致性
Minio在分布式和单机模式下，所有读写操作都严格遵守**read-after-write**一致性模型。
# 开始吧
如果你了解Minio单机模式的搭建的话，分布式搭建的流程基本一样，Minio服务基于命令行传入的参数自动切换成单机模式还是分布式模式。
## 1. 前提条件
安装Minio - [Minio快速入门](https://docs.minio.io/docs/zh_CN/minio-quickstart-guide).
## 2. 运行分布式Minio
启动一个分布式Minio实例，你只需要把硬盘位置做为参数传给minio server命令即可，然后，你需要在所有其它节点运行同样的命令。
*注意*
- 分布式Minio里所有的节点需要有同样的access秘钥和secret秘钥，这样这些节点才能建立联接。为了实现这个，你需要在执行minio server命令之前，先将access秘钥和secret秘钥export成环境变量。
- 分布式Minio使用的磁盘里必须是干净的，里面没有数据。
- 下面示例里的IP仅供示例参考，你需要改成你真实用到的IP和文件夹路径。
- 分布式Minio里的节点时间差不能超过3秒，你可以使用[NTP](http://www.ntp.org/) 来保证时间一致。
- 在Windows下运行分布式Minio处于实验阶段，请悠着点使用。
示例1: 启动分布式Minio实例，8个节点，每节点1块盘，需要在8个节点上都运行下面的命令。
#### GNU/Linux 和 macOS
```shell
export MINIO_ACCESS_KEY=<ACCESS_KEY>
export MINIO_SECRET_KEY=<SECRET_KEY>
minio server http://192.168.1.11/export1 http://192.168.1.12/export2 \
http://192.168.1.13/export3 http://192.168.1.14/export4 \
http://192.168.1.15/export5 http://192.168.1.16/export6 \
http://192.168.1.17/export7 http://192.168.1.18/export8
```
#### Windows
```cmd
set MINIO_ACCESS_KEY=<ACCESS_KEY>
set MINIO_SECRET_KEY=<SECRET_KEY>
minio.exe server http://192.168.1.11/C:/data http://192.168.1.12/C:/data ^
http://192.168.1.13/C:/data http://192.168.1.14/C:/data ^
http://192.168.1.15/C:/data http://192.168.1.16/C:/data ^
http://192.168.1.17/C:/data http://192.168.1.18/C:/data
```
![分布式Minio,8节点，每个节点一块盘](https://github.com/minio/minio/blob/master/docs/screenshots/Architecture-diagram_distributed_8.jpg?raw=true)
示例2: 启动分布式Minio实例，4节点，每节点4块盘，需要在4个节点上都运行下面的命令。
#### GNU/Linux 和 macOS
```shell
export MINIO_ACCESS_KEY=<ACCESS_KEY>
export MINIO_SECRET_KEY=<SECRET_KEY>
minio server http://192.168.1.11/export1 http://192.168.1.11/export2 \
http://192.168.1.11/export3 http://192.168.1.11/export4 \
http://192.168.1.12/export1 http://192.168.1.12/export2 \
http://192.168.1.12/export3 http://192.168.1.12/export4 \
http://192.168.1.13/export1 http://192.168.1.13/export2 \
http://192.168.1.13/export3 http://192.168.1.13/export4 \
http://192.168.1.14/export1 http://192.168.1.14/export2 \
http://192.168.1.14/export3 http://192.168.1.14/export4
```
#### Windows
```cmd
set MINIO_ACCESS_KEY=<ACCESS_KEY>
set MINIO_SECRET_KEY=<SECRET_KEY>
minio.exe server http://192.168.1.11/C:/data1 http://192.168.1.11/C:/data2 ^
http://192.168.1.11/C:/data3 http://192.168.1.11/C:/data4 ^
http://192.168.1.12/C:/data1 http://192.168.1.12/C:/data2 ^
http://192.168.1.12/C:/data3 http://192.168.1.12/C:/data4 ^
http://192.168.1.13/C:/data1 http://192.168.1.13/C:/data2 ^
http://192.168.1.13/C:/data3 http://192.168.1.13/C:/data4 ^
http://192.168.1.14/C:/data1 http://192.168.1.14/C:/data2 ^
http://192.168.1.14/C:/data3 http://192.168.1.14/C:/data4
```
![分布式Minio,4节点，每节点4块盘](https://github.com/minio/minio/blob/master/docs/screenshots/Architecture-diagram_distributed_16.jpg?raw=true)
## 3. 验证
验证是否部署成功，使用浏览器访问Minio服务或者使用 [`mc`](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)。多个节点的存储容量和就是分布式Minio的存储容量。
## 了解更多
- [Minio纠删码快速入门](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)
- [使用 `mc`](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)
- [使用 `aws-cli`](https://docs.minio.io/docs/zh_CN/aws-cli-with-minio)
- [使用 `s3cmd](https://docs.minio.io/docs/zh_CN/s3cmd-with-minio)
- [使用 `minio-go` SDK ](https://docs.minio.io/docs/zh_CN/golang-client-quickstart-guide)
- [minio官方文档](https://docs.minio.io)

116
docs/zh_CN/docker/README.md Normal file
View File

@ -0,0 +1,116 @@
# Minio Docker 快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
## 前提条件
您的机器已经安装docker. 从 [这里](https://www.docker.com/community-edition#/download)下载相关软件。
## 在Docker中运行Minio单点模式。
Minio 需要一个持久卷来存储配置和应用数据。不过, 如果只是为了测试一下, 您可以通过简单地传递一个目录（在下面的示例中为`/ data`）启动Minio。这个目录会在容器启动时在容器的文件系统中创建，不过所有的数据都会在容器退出时丢失。
```sh
docker run -p 9000:9000 minio/minio server /data
```
要创建具有永久存储的Minio容器，您需要将本地持久目录从主机操作系统映射到虚拟配置`~/.minio` 并导出`/data`目录。 为此，请运行以下命令
#### GNU/Linux 和 macOS
```sh
docker run -p 9000:9000 --name minio1 \
-v /mnt/data:/data \
-v /mnt/config:/root/.minio \
minio/minio server /data
```
#### Windows
```sh
docker run -p 9000:9000 --name minio1 \
-v D:\data:/data \
-v D:\minio\config:/root/.minio \
minio/minio server /data
```
## 在Docker中运行Minio分布式模式
分布式Minio可以通过 [Docker Compose](https://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-compose) 或者 [Swarm mode](https://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-swarm)进行部署。这两者之间的主要区别是Docker Compose创建了单个主机，多容器部署，而Swarm模式创建了一个多主机，多容器部署。
这意味着Docker Compose可以让你快速的在你的机器上快速使用分布式Minio-非常适合开发，测试环境；而Swarm模式提供了更健壮，生产级别的部署。
## Minio Docker提示
### Minio自定义Access和Secret密钥
要覆盖Minio的自动生成的密钥，您可以将Access和Secret密钥设为环境变量。 Minio允许常规字符串作为Access和Secret密钥。
#### GNU/Linux 和 macOS
```sh
docker run -p 9000:9000 --name minio1 \
-e "MINIO_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE" \
-e "MINIO_SECRET_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" \
-v /mnt/data:/data \
-v /mnt/config:/root/.minio \
minio/minio server /data
```
#### Windows
```powershell
docker run -p 9000:9000 --name minio1 \
-e "MINIO_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE" \
-e "MINIO_SECRET_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" \
-v D:\data:/data \
-v D:\minio\config:/root/.minio \
minio/minio server /data
```
### 使用Docker secrets进行Minio Access和Secret密钥自定义
要覆盖Minio的自动生成的密钥,你可以把secret和access秘钥创建成[Docker secrets](https://docs.docker.com/engine/swarm/secrets/). Minio允许常规字符串作为Access和Secret密钥。
```
echo "AKIAIOSFODNN7EXAMPLE" | docker secret create access_key -
echo "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" | docker secret create secret_key -
```
使用`docker service`创建Minio服务，并读取Docker secrets。
```
docker service create --name="minio-service" --secret="access_key" --secret="secret_key" minio/minio server /data
```
更多 `docker service`信息，请访问 [这里](https://docs.docker.com/engine/swarm/how-swarm-mode-works/services/)
### 获取容器ID
在容器中使用Docker命令, 你需要知道这个容器的 `容器ID` 。 为了获取 `Container ID`, 运行
```sh
docker ps -a
```
`-a` flag 确保你获取所有的容器(创建的，正在运行的，退出的)，然后从输出中识别`Container ID`。
### 启动和停止容器
启动容器,你可以使用 [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) 命令。
```sh
docker start <container_id>
```
停止一下正在运行的容器, 使用 [`docker stop`](https://docs.docker.com/engine/reference/commandline/stop/) 命令。
```sh
docker stop <container_id>
```
### Minio容器日志
获取Minio日志，使用 [`docker logs`](https://docs.docker.com/engine/reference/commandline/logs/) 命令。
```sh
docker logs <container_id>
```
### 监控MinioDocker容器
监控Minio容器使用的资源,使用 [`docker stats`](https://docs.docker.com/engine/reference/commandline/stats/) 命令.
```sh
docker stats <container_id>
```
## 了解更多
* [在Docker Compose上部署Minio](https://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-compose)
* [在Docker Swarm上部署Minio](https://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-swarm)
* [分布式Minio快速入门](https://docs.minio.io/docs/zh_CN/distributed-minio-quickstart-guide)
* [Minio纠删码模式快速入门](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)

50
docs/zh_CN/erasure/README.md Normal file
View File

@ -0,0 +1,50 @@
# Minio纠删码快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio使用纠删码`erasure code`和校验和`checksum`来保护数据免受硬件故障和无声数据损坏。 即便您丢失一半数量（N/2）的硬盘，您仍然可以恢复数据。
## 什么是纠删码`erasure code`?
纠删码是一种恢复丢失和损坏数据的数学算法， Minio采用Reed-Solomon code将对象拆分成N/2数据和N/2 奇偶校验块。 这就意味着如果是12块盘，一个对象会被分成6个数据块、6个奇偶校验块，你可以丢失任意6块盘（不管其是存放的数据块还是奇偶校验块），你仍可以从剩下的盘中的数据进行恢复，是不是很NB，感兴趣的同学请翻墙google。
## 为什么纠删码有用?
纠删码的工作原理和RAID或者复制不同，像RAID6可以在损失两块盘的情况下不丢数据，而Minio纠删码可以在丢失一半的盘的情况下，仍可以保证数据安全。 而且Minio纠删码是作用在对象级别，可以一次恢复一个对象，而RAID是作用在卷级别，数据恢复时间很长。 Minio对每个对象单独编码，存储服务一经部署，通常情况下是不需要更换硬盘或者修复。Minio纠删码的设计目标是为了性能和尽可能的使用硬件加速。
![Erasure](https://github.com/minio/minio/blob/master/docs/screenshots/erasure-code.jpg?raw=true)
## 什么是位衰减`bit rot`保护?
位衰减又被称为数据腐化`Data Rot`、无声数据损坏`Silent Data Corruption`,是目前硬盘数据的一种严重数据丢失问题。硬盘上的数据可能会神不知鬼不觉就损坏了，也没有什么错误日志。正所谓明枪易躲，暗箭难防，这种背地里犯的错比硬盘直接咔咔宕了还危险。 不过不用怕，Minio纠删码采用了高速[BLAKE2](https://blog.minio.io/accelerating-blake2b-by-4x-using-simd-in-go-assembly-33ef16c8a56b#.jrp1fdwer) 基于哈希的校验和来防范位衰减。
## Minio纠删码快速入门
### 1. 前提条件:
安装Minio- [Minio快速入门](https://docs.minio.io/docs/zh_CN/minio-quickstart-guide)
### 2. 以纠删码模式运行Minio
示例: 使用Minio，在12个盘中启动Minio服务。
```sh
minio server /data1 /data2 /data3 /data4 /data5 /data6 /data7 /data8 /data9 /data10 /data11 /data12
```
示例: 使用Minio Docker镜像，在8块盘中启动Minio服务。
```sh
docker run -p 9000:9000 --name minio \
-v /mnt/data1:/data1 \
-v /mnt/data2:/data2 \
-v /mnt/data3:/data3 \
-v /mnt/data4:/data4 \
-v /mnt/data5:/data5 \
-v /mnt/data6:/data6 \
-v /mnt/data7:/data7 \
-v /mnt/data8:/data8 \
minio/minio server /data1 /data2 /data3 /data4 /data5 /data6 /data7 /data8
```
### 3. 验证是否设置成功
你可以随意拔掉硬盘，看Minio是否可以正常读写。

9
docs/zh_CN/gateway/README.md Normal file
View File

@ -0,0 +1,9 @@
# Minio 网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio网关将Amazon S3兼容性添加到第三方云存储提供者。
- [Microsoft Azure Blob Storage](https://github.com/minio/minio/blob/master/docs/gateway/azure.md)
- [Google Cloud Storage](https://github.com/minio/minio/blob/master/docs/gateway/gcs.md) _Alpha release_
## 路线图
* Minio & AWS S3
* Edge Caching - 基于磁盘的代理缓存

17
docs/zh_CN/gateway/azure-limitations.md Normal file
View File

@ -0,0 +1,17 @@
## Minio Azure网关限制
网关继承了下列Azure限制:
- 最大的Multipart part size是100MB.
- 最大的对象大小是10000*100 MB = 1TB
- 不支持针对前缀的存储桶策略，仅支持顶层存储桶策略。
- 网关重启意味着正在进行的multipart上传也需要重新启动，即客户端必须再一次运行NewMultipartUpload。
这是因为S3客户端在NewMultipartUpload中发送元数据，但Azure希望在CompleteMultipartUpload（Azure术语中的PutBlockList）中设置元数据。
This is because S3 clients send metadata in NewMultipartUpload but Azure expects metadata to
be set during CompleteMultipartUpload (PutBlockList in Azure terminology). 在NewMultipartUpload期间，我们将客户端发送的元数据存储在内存中，以便以后可以在CompleteMultipartUpload中将其设置在Azure上。如果网关穗启，这些信息也会丢失。
- 存储桶名称不支持以 "."开始。
- 调用DeleteBucket() 可删除非空存储桶。
其它限制:
- 目前ListMultipartUploads实现不完整，只要存在任意上传的parts,就会返回。
- 不支持存储桶通知。

47
docs/zh_CN/gateway/azure.md Normal file
View File

@ -0,0 +1,47 @@
# Minio Azure 网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio网关将亚马逊S3兼容性添加到微软Azure Blob存储。
## 运行支持微软Azure Blob存储的Minio网关
### 使用Docker
```
docker run -p 9000:9000 --name azure-s3 \
-e "MINIO_ACCESS_KEY=azureaccountname" \
-e "MINIO_SECRET_KEY=azureaccountkey" \
minio/minio gateway azure
```
### 使用二进制
```
export MINIO_ACCESS_KEY=azureaccountname
export MINIO_SECRET_KEY=azureaccountkey
minio gateway azure
```
## 使用Minio浏览器验证
Minio Gateway配有嵌入式网络对象浏览器。 将您的Web浏览器指向http://127.0.0.1:9000确保您的服务器已成功启动。
![截图](https://github.com/minio/minio/blob/master/docs/screenshots/minio-browser-gateway.png?raw=true)
##使用Minio客户端 `mc`验证
`mc` 提供了诸如ls，cat，cp，mirror，diff等UNIX命令的替代方案。它支持文件系统和Amazon S3兼容的云存储服务。
### 配置 `mc`
```
mc config host add myazure http://gateway-ip:9000 azureaccountname azureaccountkey
```
### 列出微软Azure上的容器
```
mc ls myazure
[2017-02-22 01:50:43 PST] 0B ferenginar/
[2017-02-26 21:43:51 PST] 0B my-container/
[2017-02-26 22:10:11 PST] 0B test-container1/
```
### 已知的限制
[限制](https://github.com/minio/minio/blob/master/docs/gateway/azure-limitations.md)
## 了解更多
- [`mc` 命令行接口](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)
- [`aws` 命令行接口](https://docs.minio.io/docs/zh_CN/aws-cli-with-minio)
- [`minfs` 文件系统接口](http://docs.minio.io/docs/zh_CN/minfs-quickstart-guide)
- [`minio-go` Go SDK](https://docs.minio.io/docs/zh_CN/golang-client-quickstart-guide)

9
docs/zh_CN/gateway/gcs-limitations.md Normal file
View File

@ -0,0 +1,9 @@
## Minio GCS 网关限制
网关继承了以下GCS限制:
- 每次上传最多parts数量是1024。
- 暂不支持存储桶策略。
- 暂不支持存储桶通知。
- _List Multipart Uploads_ 和 _List Object parts_ 会一直返回空List,即客户端需要记住已经上传的parts,并使用它用于 _Complete Multipart Upload_。

63
docs/zh_CN/gateway/gcs.md Normal file
View File

@ -0,0 +1,63 @@
# Minio GCS 网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio GCS网关将亚马逊S3兼容性添加到Google云存储。
## 运行支持GCS的Minio 网关
### 为GCS创建服务帐户密钥，并获取凭据文件
1. 访问 [API控制台凭证页面](https://console.developers.google.com/project/_/apis/credentials).
2. 选择您的项目或创建一个新项目， 记下你的项目ID。
3. 在凭据页面，选择 __Create credentials__ 下拉项，然后选择 __Service account key__。
4. 从 __Service account__下拉项, 选择 __New service account__
5. 填写 __Service account name__ 和 __Service account ID__
6. 对于 __Role__, 点击下拉项，选择 __Storage__ -> __Storage Admin__ _(完全控制GCS资源)_
7. 点击 __Create__ 按钮，下载凭据文件到你的桌面，文件名咱们就叫 credentials.json
注意: 设置 *Application Default Credentials*的替代方案 在 [这里](https://developers.google.com/identity/protocols/application-default-credentials)进行了描述。
### 使用 Docker
```
docker run -p 9000:9000 --name gcs-s3 \
-v /path/to/credentials.json:/credentials.json \
-e "GOOGLE_APPLICATION_CREDENTIALS=/credentials.json" \
-e "MINIO_ACCESS_KEY=minioaccountname" \
-e "MINIO_SECRET_KEY=minioaccountkey" \
minio/minio gateway gcs yourprojectid
```
### 使用二进制
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json
export MINIO_ACCESS_KEY=minioaccesskey
export MINIO_SECRET_KEY=miniosecretkey
minio gateway gcs yourprojectid
```
## 使用Minio Browser验证
Minio Gateway配有嵌入式网络对象浏览器。 将您的Web浏览器指向http://127.0.0.1:9000确保您的服务器已成功启动。
![Screenshot](https://github.com/minio/minio/blob/master/docs/screenshots/minio-browser-gateway.png?raw=true)
##使用Minio客户端 `mc`验证
`mc` 提供了诸如ls，cat，cp，mirror，diff等UNIX命令的替代方案。它支持文件系统和Amazon S3兼容的云存储服务。
### 配置 `mc`
```
mc config host add mygcs http://gateway-ip:9000 minioaccesskey miniosecretkey
```
### 列出GCS上的容器
```
mc ls mygcs
[2017-02-22 01:50:43 PST] 0B ferenginar/
[2017-02-26 21:43:51 PST] 0B my-container/
[2017-02-26 22:10:11 PST] 0B test-container1/
```
### 已知的限制
[限制](https://github.com/minio/minio/blob/master/docs/gateway/gcs-limitations.md)
## 了解更多
- [`mc` 命令行接口](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)
- [`aws` 命令行接口](https://docs.minio.io/docs/zh_CN/aws-cli-with-minio)
- [`minfs` 文件系统接口](http://docs.minio.io/docs/zh_CN/minfs-quickstart-guide)
- [`minio-go` Go SDK](https://docs.minio.io/docs/zh_CN/golang-client-quickstart-guide)

51
docs/zh_CN/minio-limitations.md Normal file
View File

@ -0,0 +1,51 @@
## Minio服务限制/租户
### 纠删码 (多块硬盘 / 服务)
|项目|参数|
|:---|:---|
|最大驱动器数量|16|
|最小驱动器数量|4|
|读仲裁|N / 2|
|写仲裁|N / 2+1 |
### 浏览器访问
|项目|参数|
|:---|:---|
|Web浏览器上传大小限制| 5GB|
### Limits of S3 API
|项目|参数|
|:---|:---|
|最大桶数|无限额|
|每桶最大对象数|无限额|
|最大对象大小| 5 TB |
|最小对象大小| 0 B |
|每次PUT操作的最大对象大小| 5 GB |
|每次上传的最大Part数量| 10,000|
|Part大小 |5MB到5GB. 最后一个part可以从0B到5GB|
|每次list parts请求可返回的part最大数量| 1000|
|每次list objects请求可返回的object最大数量| 1000|
|每次list multipart uploads请求可返回的multipart uploads最大数量| 1000|
我们认为下列AWS S3的API有些冗余或者说用处不大，因此我们在minio中没有实现这些接口。如果您有不同意见，欢迎在[github](https://github.com/minio/minio/issues)上提issue。
### Minio不支持的Amazon S3 Bucket API
- BucketACL (可以用 [bucket policies](http://docs.minio.io/docs/minio-client-complete-guide#policy))
- BucketCORS (所有HTTP方法的所有存储桶都默认启用CORS)
- BucketLifecycle (Minio纠删码不需要)
- BucketReplication (可以用 [`mc mirror`](http://docs.minio.io/docs/minio-client-complete-guide#mirror))
- BucketVersions, BucketVersioning (可以用 [`s3git`](https://github.com/s3git/s3git))
- BucketWebsite (可以用 [`caddy`](https://github.com/mholt/caddy) or [`nginx`](https://www.nginx.com/resources/wiki/))
- BucketAnalytics, BucketMetrics, BucketLogging (可以用 [bucket notification](http://docs.minio.io/docs/minio-client-complete-guide#events) APIs)
- BucketRequestPayment
- BucketTagging
### Minio不支持的Amazon S3 Object API.
- ObjectACL (可以用 [bucket policies](http://docs.minio.io/docs/minio-client-complete-guide#policy))
- ObjectTorrent

55
docs/zh_CN/multi-tenancy/README.md Normal file
View File

@ -0,0 +1,55 @@
# Minio多租户（Multi-tenant）部署指南 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
## 单机部署
要在单台机器上托管多个租户，为每个租户运行一个Minio server,使用不同的HTTPS端口、配置和数据目录。
#### 示例1：单主机，单磁盘
以下示例在一块磁盘上托管三个租户。
```sh
minio --config-dir ~/tenant1 server --address :9001 /data/tenant1
minio --config-dir ~/tenant2 server --address :9002 /data/tenant2
minio --config-dir ~/tenant3 server --address :9003 /data/tenant3
```
![示例1](https://github.com/minio/minio/blob/master/docs/screenshots/Example-1.jpg?raw=true)
#### 示例2：单主机，多块磁盘 (erasure code)
以下示例在多块磁盘上托管三个租户。
```sh
minio --config-dir ~/tenant1 server --address :9001 /disk1/data/tenant1 /disk2/data/tenant1 /disk3/data/tenant1 /disk4/data/tenant1
minio --config-dir ~/tenant2 server --address :9002 /disk1/data/tenant2 /disk2/data/tenant2 /disk3/data/tenant2 /disk4/data/tenant2
minio --config-dir ~/tenant3 server --address :9003 /disk1/data/tenant3 /disk2/data/tenant3 /disk3/data/tenant3 /disk4/data/tenant3
```
![示例2](https://github.com/minio/minio/blob/master/docs/screenshots/Example-2.jpg?raw=true)
## 分布式部署
要在分布式环境中托管多个租户，同时运行多个分布式Minio实例。
To host multiple tenants in a distributed environment, run several distributed Minio instances concurrently.
#### 示例3 : 多主机，多块磁盘 (erasure code)
以下示例在一个4节点集群中托管三个租户。在4个节点里都执行下列命令：
```sh
export MINIO_ACCESS_KEY=<TENANT1_ACCESS_KEY>
export MINIO_SECRET_KEY=<TENANT1_SECRET_KEY>
minio --config-dir ~/tenant1 server --address :9001 http://192.168.10.11/data/tenant1 http://192.168.10.12/data/tenant1 http://192.168.10.13/data/tenant1 http://192.168.10.14/data/tenant1
export MINIO_ACCESS_KEY=<TENANT2_ACCESS_KEY>
export MINIO_SECRET_KEY=<TENANT2_SECRET_KEY>
minio --config-dir ~/tenant2 server --address :9002 http://192.168.10.11/data/tenant2 http://192.168.10.12/data/tenant2 http://192.168.10.13/data/tenant2 http://192.168.10.14/data/tenant2
export MINIO_ACCESS_KEY=<TENANT3_ACCESS_KEY>
export MINIO_SECRET_KEY=<TENANT3_SECRET_KEY>
minio --config-dir ~/tenant3 server --address :9003 http://192.168.10.11/data/tenant3 http://192.168.10.12/data/tenant3 http://192.168.10.13/data/tenant3 http://192.168.10.14/data/tenant3
```
![示例3](https://github.com/minio/minio/blob/master/docs/screenshots/Example-3.jpg?raw=true)
## 云端可伸缩部署
对于大型多租户Minio部署，我们建议使用一个流行的容器编排平台，比如Kubernetes、DC/OS，或者是Docker Swarm.参考 [这个文档](https://docs.minio.io/docs/zh_CN/minio-deployment-quickstart-guide) ,学习如何在编排平台中使用Minio。

24
docs/zh_CN/orchestration/README.md Normal file
View File

@ -0,0 +1,24 @@
# Minio部署快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Minio是一个[云原生](https://baike.baidu.com/item/Cloud%20Native/19865304?fr=aladdin)的应用程序，旨在在多租户环境中以可持续的方式进行扩展。Orchestration平台为Minio的扩展提供了非常好的支撑。以下是各种orchestration平台的Minio部署文档
Minio is a cloud-native application designed to scale in a sustainable manner in multi-tenant environments. Orchestration platforms provide perfect launchpad for Minio to scale. Below is the list of Minio deployment documents for various orchestration platforms:
| Orchestration平台|
|:---|
| [`Docker Swarm`](http://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-swarm) |
| [`Docker Compose`](http://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-compose) |
| [`Kubernetes`](http://docs.minio.io/docs/zh_CN/deploy-minio-on-kubernetes) |
| [`DC/OS`](http://docs.minio.io/docs/zh_CN/deploy-minio-on-dc-os) |
## 为什么说Minio是云原生的（cloud-native）?
云原生这个词代表的是一些思想的集合，比如微服务部署，可伸缩，而不是说把一个单体应用改造成容器部署。一个云原生的应用在设计时就考虑了移植性和可伸缩性，而且可以通过简单的复制即可实现水平扩展。现在兴起的编排平台，想Swarm,Kubernetes,以及DC/OS，让大规模集群的复制和管理变得前所未有的简单，哪里不会点哪里。
容器提供了隔离的应用执行环境，编排（orchestration）平台通过容器管理以及复制功能提供了无缝的扩展。Minio继承了这些，针对每个租户提供了存储环境的隔离。
Minio是建立在云原生的基础上，有纠删码、分布式和共享存储这些特性。Minio专注于并且只专注于存储，而且做的还不错。它可以通过编排平台复制一个Minio实例就实现了水平扩展。
> 在一个云原生环境中，伸缩性不是应用的一个功能而是编排平台的功能。
现在的应用、数据库，key-store这些，很多都已经部署在容器中，并且通过编排平台进行管理。Minio提供了一个健壮的、可伸缩、AWS S3兼容的对象存储，这是Minio的立身之本，凭此在云原生应用中占据一席之地。
![Cloud-native](https://github.com/minio/minio/blob/master/docs/screenshots/Minio_Cloud_Native_Arch.jpg?raw=true)

43
docs/zh_CN/orchestration/dcos/README.md Normal file
View File

@ -0,0 +1,43 @@
# 在 DC/OS上部署minio [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
要在DC/OS上部署Minio，可以使用我们的 [official universe package](https://github.com/mesosphere/universe/tree/version-3.x/repo/packages/M/minio/6).
## 1. 前提条件
- DC/OS 1.9或更新版本
- [Marathon-LB](https://dcos.io/docs/1.9/usage/service-discovery/marathon-lb/usage/) 必须安装并启动。
- 识别Marathon-LB或者一个指向Marathon-LB的public agent(s)的可用主机名的 [IP of the public agent](https://dcos.io/docs/1.9/administration/locate-public-agent/) 。
## 2. 设置Minio
你可以使用DC/OS GUI或者CLI安装Minio Universe package。
### 使用DC/OS GUI安装Minio
- 访问DC/OS admin页面，然后点击左边栏的Universe,然后点击Packages页签，搜索Minio,点击左边栏的```Install```按钮。
- 点击按钮`Install Package`进行一键安装。你可以通过`host:9000`访问你的Minio server,其中`host`是Marathon-LB所在服务器的IP或者主机名。 `minio` 和 `minio123` 分别是默认的access key和secret key。
- 更多关于自定义安装的内容，请看[这里](https://github.com/dcos/zh_CN/examples/blob/master/minio/1.9/README.md#minio-installation-using-gui).
### 使用DC/OS CLI安装Minio
使用命令行安装, 输入
```bash
$ dcos package install minio
```
## 3. 卸载Minio
你确定要这么做吗，如果你真要这么做，我们也不会像国内的软件那么无赖。如需卸载，请输入
```bash
$ dcos package uninstall minio
```
### 了解更多
- [Minio Erasure Code QuickStart Guide](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)
- [DC/OS Project](https://docs.mesosphere.com/)

49
docs/zh_CN/orchestration/docker-compose/README.md Normal file
View File

@ -0,0 +1,49 @@
# 使用Docker Compose部署Minio [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Docker Compose允许定义和运行单主机，多容器Docker应用程序。
使用Compose，您可以使用Compose文件来配置Minio服务。 然后，使用单个命令，您可以通过你的配置创建并启动所有分布式Minio实例。 分布式Minio实例将部署在同一主机上的多个容器中。 这是建立基于分布式Minio的开发，测试和分期环境的好方法。
## 1. 前提条件
* 熟悉 [Docker Compose](https://docs.docker.com/compose/overview/).
* Docker已经在本机安装，从[这里](https://www.docker.com/community-edition#/download)下载相关的安装器。
## 2. 在Docker Compose上运行分布式Minio
在Docker Compose上部署分布式Minio,请下载[docker-compose.yaml](https://github.com/minio/minio/blob/master/docs/orchestration/docker-compose/docker-compose.yaml?raw=true)到你的当前工作目录。Docker Compose会pull Minio Docker Image,所以你不需要手动去下载Minio binary。然后运行下面的命令
### GNU/Linux and macOS
```sh
docker-compose pull
docker-compose up
```
### Windows
```sh
docker-compose.exe pull
docker-compose.exe up
```
现在每个实例都可以访问，端口从9001到9004，请在浏览器中访问http://127.0.0.1:9001/
### 注意事项
* 默认情况下Docker Compose file使用的是最新版的Minio server的Docker镜像，你可以修改image tag来拉取指定版本的[Minio Docker image](https://hub.docker.com/r/minio/minio/).
* 默认情况下会创建4个minio实例，你可以添加更多的Minio服务（最多总共16个）到你的Minio Comose deployment。添加一个服务
* 复制服务定义并适当地更改新服务的名称。
* 更新每个服务中的命令部分。
* 更新要为新服务公开的端口号。 另外，请确保分配给新服务的端口尚未使用。
关于分布式Minio的更多资料，请访问[这里](https://docs.minio.io/docs/zh_CN/distributed-minio-quickstart-guide).
* Docker compose file中的Minio服务使用的端口是9001到9004，这允许多个服务在主机上运行。
### 了解更多
- [Docker Compose概述](https://docs.docker.com/compose/overview/)
- [Minio Docker快速入门](https://docs.minio.io/docs/zh_CN/minio-docker-quickstart-guide)
- [使用Docker Swarm部署Minio](https://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-swarm)
- [Minio纠删码快速入门](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)

86
docs/zh_CN/orchestration/docker-swarm/README.md Normal file
View File

@ -0,0 +1,86 @@
# 使用Docker Swarm部署Minio [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Docker Engine在Swarm模式下提供集群管理和编排功能。 Minio服务器可以在Swarm的分布式模式下轻松部署，创建一个多租户，高可用性和可扩展的对象存储。
从[Docker Engine v1.13.0](https://blog.docker.com/2017/01/whats-new-in-docker-1-13/) (Docker Compose v3.0)开始, Docker Swarm和Compose 二者[cross-compatible](https://docs.docker.com/compose/compose-file/#version-3)。这允许将Compose file用作在Swarm上部署服务的模板。 我们使用Docker Compose file创建分布式Minio设置。
## 1. 前提条件
* 熟悉[Swarm mode key concepts](https://docs.docker.com/engine/swarm/key-concepts/).
* Docker engine v1.13.0运行在[networked host machines]集群上(https://docs.docker.com/engine/swarm/swarm-tutorial/#/three-networked-host-machines).
## 2. 创建Swarm
在管理节点上创建一个swarm,请运行下面的命令
```shell
docker swarm init --advertise-addr <MANAGER-IP>
```
一旦swarm初使化了，你可以看到下面的响应信息
```shell
docker swarm join \
--token SWMTKN-1-49nj1cmql0jkz5s954yi3oex3nedyz0fb0xx14ie39trti4wxv-8vxv8rssmk743ojnwacrr2e7c \
192.168.99.100:2377
```
你现在可以运行上述命令[添加worker节点](https://docs.docker.com/engine/swarm/swarm-tutorial/add-nodes/)到swarm。更多关于创建swarm的细节步骤，请访问[Docker documentation site](https://docs.docker.com/engine/swarm/swarm-tutorial/create-swarm/).
## 3. 为Minio创建Docker secret
```shell
echo "AKIAIOSFODNN7EXAMPLE" | docker secret create access_key -
echo "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" | docker secret create secret_key -
```
## 4. 部署分布式minio服务
在你的Swarm master上下载[Docker Compose file](https://github.com/minio/minio/blob/master/docs/orchestration/docker-swarm/docker-compose-secrets.yaml?raw=true) ，然后运行下面的命令
```shell
docker stack deploy --compose-file=docker-compose-secrets.yaml minio_stack
```
这将把Compose file里描述的服务部署为Docker stack`minio_stack`。 更多 `docker stack` [命令参考](https://docs.docker.com/engine/reference/commandline/stack/)。
在stack成功部署之后，你可以通过[Minio Client](https://docs.minio.io/docs/zh_CN/minio-client-complete-guide) `mc` 或者浏览器访问http://[Node_Public_IP_Address]:[Expose_Port_on_Host]来访问你的Minio server。
## 4. 删除分布式Minio services
删除分布式Minio services以及相关的网络，请运行下面的命令
```shell
docker stack rm minio_stack
```
Swarm不会自动删除为Minio服务创建的host volumes,如果下次新的Minio服务不熟到swarm上，可能会导致损坏。因此，我们建议手动删除所有Minio使用的volumes。为此，到每一个swarm的节点上，列出所有的volumes
```shell
docker volume ls
```
然后删除`minio_stack` volumes
```shell
docker volume rm volume_name
```
### 注意事项
* 默认情况下Docker Compose file使用的是最新版的Minio server的Docker镜像，你可以修改image tag来拉取指定版本的[Minio Docker image](https://hub.docker.com/r/minio/minio/).
* 默认情况下会创建4个minio实例，你可以添加更多的Minio服务（最多总共16个）到你的Minio Comose deployment。添加一个服务
* 复制服务定义并适当地更改新服务的名称。
* 更新每个服务中的命令部分。
* 更新要为新服务公开的端口号。 另外，请确保分配给新服务的端口尚未使用。
关于分布式Minio的更多资料，请访问[这里](https://docs.minio.io/docs/zh_CN/distributed-minio-quickstart-guide).
* 默认情况下，Minio服务使用的是`local` volume driver. 更多配置选项，请访问[Docker documentation](https://docs.docker.com/compose/compose-file/#/volume-configuration-reference) 。
* Docker compose file中的Minio服务使用的端口是9001到9004，这允许多个服务在主机上运行。更多配置选项，请访问[Docker documentation](https://docs.docker.com/compose/compose-file/#/ports).
* Docker Swarm默认使用的是ingress做负载均衡，你可以跟据需要配置[external load balancer based](https://docs.docker.com/engine/swarm/ingress/#/configure-an-external-load-balancer)。
### 了解更多
- [Docker Swarm mode概述](https://docs.docker.com/engine/swarm/)
- [Minio Docker快速入门](https://docs.minio.io/docs/zh_CN/minio-docker-quickstart-guide)
- [使用Docker Compose部署Minio](https://docs.minio.io/docs/zh_CN/deploy-minio-on-docker-compose)
- [Minio纠删码快速入门](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)

543
docs/zh_CN/orchestration/kubernetes-yaml/README.md Normal file
View File

@ -0,0 +1,543 @@
# 使用Kubernetes做Minio的云原生部署 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
## 目录
- [前提条件](#前提条件)
- [Minio独立模式部署](#Minio-Standalone模式部署)
- [Minio独立模式快速入门](#Minio独立模式快速入门)
- [创建持久卷声明](#Minio独立模式快速入门)
- [创建Minio的部署](#创建Minio的部署)
- [创建Miniio服务](#创建Miniio服务)
- [更新已有的Minio部署](#更新已有的Minio部署)
- [独立模式资源清理](#独立模式资源清理)
- [Minio分布式服务部署](#Minio分布式服务部署)
- [分布式快速入门](#分布式快速入门)
- [创建Minio Headless服务](#创建Minio-Headless服务)
- [创建Minio Statefulset](#创建Minio-Statefulset)
- [创建负载均衡服务](#创建负载均衡服务)
- [更新已存在的Minio StatefulSet](#更新已存在的Minio-StatefulSet)
- [分布式模式资源清理](#分布式模式资源清理)
- [Minio GCS 网关部署](#Minio-GCS网关部署)
- [GCS 网关快速入门](#GCS-网关快速入门)
- [创建GCS凭据](#创建GCS凭据)
- [创建Minio GCS Gateway部署](#创建Minio-GCS-Gateway部署)
- [创建Minio LoadBalancer服务](#创建Minio-LoadBalancer服务)
- [更新现有的Minio GCS部署](#更新现有的Minio-GCS部署)
- [GCS网关资源清理](#GCS网关资源清理)
## 前提条件
运行该示例，你需要安装并运行Kubernetes版本>=1.4的集群，而且已经安装 [`kubectl`](https://kubernetes.io/docs/tasks/kubectl/install/) 命令行工具。请访问
[getting started guides](https://kubernetes.io/docs/getting-started-guides/)获取响应平台的安装指导。
## Minio Standalone模式部署
以下部分描述了如何在Kubernetes上部署一个独立的 [Minio](https://minio.io/) 服务。部署使用的是Docker Hub上的 [官方Minio Docker image](https://hub.docker.com/r/minio/minio/~/dockerfile/) 。
此部分使用了以下Kubernetes的核心组件:
- [_Pods_](https://kubernetes.io/docs/user-guide/pods/)
- [_Services_](https://kubernetes.io/docs/user-guide/services/)
- [_Deployments_](https://kubernetes.io/docs/user-guide/deployments/)
- [_Persistent Volume Claims_](https://kubernetes.io/docs/user-guide/persistent-volumes/#persistentvolumeclaims)
### Minio独立模式快速入门
运行下面的命令快速启动
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-pvc.yaml?raw=true
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-deployment.yaml?raw=true
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-service.yaml?raw=true
```
### 创建持久卷声明
Minio需要持久卷来存储对象。如果没有持久卷，Minio实例中的数据将会存到容器的文件系统中，而且在容器重启时会被清除的干干净净。
创建一个持久卷声明（PVC），为Minio实例请求存储。Kubernetes寻找与群集中的PVC请求匹配的PV，并自动将其绑定到PVC。
这是一个PVC的描述
```sh
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
# 此名称唯一标识PVC。 将在以下部署中使用。
name: minio-pv-claim
annotations:
volume.alpha.kubernetes.io/storage-class: anything
labels:
app: minio-storage-claim
spec:
# 关于 access modes的更多细节，访问这里: http://kubernetes.io/docs/user-guide/persistent-volumes/#access-modes
accessModes:
- ReadWriteOnce
resources:
# This is the request for storage. Should be available in the cluster.
requests:
storage: 10Gi
```
创建一个持久卷声明
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-pvc.yaml?raw=true
persistentvolumeclaim "minio-pv-claim" created
```
### 创建Minio的部署
部署封装了副本集和pod - 因此，如果pod掉线，复制控制器会确保另一个pod自动出现。 这样，您就不必担心pod失败，并且可以提供稳定的Minio服务。
这是一个部署的描述
```sh
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
# This name uniquely identifies the Deployment
name: minio-deployment
spec:
strategy:
type: Recreate
template:
metadata:
labels:
# Label is used as selector in the service.
app: minio
spec:
# Refer to the PVC created earlier
volumes:
- name: data
persistentVolumeClaim:
# Name of the PVC created earlier
claimName: minio-pv-claim
containers:
- name: minio
# Pulls the default Minio image from Docker Hub
image: minio/minio:RELEASE.2017-05-05T01-14-51Z
args:
- server
- /data
env:
# Minio access key and secret key
- name: MINIO_ACCESS_KEY
value: "minio"
- name: MINIO_SECRET_KEY
value: "minio123"
ports:
- containerPort: 9000
hostPort: 9000
# Mount the volume into the pod
volumeMounts:
- name: data # must match the volume name, above
mountPath: "/data"
```
创建一个部署
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-deployment.yaml?raw=true
deployment "minio-deployment" created
```
### 创建Miniio服务
现在您正在运行Minio部署，您可能希望在内部（集群内）访问它，或者将其作为服务暴露在外部（集群外部，也可能是公共Internet）IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
在此示例中，我们通过创建LoadBalancer服务来公开Minio部署。
这是服务描述。
```sh
apiVersion: v1
kind: Service
metadata:
name: minio-service
spec:
type: LoadBalancer
ports:
- port: 9000
targetPort: 9000
protocol: TCP
selector:
app: minio
```
创建Minio服务
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-service.yaml?raw=true
service "minio-service" created
```
`LoadBalancer` 服务需要几分钟才能启动。 要检查服务是否已成功创建，请运行命令
```sh
kubectl get svc minio-service
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
minio-service 10.55.248.23 104.199.249.165 9000:31852/TCP 1m
```
### 更新已有的Minio部署
您可以更新现有的Minio部署以使用较新的Minio版本。 为此，请使用`kubectl set image`命令：
```sh
kubectl set image deployment/minio-deployment minio=<replace-with-new-minio-image>
```
Kubernetes将重新启动部署以更新镜像。 成功更新后，您将收到以下消息：
```
deployment "minio-deployment" image updated
```
### 独立模式资源清理
你可以清理集群占用的资源，请运行：
```sh
kubectl delete deployment minio-deployment \
&& kubectl delete pvc minio-pv-claim \
&& kubectl delete svc minio-service
```
## Minio分布式服务部署
以下文档介绍了在Kubernetes上部署[分布式Minio](https://docs.minio.io/docs/zh_CN/distributed-minio-quickstart-guide)服务器的过程。 本示例使用Docker Hub的[官方Minio Docker镜像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
此示例使用以下Kubernetes的核心组件：
- [_Pods_](https://kubernetes.io/docs/concepts/workloads/pods/pod/)
- [_Services_](https://kubernetes.io/docs/concepts/services-networking/service/)
- [_Statefulsets_](https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/)
### 分布式快速入门
运行下面的命令快速启动
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-headless-service.yaml?raw=true
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-statefulset.yaml?raw=true
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-service.yaml?raw=true
```
###创建Minio Headless服务
Headless服务控制在其中创建StatefulSets的域。此服务管理的域采用以下格式：`$(service name).$(namespace).svc.cluster.local`（其中“cluster.local”是集群域），此域中的pod采用形式: `$(pod-name-{i}).$(service name).$(namespace).svc.cluster.local`。这里需要DNS来解析在Statefulset中创建的每个pods的URL。
这是Headless service的描述。
```sh
apiVersion: v1
kind: Service
metadata:
name: minio
labels:
app: minio
spec:
clusterIP: None
ports:
- port: 9000
name: minio
selector:
app: minio
```
创建Headless服务
```sh
$ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-headless-service.yaml?raw=true
service "minio" created
```
###创建Minio Statefulset
StatefulSet为每个pod提供确定性名称和唯一身份，从而轻松部署有状态的分布式应用程序。 要启动分布式Minio，您需要将驱动器位置作为参数传递到minio服务的命令。 然后，您需要在所有参与的pod上运行相同的命令。 StatefulSets提供了一个完美的方式来处理这个要求。
这是Statefulset的描述。
```sh
apiVersion: apps/v1beta1
kind: StatefulSet
metadata:
name: minio
spec:
serviceName: minio
replicas: 4
template:
metadata:
annotations:
pod.alpha.kubernetes.io/initialized: "true"
labels:
app: minio
spec:
containers:
- name: minio
env:
- name: MINIO_ACCESS_KEY
value: "minio"
- name: MINIO_SECRET_KEY
value: "minio123"
image: minio/minio:RELEASE.2017-05-05T01-14-51Z
args:
- server
- http://minio-0.minio.default.svc.cluster.local/data
- http://minio-1.minio.default.svc.cluster.local/data
- http://minio-2.minio.default.svc.cluster.local/data
- http://minio-3.minio.default.svc.cluster.local/data
ports:
- containerPort: 9000
hostPort: 9000
# These volume mounts are persistent. Each pod in the PetSet
# gets a volume mounted based on this field.
volumeMounts:
- name: data
mountPath: /data
# These are converted to volume claims by the controller
# and mounted at the paths mentioned above.
volumeClaimTemplates:
- metadata:
name: data
annotations:
volume.alpha.kubernetes.io/storage-class: anything
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
```
创建Statefulset
```sh
$ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-statefulset.yaml?raw=true
statefulset "minio" created
```
### 创建负载均衡服务
现在您已经运行了Minio statefulset，您可能希望在内部（集群内）访问它，或将其作为服务暴露在外部（集群外，也可能是公用Internet）的IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
在此示例中，我们通过创建LoadBalancer服务来公开Minio部署。
这是服务描述。
```sh
apiVersion: v1
kind: Service
metadata:
name: minio-service
spec:
type: LoadBalancer
ports:
- port: 9000
targetPort: 9000
protocol: TCP
selector:
app: minio
```
创建Minio service
```sh
$ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-service.yaml?raw=true
service "minio-service" created
```
`LoadBalancer` 服务需要几分钟才能启动。 要检查服务是否已成功创建，请运行命令
```sh
$ kubectl get svc minio-service
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
minio-service 10.55.248.23 104.199.249.165 9000:31852/TCP 1m
```
###更新已经存在的Minio StatefulSet
您可以更新现有的Minio StatefulSet以使用较新的Minio版本。 为此，请使用`kubectl patch statefulset`命令：
```sh
kubectl patch statefulset minio --type='json' -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/image", "value":"<replace-with-new-minio-image>"}]'
```
成功更新后，您应该会看到下面的输出
```
statefulset "minio" patched
```
然后如下所示，逐一删除StatefulSet中的所有pod。 Kubernetes将使用新的镜像为您重新启动那些pod。
```sh
kubectl delete minio-0
```
### 分布式模式资源清理
你可以使用以下命令清理集群
```sh
kubectl delete statefulset minio \
&& kubectl delete svc minio \
&& kubectl delete svc minio-service
```
## Minio GCS网关部署
以下部分介绍在Kubernetes上部署[Minio](https://minio.io/)GCS Gateway的过程。 部署使用Docker Hub的[官方Minio Docker映像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
此示例使用以下Kubernetes的核心组件：
- [_Secrets_](https://kubernetes.io/docs/concepts/configuration/secret/)
- [_Services_](https://kubernetes.io/docs/user-guide/services/)
- [_Deployments_](https://kubernetes.io/docs/user-guide/deployments/)
### GCS 网关快速入门
按照 [这里](https://github.com/minio/minio/blob/master/docs/gateway/gcs.md#create-service-account-key-for-gcs-and-get-the-credentials-file)描述的步骤创建Google云服务认证凭据文件。
使用上面生成的文件来创建一个Kubernetes`secret`。
```sh
kubectl create secret generic gcs-credentials --from-file=/path/to/gcloud/credentials/application_default_credentials.json
```
下载 `minio-gcs-gateway-deployment.yaml`
```sh
wget https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-deployment.yaml?raw=true
```
使用你的GCS project ID更新 `gcp_project_id`部分的内容，然后运行
```sh
kubectl create -f minio-gcs-gateway-deployment.yaml
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-service.yaml?raw=true
```
### 创建GCS凭据
`凭据`旨在保存敏感信息，例如密码，OAuth令牌和ssh密钥。 将这些信息放在一个凭据中比将其逐字地放在pod定义或docker镜像中更安全，更灵活。
按照 [这里](https://github.com/minio/minio/blob/master/docs/gateway/gcs.md#create-service-account-key-for-gcs-and-get-the-credentials-file)描述的步骤创建Google云服务认证凭据文件。
使用上面生成的文件来创建一个Kubernetes`secret`。
```sh
kubectl create secret generic gcs-credentials --from-file=/path/to/gcloud/credentials/application_default_credentials.json
```
### 创建Minio GCS Gateway部署
部署封装了副本集和pod - 因此，如果pod掉线，复制控制器会确保另一个pod自动出现。 这样，您就不必担心pod失败，并且可以提供稳定的Minio服务。
Minio Gateway使用GCS作为其存储后端，需要使用GCP“projectid”来识别您的凭据。 使用GCS项目ID更新“gcp_project_id”部分。 这是部署描述。
```sh
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
# This name uniquely identifies the Deployment
name: minio-deployment
spec:
strategy:
type: Recreate
template:
metadata:
labels:
# Label is used as selector in the service.
app: minio
spec:
# Refer to the secret created earlier
volumes:
- name: gcs-credentials
secret:
# Name of the Secret created earlier
secretName: gcs-credentials
containers:
- name: minio
# Pulls the default Minio image from Docker Hub
image: minio/minio:RELEASE.2017-08-05T00-00-53Z
args:
- gateway
- gcs
- gcp_project_id
env:
# Minio access key and secret key
- name: MINIO_ACCESS_KEY
value: "minio"
- name: MINIO_SECRET_KEY
value: "minio123"
# Google Cloud Service uses this variable
- name: GOOGLE_APPLICATION_CREDENTIALS
value: "/etc/credentials/application_default_credentials.json"
ports:
- containerPort: 9000
hostPort: 9000
# Mount the volume into the pod
volumeMounts:
- name: gcs-credentials
mountPath: "/etc/credentials"
readOnly: true
```
创建部署
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-deployment.yaml?raw=true
deployment "minio-deployment" created
```
### 创建Minio LoadBalancer服务
现在您正在运行Minio，您可能希望在内部（集群内）访问它，或者将其作为服务暴露在外部（集群外部，也可能是公共Internet）IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
在此示例中，我们通过创建LoadBalancer服务来暴露Minio。 这是服务描述。
```sh
apiVersion: v1
kind: Service
metadata:
name: minio-service
spec:
type: LoadBalancer
ports:
- port: 9000
targetPort: 9000
protocol: TCP
selector:
app: minio
```
创建Minio服务
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-service.yaml?raw=true
service "minio-service" created
```
`LoadBalancer`服务需要几分钟才能启动。 要检查服务是否已成功创建，请运行命令
```sh
kubectl get svc minio-service
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
minio-service 10.55.248.23 104.199.249.165 9000:31852/TCP 1m
```
### 更新现有的Minio GCS部署
您可以更新现有的Minio部署以使用较新的Minio版本。 为此，请使用`kubectl set image`命令：
```sh
kubectl set image deployment/minio-deployment minio=<replace-with-new-minio-image>
```
Kubernetes将重新启动部署以更新镜像。 成功更新后，您将收到以下消息：
```
deployment "minio-deployment" image updated
```
### GCS网关资源清理
你可以使用下面的命令清理集群
```sh
kubectl delete deployment minio-deployment \
&& kubectl delete secret gcs-credentials
```

155
docs/zh_CN/orchestration/kubernetes/README.md Normal file
View File

@ -0,0 +1,155 @@
# 使用Kubernetes部署Minio [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Kubernetes的部署和状态集提供了在独立，分布式或共享模式下部署Minio服务器的完美平台。 在Kubernetes上部署Minio有多种选择，您可以选择最适合您的。
- Minio [Helm](https://helm.sh) Chart通过一个简单的命令即可提供自定义而且简单的Minio部署。更多关于Minio Helm部署的资料，请访问[这里](#prerequisites).
- 你也可以浏览Kubernetes [Minio示例](https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/README.md) ，通过`.yaml`文件来部署Minio。
- 如果您想在Kubernetes上开始使用Minio，而无需创建真正的容器集群，您也可以使用Minikube [deploy Minio locally](https://raw.githubusercontent.com/minio/minio/master/docs/orchestration/minikube/README.md)。
<a name="prerequisites"></a>
## 1. 前提条件
* 默认standaline模式下，需要开启Beta API的Kubernetes 1.4+。
* [distributed 模式](#distributed-minio)，需要开启Beta API的Kubernetes 1.5+。
* 底层支持PV provisioner。
* 你的K8s集群里需要有Helm package manager [installed](https://github.com/kubernetes/helm#install)。
## 2. 使用Helm Chart部署Minio
安装 Minio chart
```bash
$ helm install stable/minio
```
以上命令以默认配置在Kubernetes群集上部署Minio。 以下部分列出了Minio图表的所有可配置参数及其默认值。
### 配置
| 参数 | 描述 | 默认值 |
|----------------------------|-------------------------------------|---------------------------------------------------------|
| `image` | Minio镜像名称 | `minio/minio` |
| `imageTag` | Minio镜像tag. 可选值在 [这里](https://hub.docker.com/r/minio/minio/tags/).| `RELEASE.2017-08-05T00-00-53Z`|
| `imagePullPolicy` | Image pull policy | `Always` |
| `mode` | Minio server模式 (`standalone`, `shared` 或者 `distributed`)| `standalone` |
| `numberOfNodes` | 节点数 (仅对分布式模式生效). 可选值 4 <= x <= 16 | `4` |
| `accessKey` | 默认access key | `AKIAIOSFODNN7EXAMPLE` |
| `secretKey` | 默认secret key | `wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY` |
| `configPath` | 默认配置文件路径 | `~/.minio` |
| `mountPath` | 默认挂载路径| `/export` |
| `serviceType` | Kubernetes service type | `LoadBalancer` |
| `servicePort` | Kubernetes端口 | `9000` |
| `persistence.enabled` | 是否使用持久卷存储数据 | `true` |
| `persistence.size` | 持久卷大小 | `10Gi` |
| `persistence.storageClass` | 持久卷类型 | `generic` |
| `persistence.accessMode` | ReadWriteOnce 或者 ReadOnly | `ReadWriteOnce` |
| `resources` | CPU/Memory 资源需求/限制 | Memory: `256Mi`, CPU: `100m` |
你可以通过`--set key=value[,key=value]`给`helm install`。 比如,
```bash
$ helm install --name my-release \
--set persistence.size=100Gi \
stable/minio
```
上述命令部署了一个带上100G持久卷的Minio服务。
或者，您可以提供一个YAML文件，用于在安装chart时指定参数值。 例如，
```bash
$ helm install --name my-release -f values.yaml stable/minio
```
### 分布式Minio
默认情况下，此图表以独立模式提供Minio服务器。 要在[分布式模式](https://docs.minio.io/docs/zh_CN/distributed-minio-quickstart-guide)中配置Minio服务器，请将`mode`字段设置为`distributed`,
```bash
$ helm install --set mode=distributed stable/minio
```
上述命令部署了个带有4个节点的分布式Minio服务器。 要更改分布式Minio服务器中的节点数，请设置`numberOfNodes`属性。
```bash
$ helm install --set mode=distributed,numberOfNodes=8 stable/minio
```
上述命令部署了个带有8个节点的分布式Minio服务器。注意一下，`numberOfNodes`取值范围是[4,16]。
#### StatefulSet [限制](http://kubernetes.io/docs/concepts/abstractions/controllers/statefulsets/#limitations)，适用于分布式Minio
* StatefulSets需要持久化存储，所以如果 `mode`设成 `distributed`的话，`persistence.enabled`参数不生效。
* 卸载分布式Minio版本时，需要手动删除与StatefulSet关联的卷。
### Shared Minio
如需采用[shared mode](https://github.com/minio/minio/blob/master/docs/shared-backend/README.md)部署Minio, 将`mode` 设为`shared`,
```bash
$ helm install --set mode=shared stable/minio
```
上述命令规定了4个Minio服务器节点，一个存储。 要更改共享的Minio部署中的节点数，请设置`numberOfNodes`字段，
```bash
$ helm install --set mode=shared,numberOfNodes=8 stable/minio
```
上述命令规定了Minio服务有8个节点，采用shared模式。
### 持久化
这里规定了PersistentVolumeClaim并将相应的持久卷挂载到默认位置`/export`。 您需要Kubernetes集群中的物理存储才能使其工作。 如果您宁愿使用`emptyDir`，请通过以下方式禁用PersistentVolumeClaim：
```bash
$ helm install --set persistence.enabled=false stable/minio
```
> *"当Pod分配给节点时，首先创建一个emptyDir卷，只要该节点上的Pod正在运行，它就会存在。 当某个Pod由于任何原因从节点中删除时，emptyDir中的数据将永久删除。"*
## 3. 使用Helm更新Minio版本
您可以更新现有的Minio Helm Release以使用较新的Minio Docker镜像。 为此，请使用`helm upgrade`命令：
```bash
$ helm upgrade --set imageTag=<replace-with-minio-docker-image-tag> <helm-release-name> stable/minio
```
如果更新成功，你可以看到下面的输出信息
```bash
Release "your-helm-release" has been upgraded. Happy Helming!
```
## 4. 卸载Chart
假设你的版本被命名为`my-release`，使用下面的命令删除它：
```bash
$ helm delete my-release
```
该命令删除与chart关联的所有Kubernetes组件，并删除该release。
### 提示
* 在Kubernetes群集中运行的chart的实例称为release。 安装chart后，Helm会自动分配唯一的release名称。 你也可以通过下面的命令设置你心仪的名称：
```bash
$ helm install --name my-release stable/minio
```
* 为了覆盖默认的秘钥，可在运行helm install时将access key和secret key做为参数传进去。
```bash
$ helm install --set accessKey=myaccesskey,secretKey=mysecretkey \
stable/minio
```
### 了解更多
- [Minio纠删码快速入门](https://docs.minio.io/docs/zh_CN/minio-erasure-code-quickstart-guide)
- [Kubernetes文档](https://kubernetes.io/docs/home/)
- [Helm package manager for kubernetes](https://helm.sh/)

46
docs/zh_CN/orchestration/minikube/README.md Normal file
View File

@ -0,0 +1,46 @@
# 使用minikube在本地部署分布式Minio
[![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Minikube在计算机的VM中运行单节点Kubernetes集群。 这样可以轻松地在计算机上本地运行的Kubernetes上部署分布式Minio服务器。
## 1. 前提条件
本机已经安装[Minikube](https://github.com/kubernetes/minikube/blob/master/README.md#installation) 和 [`kubectl`](https://kubernetes.io/docs/user-guide/prereqs/)
## 2. 步骤
* 下载 `minio_distributed.sh` 和 `statefulset.yaml`
```sh
wget https://raw.githubusercontent.com/minio/minio/master/docs/orchestration/minikube/minio_distributed.sh
wget https://raw.githubusercontent.com/minio/minio/master/docs/orchestration/minikube/statefulset.yaml
```
* 在命令提示符下执行`minio_distributed.sh`脚本。
```sh
./minio_distributed.sh
```
脚本执行成功后，您应该会收到一个这样的输出
```sh
service "minio-public" created
service "minio" created
statefulset "minio" created
```
这意味着Minio部署在您当地的Minikube安装中。
请注意，服务“minio-public”是一个[clusterIP]（https://kubernetes.io/docs/user-guide/services/#publishing-services---service-types）服务。 它在集群内部IP上暴露服务。 通过`kubectl port-forward`命令连接到Minio实例，执行
```
kubectl port-forward minio-0 9000:9000
```
Minio服务器现在可以在`http:// localhost:9000`访问，使用`statefulset.yaml`文件中所述的accessKey和secretKey。
## 3. 注意
Minikube目前不支持动态配置，因此我们手动创建PersistentVolumes（PV）和PersistentVolumeClaims（PVC）。 创建PV和PVC后，我们将调用`statefulset.yaml`配置文件来创建分布式的Minio设置。
此设置在笔记本电脑/计算机上运行。 因此，只有一个磁盘用作所有minio实例PV的后端。 Minio将这些PV视为单独的磁盘，并报告可用存储不正确。

141
docs/zh_CN/shared-backend/DESIGN.md Normal file
View File

@ -0,0 +1,141 @@
介绍 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
------------
该特性可以让多个Minio实例使用一个共享的NAS存储，而且不需要做什么特殊的设置。文件默认已经做了同步以及加锁。
目的
----------
由于Minio的设计理念是为单租户场景服务，所以用户希望采用在一个存储后端上运行多个Minio实例，这个存储后端可能是一个已有的NAS。Minio支持这种共享存储后端的特性，而且不需要用户做额外的设置。
限制
------------
* 如果正在执行GetObject()，则PutObject()会阻塞并等待。
* 如果正在执行PutObject()或者GetObject()，则CompleteMultipartUpload()会阻塞并等待。
* 无法
* A CompleteMultipartUpload() is blocked and waits if another PutObject() or GetObject() is in progress.
* 无法运行FS模式作为remote disk RPC。
## 如何运行?
运行共享存储后端的Minio和直接运行在一块独立磁盘的Minio没有啥区别，不需要做额外设置来开启这个特性。访问NAS上的文件默认就会加锁和同步。以下示例将对您选择的每个操作系统上的操作进行阐述：
### Ubuntu 16.04 LTS
示例1: 运行Minio实例在持载在`/path/to/nfs-volume`路径下的共享后端存储。
On linux server1
```shell
minio server /path/to/nfs-volume
```
On linux server2
```shell
minio server /path/to/nfs-volume
```
### Windows 2012 Server
示例1: 运行Minio实例在持载在`\\remote-server\cifs`路径下的共享后端存储。
On windows server1
```cmd
minio.exe server \\remote-server\cifs\data
```
On windows server2
```cmd
minio.exe server \\remote-server\cifs\data
```
或者共享存储挂载在`D:\`盘.
On windows server1
```cmd
minio.exe server D:\data
```
On windows server2
```cmd
minio.exe server D:\data
```
架构
------------------
## POSIX/Win32 Locks
### Lock process
在同一个Minio实例中，lock由现有的内存命名空间锁（** sync.RWMutex **等）处理。 为了在许多Minio实例之间同步锁，我们利用Unix上的POSIX`fcntl（）`锁定和Windows`LockFileEx（）`Win32 API）。 如果相邻Minio实例在同一路径上有任何读锁，则写锁请求会被阻塞。 如果有正在进行的写锁，读锁也是如此。
### Unlock process
关闭文件描述符（fd）就会将之前获得的锁释放。关闭fd将告诉内核放弃当前进程在路径上保留的所有锁。当相同进程在同一路径上有多个读操作时，这会变得更加棘手，这意味着关闭一个fd也会为所有并发读释放锁。 为了正确地处理这种情况，实现了简单的fd引用计数，多个读操作之间共享相同的fd。 当读操作开始关闭fd时，我们开始减少引用计数，一旦引用计数达到零，我们可以确保没有更多的活跃读操作。 所以我们继续关闭底层文件描述符，这将放弃在路径上保留的读锁。
这个不适用于写操作，因为对于每个对象总是有一个写和多个读。
## 处理并发。
这里的一个例子显示了如何使用GetObject()处理争用。
GetObject()持有`fs.json`的一个读锁。
```go
fsMetaPath := pathJoin(fs.fsPath, minioMetaBucket, bucketMetaPrefix, bucket, object, fsMetaJSONFile)
rlk, err := fs.rwPool.Open(fsMetaPath)
if err != nil {
return toObjectErr(traceError(err), bucket, object)
}
defer rlk.Close()
... you can perform other operations here ...
_, err = io.CopyBuffer(writer, reader, buf)
... after successful copy operation unlocks the read lock ...
```
对同一个对象的并发PutObject操作
在同一个对象上请求一个并发的PutObject, PutObject()尝试获取一个`fs.json`上的写锁。
```go
fsMetaPath := pathJoin(fs.fsPath, minioMetaBucket, bucketMetaPrefix, bucket, object, fsMetaJSONFile)
wlk, err := fs.rwPool.Create(fsMetaPath)
if err != nil {
return ObjectInfo{}, toObjectErr(err, bucket, object)
}
// This close will allow for locks to be synchronized on `fs.json`.
defer wlk.Close()
```
现在从上面的代码片段可以看到，直到GetObject()返回。 以下部分代码将被阻塞。
```go
wlk, err := fs.rwPool.Create(fsMetaPath)
```
这咱限制是必须的，以避免给客户端返回损坏的数据。反之亦然，PutObject(),GetObject()也会等待PutObject()完成之后再执行。
### 警告 (并发)
假设有3个Minio服务共享一个存储后端
minio1
- DeleteObject(object1) --> 在object1删除操作时持有`fs.json`的锁。
minio2
- PutObject(object1) --> 等DeleteObject完毕后进行锁定。
minio3
- PutObject(object1) --> (concurrent request during PutObject minio2 checking if `fs.json` exists)
一旦获取到锁之后，minio2验证文件是否真的存在，以避免获得已被删除的fd的锁。但是这种情况与minio3存在竞争，因为minio3也在尝试写同一个文件。这就存在一种可能，`fs.json`已经被创建了，所以minio2获得的锁就无效，这样就可能会导致数据不一致。
这是一种已知的问题，而且没办法通过POSIX fcntl锁来解决。这种情况是共享存储后端的限制，请你知晓。

71
docs/zh_CN/shared-backend/README.md Normal file
View File

@ -0,0 +1,71 @@
# Minio共享后端存储快速入门[![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io) [![Go Report Card](https://goreportcard.com/badge/minio/minio)](https://goreportcard.com/report/minio/minio) [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/) [![codecov](https://codecov.io/gh/minio/minio/branch/master/graph/badge.svg)](https://codecov.io/gh/minio/minio)
Minio共享模式可以让你使用一个[NAS](https://en.wikipedia.org/wiki/Network-attached_storage) 做为多个Minio服务的存储后端。我我们在设计时已经对多个Minio服务之间的同步做了很多的处理。更多Minio共享模式的设计文档，请访问[这里](https://github.com/minio/minio/blob/master/docs/shared-backend/DESIGN.md).
Minio共享模式是为了解决在真实场景中存在的一些问题，而且不需要做额外的配置。
如果你有下列需求，则可以考虑Minio共享模式
- 你已经买了NAS设备，并想在存储层使用Minio来增加S3兼容。
- 你的应用架构要求你使用带有S3接口的NAS。
- 你的应用存在亚历山大的流量，你想给你的NAS设备增加一个有负载均衡能力的S3兼容的服务。
在多个共享模式的Minio服务前面加一层代理，你很容易就能获得一个高可用，负载均衡，AWS S3兼容的存储系统。
# 开始
如果你知道怎么部署单机Minio,共享模式的部署和运行也是一样一样的。
## 1. 前提条件
安装Minio - [Minio快速入门](https://docs.minio.io/docs/zh_CN/minio).
## 2. 在共享后端存储上运行Minio
为了让Minio在共享后端上运行起来，你需要启动多个Minio服务，这些服务指向同一个后端存储。下面我们就来讲解如何设置。
*注意*
- 使用共享存储的所有Minio节点需要有相同的access key和secret key。为了做到这一点，我们在所有节点上将access key和secret key export成环境变量，然后再去启动Minio服务。
- 下面出现的存储路径都是为了演示目的，在真实环境中使用时，你应该替换成你真实要用的路径。
#### Minio shared mode on Ubuntu 16.04 LTS.
你需要将文件夹指向共享存储，比如`/path/to/nfs-volume`，然后在所有Minio节点上运行下面的命令。
```sh
export MINIO_ACCESS_KEY=<ACCESS_KEY>
export MINIO_SECRET_KEY=<SECRET_KEY>
minio server /path/to/nfs-volume
```
#### Minio shared mode on Windows 2012 Server
你需要将文件夹指向共享存储，比如`\\remote-server\smb`. 然后在所有Minio节点上运行下面的命令。
```cmd
set MINIO_ACCESS_KEY=my-username
set MINIO_SECRET_KEY=my-password
minio.exe server \\remote-server\smb\export
```
*Windows提示*
如果一个远程的volume, 比如`\\remote-server\smb`挂载成一个硬盘, 比如`M:\`. 你可以使用[`net use`](https://technet.microsoft.com/en-us/library/bb490717.aspx)命令将这块盘映射到一个文件夹。
```cmd
set MINIO_ACCESS_KEY=my-username
set MINIO_SECRET_KEY=my-password
net use m: \\remote-server\smb\export /P:Yes
minio.exe server M:\export
```
## 3. 验证
为了验证部署是否成功，可能通过浏览器或者[`mc`](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)访问Minio。你应该可以从各个Minio节点访问上传的文件。
## 了解更多
- [使用`mc`](https://docs.minio.io/docs/zh_CN/minio-client-quickstart-guide)
- [使用`aws-cli`](https://docs.minio.io/docs/zh_CN/aws-cli-with-minio)
- [使用`s3cmd`](https://docs.minio.io/docs/zh_CN/s3cmd-with-minio)
- [使用`minio-go` SDK](https://docs.minio.io/docs/zh_CN/golang-client-quickstart-guide)
- [Minio文档](https://docs.minio.io)

129
docs/zh_CN/tls/README.md Normal file
View File

@ -0,0 +1,129 @@
# 使用TLS安全的访问Minio服务[![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
本文，我们讲介绍如何在Linux和Windows上配置Minio服务使用TLS。
## 1. 前提条件
* 下载Minio server [这里](https://docs.minio.io/docs/minio-quickstart-guide)
## 2. 配置已存在的证书
如果你已经有私钥和公钥证书，你需要将它们拷贝到Minio的config/`certs`文件夹,分别取名为`private.key` 和 `public.crt`。
如果这个证书是被证书机构签发的，`public.crt`应该是服务器的证书，任何中间体的证书以及CA的根证书的级联。
## 3. 生成证书
### Linux
Minio在Linux只支持使用PEM格式的key/certificate。
#### 使用 Let's Encrypt
更多信息，请访问 [这里](https://docs.minio.io/docs/zh_CN/generate-let-s-encypt-certificate-using-concert-for-minio)
#### 使用 generate_cert.go (self-signed certificate)
你需要下载 [generate_cert.go](https://golang.org/src/crypto/tls/generate_cert.go?m=text)，它是一个简单的go工具，可以生成自签名的证书，不过大多数情况下用着都是木有问题的。
`generate_cert.go` 已经提供了带有DNS和IP条目的SAN证书:
```sh
go run generate_cert.go -ca --host "10.10.0.3"
```
#### 使用 OpenSSL:
生成私钥:
```sh
openssl genrsa -out private.key 2048
```
生成自签名证书:
```sh
openssl req -new -x509 -days 3650 -key private.key -out public.crt -subj "/C=US/ST=state/L=location/O=organization/CN=domain"
```
### Windows
Minio在Windows上只支持PEM格式的key/certificate，目前不支持PFX证书。
#### 安装 GnuTLS
下载并解压[GnuTLS](http://www.gnutls.org/download.html)
确保将解压后的binary路径加入到系统路径中。
```
setx path "%path%;C:\Users\MyUser\Downloads\gnutls-3.4.9-w64\bin"
```
你可能需要重启powershell控制台来使其生效。
#### 生成private.key
运行下面的命令来生成 `private.key`
```
certtool.exe --generate-privkey --outfile private.key
```
#### 生成public.crt
创建文件`cert.cnf`，填写必要信息来生成证书。
```
# X.509 Certificate options
#
# DN options
# The organization of the subject.
organization = "Example Inc."
# The organizational unit of the subject.
#unit = "sleeping dept."
# The state of the certificate owner.
state = "Example"
# The country of the subject. Two letter code.
country = "EX"
# The common name of the certificate owner.
cn = "Sally Certowner"
# In how many days, counting from today, this certificate will expire.
expiration_days = 365
# X.509 v3 extensions
# DNS name(s) of the server
dns_name = "localhost"
# (Optional) Server IP address
ip_address = "127.0.0.1"
# Whether this certificate will be used for a TLS server
tls_www_server
# Whether this certificate will be used to encrypt data (needed
# in TLS RSA ciphersuites). Note that it is preferred to use different
# keys for encryption and signing.
encryption_key
```
生成公钥证书
```
certtool.exe --generate-self-signed --load-privkey private.key --template cert.cnf --outfile public.crt
```
## 4. 安装第三方CAs
Minio可以配置成连接其它服务，不管是Minio节点还是像NATs、Redis这些。如果这些服务用的不是在已知证书机构注册的证书，你可以让Minio服务信任这些CA，怎么做呢，将这些证书放到Minio配置路径下(`~/.minio/certs/CAs/` Linux 或者 `C:\Users\<Username>\.minio\certs\CAs` Windows).
# 了解更多
* [Minio快速入门](https://docs.minio.io/docs/zh_CN/minio-quickstart-guide)
* [Minio客户端权威指南](https://docs.minio.io/docs/zh_CN/minio-client-complete-guide)