MyFavMirrors/minio
1
0
Fork 0
mirror of https://github.com/minio/minio.git synced 2025-11-11 06:20:14 -05:00
Code Issues Packages Projects Releases Wiki Activity

Replace Minio refs in docs with MinIO and links (#7494)

Browse Source
This commit is contained in:
kannappanr
2019-04-09 11:39:42 -07:00
committed by GitHub
parent 188ac8e369
commit 5ecac91a55
800 changed files with 2054 additions and 2054 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
docs/zh_CN/FreeBSD.md
View File

@@ -1,6 +1,6 @@
# Minio FreeBSD 快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
# MinIO FreeBSD 快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
### Minio with ZFS backend - FreeBSD
### MinIO with ZFS backend - FreeBSD
此示例假设你已经有正在运行的FreeBSD 11.x。
#### 启动 ZFS service
@@ -51,13 +51,13 @@ zpool status -x
all pools are healthy
```
#### 启动Minio服务
从FreeBSD port安装 [Minio](https://minio.io)。
#### 启动MinIO服务
从FreeBSD port安装 [MinIO](https://min.io)。
```sh
pkg install minio
```
配置Minio,让其使用挂载在`/minio-example/compressed-objects`的ZFS卷。
配置MinIO,让其使用挂载在`/minio-example/compressed-objects`的ZFS卷。
```
sysrc minio_enable=yes
sysrc minio_disks=/minio-example/compressed-objects
@@ -68,9 +68,9 @@ sysrc minio_disks=/minio-example/compressed-objects
service minio start
```
现在你已经成功的让Minio运行在ZFS上，你上传的对象都获得了磁盘级别的压缩功能，访问 http://localhost:9000。
现在你已经成功的让MinIO运行在ZFS上，你上传的对象都获得了磁盘级别的压缩功能，访问 http://localhost:9000。
#### 关闭Minio服务
#### 关闭MinIO服务
```sh
service minio stop
```

2
docs/zh_CN/backend/README.md
View File

@@ -2,7 +2,7 @@
Minio目前支持两种类型的后端。
| Minio | FS | Erasure | Stability |
| MinIO | FS | Erasure | Stability |
|:-----------:|:----:|:----:|:---:|
| Standalone | x | x | Stable |
| Distributed | x | x | Stable |

2
docs/zh_CN/backend/fs/README.md
View File

@@ -14,7 +14,7 @@ type ObjectPartInfo struct {
type fsMetaV1 struct {
Version string `json:"version"`
Format string `json:"format"`
Minio struct {
MinIO struct {
Release string `json:"release"`
} `json:"minio"`
// Metadata map for current object `fs.json`.

4
docs/zh_CN/backend/xl/README.md
View File

@@ -42,8 +42,8 @@ type xlMetaV1 struct {
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 {
// MinIO release tag for current object `xl.json`.
MinIO struct {
Release string `json:"release"`
} `json:"minio"`
// Metadata map for current object `xl.json`.

4
docs/zh_CN/browser/README.md
View File

@@ -1,6 +1,6 @@
## Minio Browser
## MinIO Browser
Minio Browser使用Json Web Token来验证JSON RPC请求。
MinIO Browser使用Json Web Token来验证JSON RPC请求。
初使请求为用户提供的`AccessKey`和`SecretKey`生成一个token令牌

168
docs/zh_CN/bucket/notifications/README.md
View File

@@ -1,4 +1,4 @@
# Minio存储桶通知指南 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
# MinIO存储桶通知指南 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
存储桶（Bucket）如果发生改变,比如上传对象和删除对象，可以使用存储桶事件通知机制进行监控，并通过以下方式发布出去:
@@ -16,17 +16,17 @@
## 前提条件
* 从[这里](https://docs.minio.io/cn/minio-quickstart-guide)下载并安装Minio Server。
* 从[这里](https://docs.minio.io/cn/minio-client-quickstart-guide)下载并安装Minio Client。
* 从[这里](https://docs.min.io/cn/minio-quickstart-guide)下载并安装MinIO Server。
* 从[这里](https://docs.min.io/cn/minio-client-quickstart-guide)下载并安装MinIO Client。
<a name="AMQP"></a>
## 使用AMQP发布Minio事件
## 使用AMQP发布MinIO事件
从[这里](https://www.rabbitmq.com/)下载安装RabbitMQ。
### 第一步: 将AMQP endpoint添加到Minio
### 第一步: 将AMQP endpoint添加到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。AMQP配置信息是在`notify`这个节点下的`amqp`节点下，在这里为你的AMQP实例创建配置信息键值对，key是你的AMQP endpoint的名称，value是下面表格中列列的键值对集合。
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。AMQP配置信息是在`notify`这个节点下的`amqp`节点下，在这里为你的AMQP实例创建配置信息键值对，key是你的AMQP endpoint的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
@@ -64,14 +64,14 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。AMQP配置
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:amqp`。
更新完配置文件后，重启MinIO Server让配置生效。如果一切顺利，MinIO Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:amqp`。
Minio支持[RabbitMQ](https://www.rabbitmq.com/)中所有的交换方式，这次我们采用 ``fanout`` 交换。
MinIO支持[RabbitMQ](https://www.rabbitmq.com/)中所有的交换方式，这次我们采用 ``fanout`` 交换。
注意一下，你可以听从你内心的想法，想配几个AMQP服务就配几个，只要每个AMQP服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第二步: 使用Minio客户端启用bucket通知
### 第二步: 使用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.
@@ -135,13 +135,13 @@ python rabbit.py
```
<a name="MQTT"></a>
## 使用MQTT发布Minio事件
## 使用MQTT发布MinIO事件
从 [这里](https://mosquitto.org/)安装MQTT Broker。
### 第一步: 添加MQTT endpoint到Minio
### 第一步: 添加MQTT endpoint到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MQTT配置信息是在`notify`这个节点下的`mqtt`节点下，在这里为你的MQTT实例创建配置信息键值对，key是你的MQTT endpoint的名称，value是下面表格中列列的键值对集合。
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。MQTT配置信息是在`notify`这个节点下的`mqtt`节点下，在这里为你的MQTT实例创建配置信息键值对，key是你的MQTT endpoint的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
@@ -150,7 +150,7 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MQTT配置
| `broker` | _string_ | (必须) MQTT server endpoint, 例如. `tcp://localhost:1883` |
| `topic` | _string_ | (必须) 要发布的MQTT主题的名称, 例如. `minio` |
| `qos` | _int_ | 设置服务质量级别 |
| `clientId` | _string_ | MQTT代理识别Minio的唯一ID |
| `clientId` | _string_ | MQTT代理识别MinIO的唯一ID |
| `username` | _string_ | 连接MQTT server的用户名 (如果需要的话) |
| `password` | _string_ | 链接MQTT server的密码 (如果需要的话) |
@@ -170,14 +170,14 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MQTT配置
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:mqtt`。
更新完配置文件后，重启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/)。
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通知
### 第二步: 使用MinIO客户端启用bucket通知
如果一个JPEG图片上传到``myminio`` server里的``images`` 存储桶或者从桶中删除，一个存储桶事件通知就会被触发。 这里ARN值是``arn:minio:sqs:us-east-1:1:mqtt``。
@@ -242,33 +242,33 @@ python mqtt.py
```
<a name="Elasticsearch"></a>
## 使用Elasticsearch发布Minio事件
## 使用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中删除。
如果使用的是 _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中。
如果使用的是_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)。
MinIO要求使用的是ES 5.X系统版本。如果使用的是低版本的ES，也没关系，ES官方支持升级迁移，详情请看[这里](https://www.elastic.co/guide/en/elasticsearch/reference/current/setup-upgrade.html)。
### 第二步：把ES集成到Minio中
### 第二步：把ES集成到MinIO中
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。ES配置信息是在`notify`这个节点下的`elasticsearch`节点下，在这里为你的ES实例创建配置信息键值对，key是你的ES的名称，value是下面表格中列列的键值对集合。
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 |
| `index` | _string_ | (必须) 给MinIO用的index |
以下是ES的一个配置示例:
@@ -283,17 +283,17 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。ES配置
},
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:elasticsearch`。
更新完配置文件后，重启MinIO Server让配置生效。如果一切顺利，MinIO Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:elasticsearch`。
注意一下，你又可以再一次听从你内心的想法，想配几个ES服务就配几个，只要每个ES服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第三步：使用Minio客户端启用bucket通知
### 第三步：使用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)。
要配置这种存储桶通知，我们需要用到前面步骤MinIO输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的MinIO服务别名叫`myminio`,可执行下列脚本：
```
mc mb myminio/images
@@ -369,7 +369,7 @@ $ curl "http://localhost:9200/minio_events/_search?pretty=true"
"source" : {
"host" : "127.0.0.1",
"port" : "38062",
"userAgent" : "Minio (linux; amd64) minio-go/2.0.3 mc/2017-02-15T17:57:25Z"
"userAgent" : "MinIO (linux; amd64) minio-go/2.0.3 mc/2017-02-15T17:57:25Z"
}
}
]
@@ -385,21 +385,21 @@ $ curl "http://localhost:9200/minio_events/_search?pretty=true"
这里我们可以看到这个document ID就是存储桶和对象的名称。如果用的是`access`格式，这个document ID就是由ES随机生成的。
<a name="Redis"></a>
## 使用Redis发布Minio事件
## 使用Redis发布MinIO事件
安装 [Redis](http://redis.io/download)。为了演示，我们将数据库密码设为"yoursecret"。
这种通知目标支持两种格式: _namespace_ 和 _access_。
如果用的是_namespacee_格式，Minio将存储桶里的对象同步成Redis hash中的条目。对于每一个条目，对应一个存储桶里的对象，其key都被设为"存储桶名称/对象名称"，value都是一个有关这个Minio对象的JSON格式的事件数据。如果对象更新或者删除，hash中对象的条目也会相应的更新或者删除。
如果用的是_namespacee_格式，MinIO将存储桶里的对象同步成Redis hash中的条目。对于每一个条目，对应一个存储桶里的对象，其key都被设为"存储桶名称/对象名称"，value都是一个有关这个MinIO对象的JSON格式的事件数据。如果对象更新或者删除，hash中对象的条目也会相应的更新或者删除。
如果使用的是_access_,Minio使用[RPUSH](https://redis.io/commands/rpush)将事件添加到list中。这个list中每一个元素都是一个JSON格式的list,这个list中又有两个元素，第一个元素是时间戳的字符串，第二个元素是一个含有在这个存储桶上进行操作的事件数据的JSON对象。在这种格式下，list中的元素不会更新或者删除。
如果使用的是_access_,MinIO使用[RPUSH](https://redis.io/commands/rpush)将事件添加到list中。这个list中每一个元素都是一个JSON格式的list,这个list中又有两个元素，第一个元素是时间戳的字符串，第二个元素是一个含有在这个存储桶上进行操作的事件数据的JSON对象。在这种格式下，list中的元素不会更新或者删除。
下面的步骤展示如何在`namespace`和`access`格式下使用通知目标。
### 第一步：集成Redis到Minio
### 第一步：集成Redis到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。Redis配置信息是在`notify`这个节点下的`redis`节点下，在这里为你的Redis实例创建配置信息键值对，key是你的Redis端的名称，value是下面表格中的键值对里面值的集合。
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。Redis配置信息是在`notify`这个节点下的`redis`节点下，在这里为你的Redis实例创建配置信息键值对，key是你的Redis端的名称，value是下面表格中的键值对里面值的集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
@@ -422,17 +422,17 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。Redis配
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:redis`。
更新完配置文件后，重启MinIO Server让配置生效。如果一切顺利，MinIO Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:redis`。
注意一下，你永远都可以听从你内心的想法，想配几个Redis服务就配几个，只要每个Redis服务实例有不同的ID (比如前面示例中的"1") 和配置信息。
### 第二步: 使用Minio客户端启用bucket通知
### 第二步: 使用MinIO客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知。一旦有文件被创建或者覆盖，一个新的key会被创建,或者一个已经存在的key就会被更新到之前配置好的redis hash里。如果一个已经存在的对象被删除，这个对应的key也会从hash中删除。因此，这个Redis hash里的行，就映射着`images`存储桶里的`.jpg`对象。
要配置这种存储桶通知，我们需要用到前面步骤Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
要配置这种存储桶通知，我们需要用到前面步骤MinIO输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的MinIO服务别名叫`myminio`,可执行下列脚本：
```
mc mb myminio/images
@@ -457,27 +457,27 @@ OK
mc cp myphoto.jpg myminio/images
```
在上一个终端中，你将看到Minio在Redis上执行的操作：
在上一个终端中，你将看到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\"}}]}"
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`命令。
在这我们可以看到MinIO在`minio_events`这个key上执行了`HSET`命令。
如果用的是`access`格式，那么`minio_events`就是一个list,Minio就会调用`RPUSH`添加到list中。这个list的消费者会使用`BLPOP`从list的最左端删除list元素。
如果用的是`access`格式，那么`minio_events`就是一个list,MinIO就会调用`RPUSH`添加到list中。这个list的消费者会使用`BLPOP`从list的最左端删除list元素。
<a name="NATS"></a>
## 使用NATS发布Minio事件
## 使用NATS发布MinIO事件
安装 [NATS](http://nats.io/).
### 第一步：集成NATS到Minio
### 第一步：集成NATS到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例修改NATS的配置:
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例修改NATS的配置:
```
"nats": {
@@ -501,9 +501,9 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下
},
```
更新完配置文件后，重启Minio Server让配置生效。``bucketevents``是NATS在这个例子中使用的主题。
更新完配置文件后，重启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,参考下面示面进行配置：
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": {
@@ -528,7 +528,7 @@ Minio服务也支持 [NATS Streaming mode](http://nats.io/documentation/streamin
```
更多关于 `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通知
### 第二步: 使用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)。
@@ -638,29 +638,29 @@ 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"}
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发布MinIO事件
安装 [PostgreSQL](https://www.postgresql.org/) 数据库。为了演示，我们将"postgres"用户的密码设为`password`，并且创建了一个`minio_events`数据库来存储事件信息。
这个通知目标支持两种格式: _namespace_ and _access_。
如果使用的是_namespace_格式，Minio将存储桶里的对象同步成数据库表中的行。每一行有两列：key和value。key是这个对象的存储桶名字加上对象名，value都是一个有关这个Minio对象的JSON格式的事件数据。如果对象更新或者删除，表中相应的行也会相应的更新或者删除。
如果使用的是_namespace_格式，MinIO将存储桶里的对象同步成数据库表中的行。每一行有两列：key和value。key是这个对象的存储桶名字加上对象名，value都是一个有关这个MinIO对象的JSON格式的事件数据。如果对象更新或者删除，表中相应的行也会相应的更新或者删除。
如果使用的是_access_,Minio将将事件添加到表里，行有两列：event_time 和 event_data。event_time是事件在Minio server里发生的时间，event_data是有关这个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) 数据类型。
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
### 第二步：集成PostgreSQL到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。PostgreSQL配置信息是在`notify`这个节点下的`postgresql`节点下，在这里为你的PostgreSQL实例创建配置信息键值对，key是你的PostgreSQL的名称，value是下面表格中列列的键值对集合。
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。PostgreSQL配置信息是在`notify`这个节点下的`postgresql`节点下，在这里为你的PostgreSQL实例创建配置信息键值对，key是你的PostgreSQL的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
@@ -670,7 +670,7 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。PostgreSQL
| `table` | _string_ | (必须) 事件对应的表名，如果该表不存在，Mniio server会在启动时创建。|
| `host` | _string_ | (可选) PostgresSQL的主机名，默认是`localhost`|
| `port` | _string_ | (可选) PostgreSQL的端口号，默认是`5432` |
| `user` | _string_ | (可选)数据库用户名，默认是运行Minio server进程的用户|
| `user` | _string_ | (可选)数据库用户名，默认是运行MinIO server进程的用户|
| `password` | _string_ | (可选) 数据库密码 |
| `database` | _string_ | (可选)库名 |
@@ -694,18 +694,18 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。PostgreSQL
注意一下，为了演示，咱们这把SSL禁掉了，但是为了安全起见，不建议在生产环境这么弄。
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:postgresql`。
更新完配置文件后，重启MinIO Server让配置生效。如果一切顺利，MinIO Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:postgresql`。
和之前描述的一样，你也可以添加多个PostreSQL实例，只要ID不重复就行。
### 第三步：使用Minio客户端启用bucket通知
### 第三步：使用MinIO客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦上有文件上传到存储桶中，PostgreSQL中会insert一条新的记录或者一条已经存在的记录会被update，如果一个存在对象被删除，一条对应的记录也会从PostgreSQL表中删除。因此，PostgreSQL表中的行，对应的就是存储桶里的一个对象。
要配置这种存储桶通知，我们需要用到前面步骤中Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
要配置这种存储桶通知，我们需要用到前面步骤中MinIO输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设Minio服务别名叫`myminio`,可执行下列脚本：
有了`mc`这个工具，这些配置信息很容易就能添加上。假设MinIO服务别名叫`myminio`,可执行下列脚本：
```
# Create bucket named `images` in myminio
@@ -739,25 +739,25 @@ key | value
```
<a name="MySQL"></a>
## 使用MySQL发布Minio事件
## 使用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格式的事件数据。如果对象更新或者删除，表中相应的行也会相应的更新或者删除。
如果使用的是_namespace_格式，MinIO将存储桶里的对象同步成数据库表中的行。每一行有两列：key_name和value。key_name是这个对象的存储桶名字加上对象名，value都是一个有关这个MinIO对象的JSON格式的事件数据。如果对象更新或者删除，表中相应的行也会相应的更新或者删除。
如果使用的是_access_,Minio将将事件添加到表里，行有两列：event_time 和 event_data。event_time是事件在Minio server里发生的时间，event_data是有关这个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进行的测试。
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
### 第二步：集成MySQL到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MySQL配置信息是在`notify`这个节点下的`mysql`节点下，在这里为你的MySQL实例创建配置信息键值对，key是你的PostgreSQL的名称，value是下面表格中列列的键值对集合。
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。MySQL配置信息是在`notify`这个节点下的`mysql`节点下，在这里为你的MySQL实例创建配置信息键值对，key是你的PostgreSQL的名称，value是下面表格中列列的键值对集合。
| 参数 | 类型 | 描述 |
|:---|:---|:---|
@@ -788,18 +788,18 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。MySQL配
}
```
更新完配置文件后，重启Minio Server让配置生效。如果一切顺利，Minio Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:mysql`。
更新完配置文件后，重启MinIO Server让配置生效。如果一切顺利，MinIO Server会在启动时输出一行信息，类似 `SQS ARNs: arn:minio:sqs:us-east-1:1:mysql`。
和之前描述的一样，你也可以添加多个MySQL实例，只要ID不重复就行。
### 第三步：使用Minio客户端启用bucket通知
### 第三步：使用MinIO客户端启用bucket通知
我们现在可以在一个叫`images`的存储桶上开启事件通知，一旦上有文件上传到存储桶中，MySQL中会insert一条新的记录或者一条已经存在的记录会被update，如果一个存在对象被删除，一条对应的记录也会从MySQL表中删除。因此，MySQL表中的行，对应的就是存储桶里的一个对象。
要配置这种存储桶通知，我们需要用到前面步骤Minio输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
要配置这种存储桶通知，我们需要用到前面步骤MinIO输出的ARN信息。更多有关ARN的资料，请参考[这里](http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的Minio服务别名叫`myminio`,可执行下列脚本：
有了`mc`这个工具，这些配置信息很容易就能添加上。假设咱们的MinIO服务别名叫`myminio`,可执行下列脚本：
```
# Create bucket named `images` in myminio
@@ -834,17 +834,17 @@ mysql> select * from minio_images;
```
<a name="apache-kafka"></a>
## 使用Kafka发布Minio事件
## 使用Kafka发布MinIO事件
安装[ Apache Kafka](http://kafka.apache.org/).
### 第一步：确保确保至少满足第低要求
Minio要求Kafka版本0.10或者0.9.Minio内部使用了 [Shopify/sarama](https://github.com/Shopify/sarama/) 库，因此需要和该库有同样的版本兼容性。
MinIO要求Kafka版本0.10或者0.9.MinIO内部使用了 [Shopify/sarama](https://github.com/Shopify/sarama/) 库，因此需要和该库有同样的版本兼容性。
###第二步：集成Kafka到Minio
###第二步：集成Kafka到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例更新Kafka配置：
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例更新Kafka配置：
```
"kafka": {
@@ -856,9 +856,9 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下
}
```
重启Minio server让配置生效。``bucketevents``是本示例用到的Kafka主题（topic）。
重启MinIO server让配置生效。``bucketevents``是本示例用到的Kafka主题（topic）。
### 第三步：使用Minio客户端启用bucket通知
### 第三步：使用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)。
@@ -892,13 +892,13 @@ kafkacat -b localhost:9092 -t bucketevents
```
<a name="webhooks"></a>
## 使用Webhook发布Minio事件
## 使用Webhook发布MinIO事件
[Webhooks](https://en.wikipedia.org/wiki/Webhook) 采用推的方式获取数据，而不是一直去拉取。
### 第一步：集成MySQL到Minio
### 第一步：集成MySQL到MinIO
Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例更新Webhook配置：
MinIO Server的配置文件默认路径是 ``~/.minio/config.json``。参考下面的示例更新Webhook配置：
```
"webhook": {
@@ -907,9 +907,9 @@ Minio Server的配置文件默认路径是 ``~/.minio/config.json``。参考下
"endpoint": "http://localhost:3000/"
}
```
endpoint是监听webhook通知的服务。保存配置文件并重启Minio服务让配配置生效。注意一下，在重启Minio时，这个endpoint必须是启动并且可访问到。
endpoint是监听webhook通知的服务。保存配置文件并重启MinIO服务让配配置生效。注意一下，在重启MinIO时，这个endpoint必须是启动并且可访问到。
### 第二步：使用Minio客户端启用bucket通知
### 第二步：使用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)。
@@ -933,7 +933,7 @@ 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](https://github.com/minio/thumbnailer) 来监听MinIO通知。如果有文件上传于是MinIO服务，Thumnailer监听到该通知，生成一个缩略图并上传到MinIO服务。
安装Thumbnailer:
```
@@ -941,13 +941,13 @@ git clone https://github.com/minio/thumbnailer/
npm install
```
然后打开Thumbnailer的``config/webhook.json``配置文件，添加有关Minio server的配置，使用下面的方式启动Thumbnailer:
然后打开Thumbnailer的``config/webhook.json``配置文件，添加有关MinIO server的配置，使用下面的方式启动Thumbnailer:
```
NODE_ENV=webhook node thumbnail-webhook.js
```
Thumbnailer运行在``http://localhost:3000/``。下一步，配置Minio server,让其发送消息到这个URL（第一步提到的），并使用 ``mc`` 来设置存储桶通知（第二步提到的）。然后上传一张图片到Minio server:
Thumbnailer运行在``http://localhost:3000/``。下一步，配置MinIO server,让其发送消息到这个URL（第一步提到的），并使用 ``mc`` 来设置存储桶通知（第二步提到的）。然后上传一张图片到MinIO server:
```
mc cp ~/images.jpg myminio/images
@@ -960,4 +960,4 @@ mc ls myminio/images-thumbnail
[2017-02-08 11:39:40 IST] 992B images-thumbnail.jpg
```
*注意* 如果你用的是 [distributed Minio](https://docs.minio.io/cn/distributed-minio-quickstart-guide),请修改所有节点的 ``~/.minio/config.json``。
*注意* 如果你用的是 [distributed MinIO](https://docs.min.io/cn/distributed-minio-quickstart-guide),请修改所有节点的 ``~/.minio/config.json``。

28
docs/zh_CN/config/README.md
View File

@@ -1,18 +1,18 @@
# 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 `config.json` (v18) 指南 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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)
MinIO server在默认情况下会将所有配置信息存到 `${HOME}/.minio/config.json` 文件中。 以下部分提供每个字段的详细说明以及如何自定义它们。一个完整的 `config.json` 在 [这里](https://raw.githubusercontent.com/minio/minio/master/docs/config/config.sample.json)
## 配置目录
默认的配置目录是 `${HOME}/.minio`，你可以使用`--config-dir`命令行选项重写之。Minio server在首次启动时会生成一个新的`config.json`，里面带有自动生成的访问凭据。
默认的配置目录是 `${HOME}/.minio`，你可以使用`--config-dir`命令行选项重写之。MinIO server在首次启动时会生成一个新的`config.json`，里面带有自动生成的访问凭据。
```sh
minio server --config-dir /etc/minio /data
```
### 证书目录
TLS证书存在``${HOME}/.minio/certs``目录下，你需要将证书放在该目录下来启用`HTTPS` 。如果你是一个乐学上进的好青年，这里有一本免费的秘籍传授一你: [如何使用TLS安全的访问minio](https://docs.minio.io/cn/how-to-secure-access-to-minio-server-with-tls).
TLS证书存在``${HOME}/.minio/certs``目录下，你需要将证书放在该目录下来启用`HTTPS` 。如果你是一个乐学上进的好青年，这里有一本免费的秘籍传授一你: [如何使用TLS安全的访问minio](https://docs.min.io/cn/how-to-secure-access-to-minio-server-with-tls).
以下是一个带来TLS证书的Minio server的目录结构。
以下是一个带来TLS证书的MinIO server的目录结构。
```sh
$ tree ~/.minio
@@ -73,14 +73,14 @@ minio server /data
|参数|类型|描述|
|:---|:---|:---|
|``notify``| |通知通过以下方式开启存储桶事件通知，用于lambda计算|
|``notify.amqp``| |[通过AMQP发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#AMQP)|
|``notify.mqtt``| |[通过MQTT发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#MQTT)|
|``notify.elasticsearch``| |[通过Elasticsearch发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#Elasticsearch)|
|``notify.redis``| |[通过Redis发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#Redis)|
|``notify.nats``| |[通过NATS发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#NATS)|
|``notify.postgresql``| |[通过PostgreSQL发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#PostgreSQL)|
|``notify.kafka``| |[通过Apache Kafka发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#apache-kafka)|
|``notify.webhook``| |[通过Webhooks发布Minio事件](https://docs.minio.io/cn/minio-bucket-notification-guide#webhooks)|
|``notify.amqp``| |[通过AMQP发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#AMQP)|
|``notify.mqtt``| |[通过MQTT发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#MQTT)|
|``notify.elasticsearch``| |[通过Elasticsearch发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#Elasticsearch)|
|``notify.redis``| |[通过Redis发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#Redis)|
|``notify.nats``| |[通过NATS发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#NATS)|
|``notify.postgresql``| |[通过PostgreSQL发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#PostgreSQL)|
|``notify.kafka``| |[通过Apache Kafka发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#apache-kafka)|
|``notify.webhook``| |[通过Webhooks发布MinIO事件](https://docs.min.io/cn/minio-bucket-notification-guide#webhooks)|
## 了解更多
* [Minio Quickstart Guide](https://docs.minio.io/docs/minio-quickstart-guide)
* [MinIO Quickstart Guide](https://docs.min.io/docs/minio-quickstart-guide)

2
docs/zh_CN/deployment/kernel-tuning/README.md
View File

@@ -1,4 +1,4 @@
# 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)
# Linux服务器上Minio生产环境的内核调优 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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)
## 调优网络参数

16
docs/zh_CN/disk-caching/README.md
View File

@@ -1,4 +1,4 @@
# 磁盘缓存快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
# 磁盘缓存快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
这里的磁盘缓存功能是指使用缓存磁盘来存储租户常用的一些数据。例如，假设你通过`gateway azure`设置访问一个对象并下载下来进行缓存，那接下来的请求都会直接访问缓存磁盘上的对象，直至其过期失效。此功能允许Minio用户：
- 对象的读取速度性能最佳。
@@ -7,7 +7,7 @@
## 开始
### 1. 前期条件
安装Minio - [Minio快速入门](https://docs.minio.io/docs/minio-quickstart-guide)。
安装Minio - [Minio快速入门](https://docs.min.io/docs/minio-quickstart-guide)。
### 2. 运行Minio缓存
磁盘缓存可以通过修改Minio服务的`cache`配置来进行开启。配置`cache`设置需要指定磁盘路径、缓存过期时间（以天为单位）以及使用统配符方式指定的不需要进行缓存的对象。
@@ -30,12 +30,12 @@ minio server /export{1...24}
```
### 3. 验证设置是否成功
要验证是否部署成功，你可以通过浏览器或者[`mc`](https://docs.minio.io/docs/minio-client-quickstart-guide)来访问刚刚部署的Minio服务。你应该可以看到上传的文件在所有Minio节点上都可以访问。
要验证是否部署成功，你可以通过浏览器或者[`mc`](https://docs.min.io/docs/minio-client-quickstart-guide)来访问刚刚部署的Minio服务。你应该可以看到上传的文件在所有Minio节点上都可以访问。
# 了解更多
- [磁盘缓存设计](https://github.com/minio/minio/blob/master/docs/disk-caching/DESIGN.md)
- [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)
- [mc快速入门](https://docs.min.io/docs/minio-client-quickstart-guide)
- [使用 aws-cli](https://docs.min.io/docs/aws-cli-with-minio)
- [使用 s3cmd](https://docs.min.io/docs/s3cmd-with-minio)
- [使用 minio-go SDK](https://docs.min.io/docs/golang-client-quickstart-guide)
- [Minio文档](https://docs.min.io)

20
docs/zh_CN/distributed/README.md
View File

@@ -1,4 +1,4 @@
# 分布式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快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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避免了单点故障。
@@ -9,7 +9,7 @@
### 数据保护
分布式Minio采用 [erasure code](https://docs.minio.io/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采用 [erasure code](https://docs.min.io/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自动引入了纠删码功能。
@@ -35,7 +35,7 @@ Minio在分布式和单机模式下，所有读写操作都严格遵守**read-af
## 1. 前提条件
安装Minio - [Minio快速入门](https://docs.minio.io/cn/minio-quickstart-guide).
安装Minio - [Minio快速入门](https://docs.min.io/cn/minio-quickstart-guide).
## 2. 运行分布式Minio
@@ -110,14 +110,14 @@ minio.exe server http://192.168.1.11/C:/data1 http://192.168.1.11/C:/data2 ^
## 3. 验证
验证是否部署成功，使用浏览器访问Minio服务或者使用 [`mc`](https://docs.minio.io/cn/minio-client-quickstart-guide)。多个节点的存储容量和就是分布式Minio的存储容量。
验证是否部署成功，使用浏览器访问Minio服务或者使用 [`mc`](https://docs.min.io/cn/minio-client-quickstart-guide)。多个节点的存储容量和就是分布式Minio的存储容量。
## 了解更多
- [Minio纠删码快速入门](https://docs.minio.io/cn/minio-erasure-code-quickstart-guide)
- [使用 `mc`](https://docs.minio.io/cn/minio-client-quickstart-guide)
- [使用 `aws-cli`](https://docs.minio.io/cn/aws-cli-with-minio)
- [使用 `s3cmd](https://docs.minio.io/cn/s3cmd-with-minio)
- [使用 `minio-go` SDK ](https://docs.minio.io/cn/golang-client-quickstart-guide)
- [Minio纠删码快速入门](https://docs.min.io/cn/minio-erasure-code-quickstart-guide)
- [使用 `mc`](https://docs.min.io/cn/minio-client-quickstart-guide)
- [使用 `aws-cli`](https://docs.min.io/cn/aws-cli-with-minio)
- [使用 `s3cmd](https://docs.min.io/cn/s3cmd-with-minio)
- [使用 `minio-go` SDK ](https://docs.min.io/cn/golang-client-quickstart-guide)
- [minio官方文档](https://docs.minio.io)
- [minio官方文档](https://docs.min.io)

40
docs/zh_CN/docker/README.md
View File

@@ -1,16 +1,16 @@
# 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)
# MinIO Docker 快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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。这个目录会在容器启动时在容器的文件系统中创建，不过所有的数据都会在容器退出时丢失。
## 在Docker中运行MinIO单点模式。
MinIO 需要一个持久卷来存储配置和应用数据。不过, 如果只是为了测试一下, 您可以通过简单地传递一个目录（在下面的示例中为`/ data`）启动MinIO。这个目录会在容器启动时在容器的文件系统中创建，不过所有的数据都会在容器退出时丢失。
```sh
docker run -p 9000:9000 minio/minio server /data
```
要创建具有永久存储的Minio容器，您需要将本地持久目录从主机操作系统映射到虚拟配置`~/.minio` 并导出`/data`目录。 为此，请运行以下命令
要创建具有永久存储的MinIO容器，您需要将本地持久目录从主机操作系统映射到虚拟配置`~/.minio` 并导出`/data`目录。 为此，请运行以下命令
#### GNU/Linux 和 macOS
```sh
@@ -28,15 +28,15 @@ docker run -p 9000:9000 --name minio1 \
minio/minio server /data
```
## 在Docker中运行Minio分布式模式
分布式Minio可以通过 [Docker Compose](https://docs.minio.io/cn/deploy-minio-on-docker-compose) 或者 [Swarm mode](https://docs.minio.io/cn/deploy-minio-on-docker-swarm)进行部署。这两者之间的主要区别是Docker Compose创建了单个主机，多容器部署，而Swarm模式创建了一个多主机，多容器部署。
## 在Docker中运行MinIO分布式模式
分布式MinIO可以通过 [Docker Compose](https://docs.min.io/cn/deploy-minio-on-docker-compose) 或者 [Swarm mode](https://docs.min.io/cn/deploy-minio-on-docker-swarm)进行部署。这两者之间的主要区别是Docker Compose创建了单个主机，多容器部署，而Swarm模式创建了一个多主机，多容器部署。
这意味着Docker Compose可以让你快速的在你的机器上快速使用分布式Minio-非常适合开发，测试环境；而Swarm模式提供了更健壮，生产级别的部署。
这意味着Docker Compose可以让你快速的在你的机器上快速使用分布式MinIO-非常适合开发，测试环境；而Swarm模式提供了更健壮，生产级别的部署。
## Minio Docker提示
## MinIO Docker提示
### Minio自定义Access和Secret密钥
要覆盖Minio的自动生成的密钥，您可以将Access和Secret密钥设为环境变量。 Minio允许常规字符串作为Access和Secret密钥。
### MinIO自定义Access和Secret密钥
要覆盖MinIO的自动生成的密钥，您可以将Access和Secret密钥设为环境变量。 MinIO允许常规字符串作为Access和Secret密钥。
#### GNU/Linux 和 macOS
```sh
@@ -58,15 +58,15 @@ docker run -p 9000:9000 --name minio1 \
minio/minio server /data
```
### 使用Docker secrets进行Minio Access和Secret密钥自定义
要覆盖Minio的自动生成的密钥,你可以把secret和access秘钥创建成[Docker secrets](https://docs.docker.com/engine/swarm/secrets/). Minio允许常规字符串作为Access和Secret密钥。
### 使用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`创建MinIO服务，并读取Docker secrets。
```
docker service create --name="minio-service" --secret="access_key" --secret="secret_key" minio/minio server /data
```
@@ -94,15 +94,15 @@ docker start <container_id>
docker stop <container_id>
```
### Minio容器日志
获取Minio日志，使用 [`docker logs`](https://docs.docker.com/engine/reference/commandline/logs/) 命令。
### 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/) 命令.
监控MinIO容器使用的资源,使用 [`docker stats`](https://docs.docker.com/engine/reference/commandline/stats/) 命令.
```sh
docker stats <container_id>
@@ -111,8 +111,8 @@ docker stats <container_id>
## 了解更多
* [在Docker Compose上部署Minio](https://docs.minio.io/cn/deploy-minio-on-docker-compose)
* [在Docker Swarm上部署Minio](https://docs.minio.io/cn/deploy-minio-on-docker-swarm)
* [分布式Minio快速入门](https://docs.minio.io/cn/distributed-minio-quickstart-guide)
* [Minio纠删码模式快速入门](https://docs.minio.io/cn/minio-erasure-code-quickstart-guide)
* [在Docker Compose上部署MinIO](https://docs.min.io/cn/deploy-minio-on-docker-compose)
* [在Docker Swarm上部署MinIO](https://docs.min.io/cn/deploy-minio-on-docker-swarm)
* [分布式MinIO快速入门](https://docs.min.io/cn/distributed-minio-quickstart-guide)
* [MinIO纠删码模式快速入门](https://docs.min.io/cn/minio-erasure-code-quickstart-guide)

6
docs/zh_CN/erasure/README.md
View File

@@ -1,4 +1,4 @@
# Minio纠删码快速入门 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
# Minio纠删码快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
Minio使用纠删码`erasure code`和校验和`checksum`来保护数据免受硬件故障和无声数据损坏。 即便您丢失一半数量（N/2）的硬盘，您仍然可以恢复数据。
@@ -14,13 +14,13 @@ Minio使用纠删码`erasure code`和校验和`checksum`来保护数据免受硬
## 什么是位衰减`bit rot`保护?
位衰减又被称为数据腐化`Data Rot`、无声数据损坏`Silent Data Corruption`,是目前硬盘数据的一种严重数据丢失问题。硬盘上的数据可能会神不知鬼不觉就损坏了，也没有什么错误日志。正所谓明枪易躲，暗箭难防，这种背地里犯的错比硬盘直接咔咔宕了还危险。 不过不用怕，Minio纠删码采用了高速[BLAKE2](https://blog.minio.io/accelerating-blake2b-by-4x-using-simd-in-go-assembly-33ef16c8a56b#.jrp1fdwer) 基于哈希的校验和来防范位衰减。
位衰减又被称为数据腐化`Data Rot`、无声数据损坏`Silent Data Corruption`,是目前硬盘数据的一种严重数据丢失问题。硬盘上的数据可能会神不知鬼不觉就损坏了，也没有什么错误日志。正所谓明枪易躲，暗箭难防，这种背地里犯的错比硬盘直接咔咔宕了还危险。 不过不用怕，Minio纠删码采用了高速[BLAKE2](https://blog.min.io/accelerating-blake2b-by-4x-using-simd-in-go-assembly-33ef16c8a56b#.jrp1fdwer) 基于哈希的校验和来防范位衰减。
## Minio纠删码快速入门
### 1. 前提条件:
安装Minio- [Minio快速入门](https://docs.minio.io/cn/minio-quickstart-guide)
安装Minio- [Minio快速入门](https://docs.min.io/cn/minio-quickstart-guide)
### 2. 以纠删码模式运行Minio

6
docs/zh_CN/gateway/README.md
View File

@@ -1,9 +1,9 @@
# Minio 网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio网关将Amazon S3兼容性添加到第三方云存储提供者。
# MinIO 网关 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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
* MinIO & AWS S3
* Edge Caching - 基于磁盘的代理缓存

2
docs/zh_CN/gateway/azure-limitations.md
View File

@@ -1,4 +1,4 @@
## Minio Azure网关限制
## MinIO Azure网关限制
网关继承了下列Azure限制:

18
docs/zh_CN/gateway/azure.md
View File

@@ -1,8 +1,8 @@
# Minio Azure 网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio网关将亚马逊S3兼容性添加到微软Azure Blob存储。
# MinIO Azure 网关 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
MinIO网关将亚马逊S3兼容性添加到微软Azure Blob存储。
## 运行支持微软Azure Blob存储的Minio网关
## 运行支持微软Azure Blob存储的MinIO网关
### 使用Docker
```
docker run -p 9000:9000 --name azure-s3 \
@@ -17,11 +17,11 @@ export MINIO_ACCESS_KEY=azureaccountname
export MINIO_SECRET_KEY=azureaccountkey
minio gateway azure
```
## 使用Minio浏览器验证
Minio Gateway配有嵌入式网络对象浏览器。 将您的Web浏览器指向http://127.0.0.1:9000确保您的服务器已成功启动。
## 使用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`验证
## 使用MinIO客户端 `mc`验证
`mc` 提供了诸如ls，cat，cp，mirror，diff等UNIX命令的替代方案。它支持文件系统和Amazon S3兼容的云存储服务。
### 配置 `mc`
@@ -38,6 +38,6 @@ mc ls myazure
```
## 了解更多
- [`mc` 命令行接口](https://docs.minio.io/cn/minio-client-quickstart-guide)
- [`aws` 命令行接口](https://docs.minio.io/cn/aws-cli-with-minio)
- [`minio-go` Go SDK](https://docs.minio.io/cn/golang-client-quickstart-guide)
- [`mc` 命令行接口](https://docs.min.io/cn/minio-client-quickstart-guide)
- [`aws` 命令行接口](https://docs.min.io/cn/aws-cli-with-minio)
- [`minio-go` Go SDK](https://docs.min.io/cn/golang-client-quickstart-guide)

2
docs/zh_CN/gateway/gcs-limitations.md
View File

@@ -1,4 +1,4 @@
## Minio GCS 网关限制
## MinIO GCS 网关限制
网关继承了以下GCS限制:

18
docs/zh_CN/gateway/gcs.md
View File

@@ -1,7 +1,7 @@
# Minio GCS 网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio GCS网关将亚马逊S3兼容性添加到Google云存储。
# MinIO GCS 网关 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
MinIO GCS网关将亚马逊S3兼容性添加到Google云存储。
## 运行支持GCS的Minio 网关
## 运行支持GCS的MinIO 网关
### 为GCS创建服务帐户密钥，并获取凭据文件
1. 访问 [API控制台凭证页面](https://console.developers.google.com/project/_/apis/credentials).
2. 选择您的项目或创建一个新项目， 记下你的项目ID。
@@ -31,12 +31,12 @@ export MINIO_SECRET_KEY=miniosecretkey
minio gateway gcs yourprojectid
```
## 使用Minio Browser验证
Minio Gateway配有嵌入式网络对象浏览器。 将您的Web浏览器指向http://127.0.0.1:9000确保您的服务器已成功启动。
## 使用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`验证
## 使用MinIO客户端 `mc`验证
`mc` 提供了诸如ls，cat，cp，mirror，diff等UNIX命令的替代方案。它支持文件系统和Amazon S3兼容的云存储服务。
### 配置 `mc`
@@ -53,7 +53,7 @@ mc ls mygcs
```
## 了解更多
- [`mc` 命令行接口](https://docs.minio.io/cn/minio-client-quickstart-guide)
- [`aws` 命令行接口](https://docs.minio.io/cn/aws-cli-with-minio)
- [`minio-go` Go SDK](https://docs.minio.io/cn/golang-client-quickstart-guide)
- [`mc` 命令行接口](https://docs.min.io/cn/minio-client-quickstart-guide)
- [`aws` 命令行接口](https://docs.min.io/cn/aws-cli-with-minio)
- [`minio-go` Go SDK](https://docs.min.io/cn/golang-client-quickstart-guide)

12
docs/zh_CN/gateway/nas.md
View File

@@ -1,7 +1,7 @@
# Minio NAS网关 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
Minio网关使用NAS存储支持Amazon S3。你可以在同一个共享NAS卷上运行多个minio实例，作为一个分布式的对象网关。
# MinIO NAS网关 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
MinIO网关使用NAS存储支持Amazon S3。你可以在同一个共享NAS卷上运行多个minio实例，作为一个分布式的对象网关。
## 为NAS存储运行Minio网关
## 为NAS存储运行MinIO网关
### 使用Docker
```
docker run -p 9000:9000 --name nas-s3 \
@@ -38,6 +38,6 @@ mc ls mynas
```
## 了解更多
- [`mc`快速入门](https://docs.minio.io/docs/minio-client-quickstart-guide)
- [使用 aws-cli](https://docs.minio.io/docs/aws-cli-with-minio)
- [使用 minio-go SDK](https://docs.minio.io/docs/golang-client-quickstart-guide)
- [`mc`快速入门](https://docs.min.io/docs/minio-client-quickstart-guide)
- [使用 aws-cli](https://docs.min.io/docs/aws-cli-with-minio)
- [使用 minio-go SDK](https://docs.min.io/docs/golang-client-quickstart-guide)

16
docs/zh_CN/large-bucket/README.md
View File

@@ -1,4 +1,4 @@
# 超大存储桶快速入门 [![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)
# 超大存储桶快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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的纠删码功能限制了最多只能使用16块磁盘。这就限制了一个租户的数据可以用多少存储空间。不过，为了满足需要大量磁盘或者是超大容量存储空间的需求，我们引入了超大存储桶的支持。
@@ -8,7 +8,7 @@ Minio的纠删码功能限制了最多只能使用16块磁盘。这就限制了
安装和部署方式和分布式Minio一样。只不过是在输入参数的语法上，用`...`来做为磁盘参数的简写。分布式设置中的远程磁盘被编码为HTTP（s）URI，它也可以被同样的缩写。
### 1. 前提条件
安装Minio - [Minio快速入门](https://docs.minio.io/docs/minio-quickstart-guide)。
安装Minio - [Minio快速入门](https://docs.min.io/docs/minio-quickstart-guide)。
### 2. 在多个磁盘上运行Minio
我们将在下面的章节中看到如何做到这一点的例子。
@@ -37,11 +37,11 @@ minio server http://host{1...4}/export{1...16}
```
### 3. 验证设置是否成功
要验证是否部署成功，你可以通过浏览器或者[`mc`](https://docs.minio.io/docs/minio-client-quickstart-guide)来访问刚刚部署的Minio服务。你应该可以看到上传的文件在所有Minio节点上都可以访问。
要验证是否部署成功，你可以通过浏览器或者[`mc`](https://docs.min.io/docs/minio-client-quickstart-guide)来访问刚刚部署的Minio服务。你应该可以看到上传的文件在所有Minio节点上都可以访问。
## 了解更多
- [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)
- [mc快速入门](https://docs.min.io/docs/minio-client-quickstart-guide)
- [使用 aws-cli](https://docs.min.io/docs/aws-cli-with-minio)
- [使用 s3cmd](https://docs.min.io/docs/s3cmd-with-minio)
- [使用 minio-go SDK](https://docs.min.io/docs/golang-client-quickstart-guide)
- [Minio文档](https://docs.min.io)

8
docs/zh_CN/minio-limits.md
View File

@@ -35,17 +35,17 @@
### Minio不支持的Amazon S3 Bucket API
- BucketACL (可以用 [bucket policies](https://docs.minio.io/docs/minio-client-complete-guide#policy))
- BucketACL (可以用 [bucket policies](https://docs.min.io/docs/minio-client-complete-guide#policy))
- BucketCORS (所有HTTP方法的所有存储桶都默认启用CORS)
- BucketLifecycle (Minio纠删码不需要)
- BucketReplication (可以用 [`mc mirror`](https://docs.minio.io/docs/minio-client-complete-guide#mirror))
- BucketReplication (可以用 [`mc mirror`](https://docs.min.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](https://docs.minio.io/docs/minio-client-complete-guide#events) APIs)
- BucketAnalytics, BucketMetrics, BucketLogging (可以用 [bucket notification](https://docs.min.io/docs/minio-client-complete-guide#events) APIs)
- BucketRequestPayment
- BucketTagging
### Minio不支持的Amazon S3 Object API.
- ObjectACL (可以用 [bucket policies](https://docs.minio.io/docs/minio-client-complete-guide#policy))
- ObjectACL (可以用 [bucket policies](https://docs.min.io/docs/minio-client-complete-guide#policy))
- ObjectTorrent

4
docs/zh_CN/multi-tenancy/README.md
View File

@@ -1,4 +1,4 @@
# 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多租户（Multi-tenant）部署指南 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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)
## 单机部署
@@ -49,6 +49,6 @@ minio --config-dir ~/tenant3 server --address :9003 http://192.168.10.11/data/te
![示例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/cn/minio-deployment-quickstart-guide) ,学习如何在编排平台中使用Minio。
对于大型多租户Minio部署，我们建议使用一个流行的容器编排平台，比如Kubernetes、DC/OS，或者是Docker Swarm.参考 [这个文档](https://docs.min.io/cn/minio-deployment-quickstart-guide) ,学习如何在编排平台中使用Minio。

10
docs/zh_CN/orchestration/README.md
View File

@@ -1,13 +1,13 @@
# 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部署快速入门 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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的扩展提供了非常好的支撑。以下是各种编排平台的Minio部署文档:
| Orchestration平台|
|:---|
| [`Docker Swarm`](https://docs.minio.io/cn/deploy-minio-on-docker-swarm) |
| [`Docker Compose`](https://docs.minio.io/cn/deploy-minio-on-docker-compose) |
| [`Kubernetes`](https://docs.minio.io/cn/deploy-minio-on-kubernetes) |
| [`DC/OS`](https://docs.minio.io/cn/deploy-minio-on-dc-os) |
| [`Docker Swarm`](https://docs.min.io/cn/deploy-minio-on-docker-swarm) |
| [`Docker Compose`](https://docs.min.io/cn/deploy-minio-on-docker-compose) |
| [`Kubernetes`](https://docs.min.io/cn/deploy-minio-on-kubernetes) |
| [`DC/OS`](https://docs.min.io/cn/deploy-minio-on-dc-os) |
## 为什么说Minio是云原生的（cloud-native）?
云原生这个词代表的是一些思想的集合，比如微服务部署，可伸缩，而不是说把一个单体应用改造成容器部署。一个云原生的应用在设计时就考虑了移植性和可伸缩性，而且可以通过简单的复制即可实现水平扩展。现在兴起的编排平台，像Swarm、Kubernetes以及DC/OS，让大规模集群的复制和管理变得前所未有的简单，哪里不会点哪里。

20
docs/zh_CN/orchestration/dcos/README.md
View File

@@ -1,6 +1,6 @@
# 在 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 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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).
要在DC/OS上部署MinIO，可以使用我们的 [official universe package](https://github.com/mesosphere/universe/tree/version-3.x/repo/packages/M/minio/6).
## 1. 前提条件
@@ -9,18 +9,18 @@
- 识别Marathon-LB或者一个指向Marathon-LB的public agent(s)的可用主机名的 [IP of the public agent](https://dcos.io/docs/1.9/administration/locate-public-agent/) 。
## 2. 设置Minio
## 2. 设置MinIO
你可以使用DC/OS GUI或者CLI安装Minio Universe package。
你可以使用DC/OS GUI或者CLI安装MinIO Universe package。
### 使用DC/OS GUI安装Minio
- 访问DC/OS admin页面，然后点击左边栏的Universe,然后点击Packages页签，搜索Minio,点击左边栏的```Install```按钮。
### 使用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。
- 点击按钮`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
### 使用DC/OS CLI安装MinIO
使用命令行安装, 输入
@@ -28,7 +28,7 @@
$ dcos package install minio
```
## 3. 卸载Minio
## 3. 卸载MinIO
你确定要这么做吗，如果你真要这么做，我们也不会像国内的软件那么无赖。如需卸载，请输入
@@ -38,7 +38,7 @@ $ dcos package uninstall minio
### 了解更多
- [Minio Erasure Code QuickStart Guide](https://docs.minio.io/cn/minio-erasure-code-quickstart-guide)
- [MinIO Erasure Code QuickStart Guide](https://docs.min.io/cn/minio-erasure-code-quickstart-guide)
- [DC/OS Project](https://docs.mesosphere.com/)

22
docs/zh_CN/orchestration/docker-compose/README.md
View File

@@ -1,17 +1,17 @@
# 使用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部署MinIO [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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的开发，测试和分期环境的好方法。
使用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
## 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。然后运行下面的命令
在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
@@ -31,19 +31,19 @@ docker-compose.exe up
### 注意事项
* 默认情况下Docker Compose file使用的是最新版的Minio server的Docker镜像，你可以修改image tag来拉取指定版本的[Minio Docker image](https://hub.docker.com/r/minio/minio/).
* 默认情况下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。添加一个服务
* 默认情况下会创建4个minio实例，你可以添加更多的MinIO服务（最多总共16个）到你的MinIO Comose deployment。添加一个服务
* 复制服务定义并适当地更改新服务的名称。
* 更新每个服务中的命令部分。
* 更新要为新服务公开的端口号。 另外，请确保分配给新服务的端口尚未使用。
关于分布式Minio的更多资料，请访问[这里](https://docs.minio.io/cn/distributed-minio-quickstart-guide).
关于分布式MinIO的更多资料，请访问[这里](https://docs.min.io/cn/distributed-minio-quickstart-guide).
* Docker compose file中的Minio服务使用的端口是9001到9004，这允许多个服务在主机上运行。
* Docker compose file中的MinIO服务使用的端口是9001到9004，这允许多个服务在主机上运行。
### 了解更多
- [Docker Compose概述](https://docs.docker.com/compose/overview/)
- [Minio Docker快速入门](https://docs.minio.io/cn/minio-docker-quickstart-guide)
- [使用Docker Swarm部署Minio](https://docs.minio.io/cn/deploy-minio-on-docker-swarm)
- [Minio纠删码快速入门](https://docs.minio.io/cn/minio-erasure-code-quickstart-guide)
- [MinIO Docker快速入门](https://docs.min.io/cn/minio-docker-quickstart-guide)
- [使用Docker Swarm部署MinIO](https://docs.min.io/cn/deploy-minio-on-docker-swarm)
- [MinIO纠删码快速入门](https://docs.min.io/cn/minio-erasure-code-quickstart-guide)

32
docs/zh_CN/orchestration/docker-swarm/README.md
View File

@@ -1,8 +1,8 @@
# 使用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 Swarm部署MinIO [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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在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设置。
从[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. 前提条件
@@ -25,7 +25,7 @@ docker swarm join \
你现在可以运行上述命令[添加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
## 3. 为MinIO创建Docker secret
```shell
echo "AKIAIOSFODNN7EXAMPLE" | docker secret create access_key -
@@ -42,16 +42,16 @@ 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/cn/minio-client-complete-guide) `mc` 或者浏览器访问http://[Node_Public_IP_Address]:[Expose_Port_on_Host]来访问你的Minio server。
在stack成功部署之后，你可以通过[MinIO Client](https://docs.min.io/cn/minio-client-complete-guide) `mc` 或者浏览器访问http://[Node_Public_IP_Address]:[Expose_Port_on_Host]来访问你的MinIO server。
## 4. 删除分布式Minio services
## 4. 删除分布式MinIO services
删除分布式Minio services以及相关的网络，请运行下面的命令
删除分布式MinIO services以及相关的网络，请运行下面的命令
```shell
docker stack rm minio_stack
```
Swarm不会自动删除为Minio服务创建的host volumes,如果下次新的Minio服务不熟到swarm上，可能会导致损坏。因此，我们建议手动删除所有Minio使用的volumes。为此，到每一个swarm的节点上，列出所有的volumes
Swarm不会自动删除为MinIO服务创建的host volumes,如果下次新的MinIO服务不熟到swarm上，可能会导致损坏。因此，我们建议手动删除所有MinIO使用的volumes。为此，到每一个swarm的节点上，列出所有的volumes
```shell
docker volume ls
@@ -64,23 +64,23 @@ docker volume rm volume_name
### 注意事项
* 默认情况下Docker Compose file使用的是最新版的Minio server的Docker镜像，你可以修改image tag来拉取指定版本的[Minio Docker image](https://hub.docker.com/r/minio/minio/).
* 默认情况下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。添加一个服务
* 默认情况下会创建4个minio实例，你可以添加更多的MinIO服务（最多总共16个）到你的MinIO Comose deployment。添加一个服务
* 复制服务定义并适当地更改新服务的名称。
* 更新每个服务中的命令部分。
* 更新要为新服务公开的端口号。 另外，请确保分配给新服务的端口尚未使用。
关于分布式Minio的更多资料，请访问[这里](https://docs.minio.io/cn/distributed-minio-quickstart-guide).
关于分布式MinIO的更多资料，请访问[这里](https://docs.min.io/cn/distributed-minio-quickstart-guide).
* 默认情况下，Minio服务使用的是`local` volume driver. 更多配置选项，请访问[Docker documentation](https://docs.docker.com/compose/compose-file/#/volume-configuration-reference) 。
* 默认情况下，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 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/cn/minio-docker-quickstart-guide)
- [使用Docker Compose部署Minio](https://docs.minio.io/cn/deploy-minio-on-docker-compose)
- [Minio纠删码快速入门](https://docs.minio.io/cn/minio-erasure-code-quickstart-guide)
- [MinIO Docker快速入门](https://docs.min.io/cn/minio-docker-quickstart-guide)
- [使用Docker Compose部署MinIO](https://docs.min.io/cn/deploy-minio-on-docker-compose)
- [MinIO纠删码快速入门](https://docs.min.io/cn/minio-erasure-code-quickstart-guide)

102
docs/zh_CN/orchestration/kubernetes-yaml/README.md
View File

@@ -1,38 +1,38 @@
# 使用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的云原生部署 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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的部署)
- [MinIO独立模式部署](#MinIO-Standalone模式部署)
- [MinIO独立模式快速入门](#MinIO独立模式快速入门)
- [创建持久卷声明](#MinIO独立模式快速入门)
- [创建MinIO的部署](#创建MinIO的部署)
- [创建Miniio服务](#创建Miniio服务)
- [更新已有的Minio部署](#更新已有的Minio部署)
- [更新已有的MinIO部署](#更新已有的MinIO部署)
- [独立模式资源清理](#独立模式资源清理)
- [Minio分布式服务部署](#Minio分布式服务部署)
- [MinIO分布式服务部署](#MinIO分布式服务部署)
- [分布式快速入门](#分布式快速入门)
- [创建Minio Headless服务](#创建Minio-Headless服务)
- [创建Minio Statefulset](#创建Minio-Statefulset)
- [创建MinIO Headless服务](#创建MinIO-Headless服务)
- [创建MinIO Statefulset](#创建MinIO-Statefulset)
- [创建负载均衡服务](#创建负载均衡服务)
- [更新已存在的Minio StatefulSet](#更新已存在的Minio-StatefulSet)
- [更新已存在的MinIO StatefulSet](#更新已存在的MinIO-StatefulSet)
- [分布式模式资源清理](#分布式模式资源清理)
- [Minio GCS 网关部署](#Minio-GCS网关部署)
- [MinIO GCS 网关部署](#MinIO-GCS网关部署)
- [GCS 网关快速入门](#GCS-网关快速入门)
- [创建GCS凭据](#创建GCS凭据)
- [创建Minio GCS Gateway部署](#创建Minio-GCS-Gateway部署)
- [创建Minio LoadBalancer服务](#创建Minio-LoadBalancer服务)
- [更新现有的Minio GCS部署](#更新现有的Minio-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模式部署
## MinIO Standalone模式部署
以下部分描述了如何在Kubernetes上部署一个独立的 [Minio](https://minio.io/) 服务。部署使用的是Docker Hub上的 [官方Minio Docker image](https://hub.docker.com/r/minio/minio/~/dockerfile/) 。
以下部分描述了如何在Kubernetes上部署一个独立的 [MinIO](https://min.io/) 服务。部署使用的是Docker Hub上的 [官方MinIO Docker image](https://hub.docker.com/r/minio/minio/~/dockerfile/) 。
此部分使用了以下Kubernetes的核心组件:
@@ -41,7 +41,7 @@
- [_Deployments_](https://kubernetes.io/docs/user-guide/deployments/)
- [_Persistent Volume Claims_](https://kubernetes.io/docs/user-guide/persistent-volumes/#persistentvolumeclaims)
### Minio独立模式快速入门
### MinIO独立模式快速入门
运行下面的命令快速启动
@@ -53,8 +53,8 @@ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/
### 创建持久卷声明
Minio需要持久卷来存储对象。如果没有持久卷，Minio实例中的数据将会存到容器的文件系统中，而且在容器重启时会被清除的干干净净。
创建一个持久卷声明（PVC），为Minio实例请求存储。Kubernetes寻找与群集中的PVC请求匹配的PV，并自动将其绑定到PVC。
MinIO需要持久卷来存储对象。如果没有持久卷，MinIO实例中的数据将会存到容器的文件系统中，而且在容器重启时会被清除的干干净净。
创建一个持久卷声明（PVC），为MinIO实例请求存储。Kubernetes寻找与群集中的PVC请求匹配的PV，并自动将其绑定到PVC。
这是一个PVC的描述
@@ -85,9 +85,9 @@ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/
persistentvolumeclaim "minio-pv-claim" created
```
### 创建Minio的部署
### 创建MinIO的部署
部署封装了副本集和pod - 因此，如果pod掉线，复制控制器会确保另一个pod自动出现。 这样，您就不必担心pod失败，并且可以提供稳定的Minio服务。
部署封装了副本集和pod - 因此，如果pod掉线，复制控制器会确保另一个pod自动出现。 这样，您就不必担心pod失败，并且可以提供稳定的MinIO服务。
这是一个部署的描述
@@ -114,13 +114,13 @@ spec:
claimName: minio-pv-claim
containers:
- name: minio
# Pulls the default Minio image from Docker Hub
# 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
# MinIO access key and secret key
- name: MINIO_ACCESS_KEY
value: "minio"
- name: MINIO_SECRET_KEY
@@ -142,9 +142,9 @@ deployment "minio-deployment" created
### 创建Miniio服务
现在您正在运行Minio部署，您可能希望在内部（集群内）访问它，或者将其作为服务暴露在外部（集群外部，也可能是公共Internet）IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
现在您正在运行MinIO部署，您可能希望在内部（集群内）访问它，或者将其作为服务暴露在外部（集群外部，也可能是公共Internet）IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
在此示例中，我们通过创建LoadBalancer服务来公开Minio部署。
在此示例中，我们通过创建LoadBalancer服务来公开MinIO部署。
这是服务描述。
```sh
@@ -161,7 +161,7 @@ spec:
selector:
app: minio
```
创建Minio服务
创建MinIO服务
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-service.yaml?raw=true
@@ -176,9 +176,9 @@ 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部署以使用较新的Minio版本。 为此，请使用`kubectl set image`命令：
您可以更新现有的MinIO部署以使用较新的MinIO版本。 为此，请使用`kubectl set image`命令：
```sh
kubectl set image deployment/minio-deployment minio=<replace-with-new-minio-image>
@@ -200,9 +200,9 @@ kubectl delete deployment minio-deployment \
&& kubectl delete svc minio-service
```
## Minio分布式服务部署
## MinIO分布式服务部署
以下文档介绍了在Kubernetes上部署[分布式Minio](https://docs.minio.io/cn/distributed-minio-quickstart-guide)服务器的过程。 本示例使用Docker Hub的[官方Minio Docker镜像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
以下文档介绍了在Kubernetes上部署[分布式MinIO](https://docs.min.io/cn/distributed-minio-quickstart-guide)服务器的过程。 本示例使用Docker Hub的[官方MinIO Docker镜像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
此示例使用以下Kubernetes的核心组件：
@@ -220,7 +220,7 @@ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-service.yaml?raw=true
```
###创建Minio Headless服务
###创建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。
@@ -249,9 +249,9 @@ $ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestratio
service "minio" created
```
###创建Minio Statefulset
###创建MinIO Statefulset
StatefulSet为每个pod提供确定性名称和唯一身份，从而轻松部署有状态的分布式应用程序。 要启动分布式Minio，您需要将驱动器位置作为参数传递到minio服务的命令。 然后，您需要在所有参与的pod上运行相同的命令。 StatefulSets提供了一个完美的方式来处理这个要求。
StatefulSet为每个pod提供确定性名称和唯一身份，从而轻松部署有状态的分布式应用程序。 要启动分布式MinIO，您需要将驱动器位置作为参数传递到minio服务的命令。 然后，您需要在所有参与的pod上运行相同的命令。 StatefulSets提供了一个完美的方式来处理这个要求。
这是Statefulset的描述。
@@ -315,9 +315,9 @@ statefulset "minio" created
### 创建负载均衡服务
现在您已经运行了Minio statefulset，您可能希望在内部（集群内）访问它，或将其作为服务暴露在外部（集群外，也可能是公用Internet）的IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
现在您已经运行了MinIO statefulset，您可能希望在内部（集群内）访问它，或将其作为服务暴露在外部（集群外，也可能是公用Internet）的IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
在此示例中，我们通过创建LoadBalancer服务来公开Minio部署。
在此示例中，我们通过创建LoadBalancer服务来公开MinIO部署。
这是服务描述。
```sh
@@ -334,7 +334,7 @@ spec:
selector:
app: minio
```
创建Minio service
创建MinIO service
```sh
$ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-service.yaml?raw=true
@@ -349,8 +349,8 @@ 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`命令：
###更新已经存在的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>"}]'
@@ -377,9 +377,9 @@ kubectl delete statefulset minio \
&& kubectl delete svc minio-service
```
## Minio GCS网关部署
## MinIO GCS网关部署
以下部分介绍在Kubernetes上部署[Minio](https://minio.io/)GCS Gateway的过程。 部署使用Docker Hub的[官方Minio Docker映像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
以下部分介绍在Kubernetes上部署[MinIO](https://min.io/)GCS Gateway的过程。 部署使用Docker Hub的[官方MinIO Docker映像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
此示例使用以下Kubernetes的核心组件：
@@ -422,11 +422,11 @@ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/
kubectl create secret generic gcs-credentials --from-file=/path/to/gcloud/credentials/application_default_credentials.json
```
### 创建Minio GCS Gateway部署
### 创建MinIO GCS Gateway部署
部署封装了副本集和pod - 因此，如果pod掉线，复制控制器会确保另一个pod自动出现。 这样，您就不必担心pod失败，并且可以提供稳定的Minio服务。
部署封装了副本集和pod - 因此，如果pod掉线，复制控制器会确保另一个pod自动出现。 这样，您就不必担心pod失败，并且可以提供稳定的MinIO服务。
Minio Gateway使用GCS作为其存储后端，需要使用GCP“projectid”来识别您的凭据。 使用GCS项目ID更新“gcp_project_id”部分。 这是部署描述。
MinIO Gateway使用GCS作为其存储后端，需要使用GCP“projectid”来识别您的凭据。 使用GCS项目ID更新“gcp_project_id”部分。 这是部署描述。
```sh
apiVersion: extensions/v1beta1
@@ -451,14 +451,14 @@ spec:
secretName: gcs-credentials
containers:
- name: minio
# Pulls the default Minio image from Docker Hub
# 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
# MinIO access key and secret key
- name: MINIO_ACCESS_KEY
value: "minio"
- name: MINIO_SECRET_KEY
@@ -482,11 +482,11 @@ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/
deployment "minio-deployment" created
```
### 创建Minio LoadBalancer服务
### 创建MinIO LoadBalancer服务
现在您正在运行Minio，您可能希望在内部（集群内）访问它，或者将其作为服务暴露在外部（集群外部，也可能是公共Internet）IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
现在您正在运行MinIO，您可能希望在内部（集群内）访问它，或者将其作为服务暴露在外部（集群外部，也可能是公共Internet）IP地址，具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP，它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
在此示例中，我们通过创建LoadBalancer服务来暴露Minio。 这是服务描述。
在此示例中，我们通过创建LoadBalancer服务来暴露MinIO。 这是服务描述。
```sh
apiVersion: v1
@@ -502,7 +502,7 @@ spec:
selector:
app: minio
```
创建Minio服务
创建MinIO服务
```sh
kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-service.yaml?raw=true
@@ -517,9 +517,9 @@ 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 GCS部署
您可以更新现有的Minio部署以使用较新的Minio版本。 为此，请使用`kubectl set image`命令：
您可以更新现有的MinIO部署以使用较新的MinIO版本。 为此，请使用`kubectl set image`命令：
```sh
kubectl set image deployment/minio-deployment minio=<replace-with-new-minio-image>

48
docs/zh_CN/orchestration/kubernetes/README.md
View File

@@ -1,10 +1,10 @@
# 使用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 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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有多种选择，您可以选择最适合您的。
Kubernetes的部署和状态集提供了在独立，分布式或共享模式下部署MinIO服务器的完美平台。 在Kubernetes上部署MinIO有多种选择，您可以选择最适合您的。
- Minio [Helm](https://helm.sh) Chart通过一个简单的命令即可提供自定义而且简单的Minio部署。更多关于Minio Helm部署的资料，请访问[这里](#prerequisites).
- MinIO [Helm](https://helm.sh) Chart通过一个简单的命令即可提供自定义而且简单的MinIO部署。更多关于MinIO Helm部署的资料，请访问[这里](#prerequisites).
- 你也可以浏览Kubernetes [Minio示例](https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes/README.md) ，通过`.yaml`文件来部署Minio。
- 你也可以浏览Kubernetes [MinIO示例](https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes/README.md) ，通过`.yaml`文件来部署MinIO。
<a name="prerequisites"></a>
## 1. 前提条件
@@ -14,23 +14,23 @@ Kubernetes的部署和状态集提供了在独立，分布式或共享模式下
* 底层支持PV provisioner。
* 你的K8s集群里需要有Helm package manager [installed](https://github.com/kubernetes/helm#install)。
## 2. 使用Helm Chart部署Minio
## 2. 使用Helm Chart部署MinIO
安装 Minio chart
安装 MinIO chart
```bash
$ helm install stable/minio
```
以上命令以默认配置在Kubernetes群集上部署Minio。 以下部分列出了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`|
| `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` |
| `mode` | MinIO server模式 (`standalone`, `shared` 或者 `distributed`)| `standalone` |
| `numberOfNodes` | 节点数 (仅对分布式模式生效). 可选值 4 <= x <= 16 | `4` |
| `accessKey` | 默认access key | `AKIAIOSFODNN7EXAMPLE` |
| `secretKey` | 默认secret key | `wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY` |
@@ -52,7 +52,7 @@ $ helm install --name my-release \
stable/minio
```
上述命令部署了一个带上100G持久卷的Minio服务。
上述命令部署了一个带上100G持久卷的MinIO服务。
或者，您可以提供一个YAML文件，用于在安装chart时指定参数值。 例如，
@@ -60,43 +60,43 @@ $ helm install --name my-release \
$ helm install --name my-release -f values.yaml stable/minio
```
### 分布式Minio
### 分布式MinIO
默认情况下，此图表以独立模式提供Minio服务器。 要在[分布式模式](https://docs.minio.io/cn/distributed-minio-quickstart-guide)中配置Minio服务器，请将`mode`字段设置为`distributed`,
默认情况下，此图表以独立模式提供MinIO服务器。 要在[分布式模式](https://docs.min.io/cn/distributed-minio-quickstart-guide)中配置MinIO服务器，请将`mode`字段设置为`distributed`,
```bash
$ helm install --set mode=distributed stable/minio
```
上述命令部署了个带有4个节点的分布式Minio服务器。 要更改分布式Minio服务器中的节点数，请设置`numberOfNodes`属性。
上述命令部署了个带有4个节点的分布式MinIO服务器。 要更改分布式MinIO服务器中的节点数，请设置`numberOfNodes`属性。
```bash
$ helm install --set mode=distributed,numberOfNodes=8 stable/minio
```
上述命令部署了个带有8个节点的分布式Minio服务器。注意一下，`numberOfNodes`取值范围是[4,16]。
上述命令部署了个带有8个节点的分布式MinIO服务器。注意一下，`numberOfNodes`取值范围是[4,16]。
#### StatefulSet [限制](http://kubernetes.io/docs/concepts/abstractions/controllers/statefulsets/#limitations)，适用于分布式Minio
#### StatefulSet [限制](http://kubernetes.io/docs/concepts/abstractions/controllers/statefulsets/#limitations)，适用于分布式MinIO
* StatefulSets需要持久化存储，所以如果 `mode`设成 `distributed`的话，`persistence.enabled`参数不生效。
* 卸载分布式Minio版本时，需要手动删除与StatefulSet关联的卷。
* 卸载分布式MinIO版本时，需要手动删除与StatefulSet关联的卷。
### Shared Minio
### Shared MinIO
如需采用[shared mode](https://github.com/minio/minio/blob/master/docs/shared-backend/README.md)部署Minio, 将`mode` 设为`shared`,
如需采用[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`字段，
上述命令规定了4个MinIO服务器节点，一个存储。 要更改共享的MinIO部署中的节点数，请设置`numberOfNodes`字段，
```bash
$ helm install --set mode=shared,numberOfNodes=8 stable/minio
```
上述命令规定了Minio服务有8个节点，采用shared模式。
上述命令规定了MinIO服务有8个节点，采用shared模式。
### 持久化
@@ -108,9 +108,9 @@ $ helm install --set persistence.enabled=false stable/minio
> *"当Pod分配给节点时，首先创建一个emptyDir卷，只要该节点上的Pod正在运行，它就会存在。 当某个Pod由于任何原因从节点中删除时，emptyDir中的数据将永久删除。"*
## 3. 使用Helm更新Minio版本
## 3. 使用Helm更新MinIO版本
您可以更新现有的Minio Helm Release以使用较新的Minio Docker镜像。 为此，请使用`helm upgrade`命令：
您可以更新现有的MinIO Helm Release以使用较新的MinIO Docker镜像。 为此，请使用`helm upgrade`命令：
```bash
$ helm upgrade --set imageTag=<replace-with-minio-docker-image-tag> <helm-release-name> stable/minio
@@ -149,6 +149,6 @@ $ helm install --set accessKey=myaccesskey,secretKey=mysecretkey \
### 了解更多
- [Minio纠删码快速入门](https://docs.minio.io/cn/minio-erasure-code-quickstart-guide)
- [MinIO纠删码快速入门](https://docs.min.io/cn/minio-erasure-code-quickstart-guide)
- [Kubernetes文档](https://kubernetes.io/docs/home/)
- [Helm package manager for kubernetes](https://helm.sh/)

2
docs/zh_CN/shared-backend/DESIGN.md
View File

@@ -1,4 +1,4 @@
介绍 [![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
介绍 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
------------
该特性可以让多个Minio实例使用一个共享的NAS存储，而且不需要做什么特殊的设置。文件默认已经做了同步以及加锁。

42
docs/zh_CN/shared-backend/README.md
View File

@@ -1,36 +1,36 @@
# 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共享后端存储快速入门[![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.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共享模式可以让你使用一个[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共享模式
MinIO共享模式是为了解决在真实场景中存在的一些问题，而且不需要做额外的配置。
如果你有下列需求，则可以考虑MinIO共享模式
- 你已经买了NAS设备，并想在存储层使用Minio来增加S3兼容。
- 你已经买了NAS设备，并想在存储层使用MinIO来增加S3兼容。
- 你的应用架构要求你使用带有S3接口的NAS。
- 你的应用存在亚历山大的流量，你想给你的NAS设备增加一个有负载均衡能力的S3兼容的服务。
在多个共享模式的Minio服务前面加一层代理，你很容易就能获得一个高可用，负载均衡，AWS S3兼容的存储系统。
在多个共享模式的MinIO服务前面加一层代理，你很容易就能获得一个高可用，负载均衡，AWS S3兼容的存储系统。
# 开始
如果你知道怎么部署单机Minio,共享模式的部署和运行也是一样一样的。
如果你知道怎么部署单机MinIO,共享模式的部署和运行也是一样一样的。
## 1. 前提条件
安装Minio - [Minio快速入门](https://docs.minio.io/cn/).
安装MinIO - [MinIO快速入门](https://docs.min.io/cn/).
## 2. 在共享后端存储上运行Minio
## 2. 在共享后端存储上运行MinIO
为了让Minio在共享后端上运行起来，你需要启动多个Minio服务，这些服务指向同一个后端存储。下面我们就来讲解如何设置。
为了让MinIO在共享后端上运行起来，你需要启动多个MinIO服务，这些服务指向同一个后端存储。下面我们就来讲解如何设置。
*注意*
- 使用共享存储的所有Minio节点需要有相同的access key和secret key。为了做到这一点，我们在所有节点上将access key和secret key export成环境变量，然后再去启动Minio服务。
- 使用共享存储的所有MinIO节点需要有相同的access key和secret key。为了做到这一点，我们在所有节点上将access key和secret key export成环境变量，然后再去启动MinIO服务。
- 下面出现的存储路径都是为了演示目的，在真实环境中使用时，你应该替换成你真实要用的路径。
#### Minio shared mode on Ubuntu 16.04 LTS.
#### MinIO shared mode on Ubuntu 16.04 LTS.
你需要将文件夹指向共享存储，比如`/path/to/nfs-volume`，然后在所有Minio节点上运行下面的命令。
你需要将文件夹指向共享存储，比如`/path/to/nfs-volume`，然后在所有MinIO节点上运行下面的命令。
```sh
export MINIO_ACCESS_KEY=<ACCESS_KEY>
@@ -38,9 +38,9 @@ export MINIO_SECRET_KEY=<SECRET_KEY>
minio gateway nas /path/to/nfs-volume
```
#### Minio shared mode on Windows 2012 Server
#### MinIO shared mode on Windows 2012 Server
你需要将文件夹指向共享存储，比如`\\remote-server\smb`. 然后在所有Minio节点上运行下面的命令。
你需要将文件夹指向共享存储，比如`\\remote-server\smb`. 然后在所有MinIO节点上运行下面的命令。
```cmd
set MINIO_ACCESS_KEY=my-username
@@ -61,11 +61,11 @@ minio.exe gateway nas M:\export
## 3. 验证
为了验证部署是否成功，可能通过浏览器或者[`mc`](https://docs.minio.io/cn/minio-client-quickstart-guide)访问Minio。你应该可以从各个Minio节点访问上传的文件。
为了验证部署是否成功，可能通过浏览器或者[`mc`](https://docs.min.io/cn/minio-client-quickstart-guide)访问MinIO。你应该可以从各个MinIO节点访问上传的文件。
## 了解更多
- [使用`mc`](https://docs.minio.io/cn/minio-client-quickstart-guide)
- [使用`aws-cli`](https://docs.minio.io/cn/aws-cli-with-minio)
- [使用`s3cmd`](https://docs.minio.io/cn/s3cmd-with-minio)
- [使用`minio-go` SDK](https://docs.minio.io/cn/golang-client-quickstart-guide)
- [Minio文档](https://docs.minio.io)
- [使用`mc`](https://docs.min.io/cn/minio-client-quickstart-guide)
- [使用`aws-cli`](https://docs.min.io/cn/aws-cli-with-minio)
- [使用`s3cmd`](https://docs.min.io/cn/s3cmd-with-minio)
- [使用`minio-go` SDK](https://docs.min.io/cn/golang-client-quickstart-guide)
- [MinIO文档](https://docs.min.io)

10
docs/zh_CN/tls/README.md
View File

@@ -1,10 +1,10 @@
# 使用TLS安全的访问Minio服务[![Slack](https://slack.minio.io/slack?type=svg)](https://slack.minio.io)
# 使用TLS安全的访问Minio服务[![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)
本文，我们讲介绍如何在Linux和Windows上配置Minio服务使用TLS。
## 1. 前提条件
* 下载Minio server [这里](https://docs.minio.io/docs/minio-quickstart-guide)
* 下载Minio server [这里](https://docs.min.io/docs/minio-quickstart-guide)
## 2. 配置已存在的证书
@@ -20,7 +20,7 @@ Minio在Linux只支持使用PEM格式的key/certificate。
#### 使用 Let's Encrypt
更多信息，请访问 [这里](https://docs.minio.io/cn/generate-let-s-encypt-certificate-using-concert-for-minio)
更多信息，请访问 [这里](https://docs.min.io/cn/generate-let-s-encypt-certificate-using-concert-for-minio)
#### 使用 generate_cert.go (self-signed certificate)
@@ -125,5 +125,5 @@ certtool.exe --generate-self-signed --load-privkey private.key --template cert.c
Minio可以配置成连接其它服务，不管是Minio节点还是像NATs、Redis这些。如果这些服务用的不是在已知证书机构注册的证书，你可以让Minio服务信任这些CA，怎么做呢，将这些证书放到Minio配置路径下(`~/.minio/certs/CAs/` Linux 或者 `C:\Users\<Username>\.minio\certs\CAs` Windows).
# 了解更多
* [Minio快速入门](https://docs.minio.io/cn/minio-quickstart-guide)
* [Minio客户端权威指南](https://docs.minio.io/cn/minio-client-complete-guide)
* [Minio快速入门](https://docs.min.io/cn/minio-quickstart-guide)
* [Minio客户端权威指南](https://docs.min.io/cn/minio-client-complete-guide)