storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/docs/zh_CN/orchestration/kubernetes-yaml/README.md (about)

     1  # 使用Kubernetes做MinIO的云原生部署 [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)  [![Docker Pulls](https://img.shields.io/docker/pulls/minio/minio.svg?maxAge=604800)](https://hub.docker.com/r/minio/minio/)
     2  
     3  ## 目录
     4  - [前提条件](#前提条件)
     5  - [MinIO独立模式部署](#MinIO-Standalone模式部署)
     6      - [MinIO独立模式快速入门](#MinIO独立模式快速入门)
     7      - [创建持久卷声明](#MinIO独立模式快速入门)
     8      - [创建MinIO的部署](#创建MinIO的部署)
     9      - [创建Miniio服务](#创建Miniio服务)
    10    - [更新已有的MinIO部署](#更新已有的MinIO部署)
    11    - [独立模式资源清理](#独立模式资源清理)
    12  
    13  - [MinIO分布式服务部署](#MinIO分布式服务部署)
    14      - [分布式快速入门](#分布式快速入门)
    15      - [创建MinIO Headless服务](#创建MinIO-Headless服务)
    16      - [创建MinIO Statefulset](#创建MinIO-Statefulset)
    17      - [创建负载均衡服务](#创建负载均衡服务)
    18    - [更新已存在的MinIO StatefulSet](#更新已存在的MinIO-StatefulSet)
    19    - [分布式模式资源清理](#分布式模式资源清理)
    20  
    21  - [MinIO GCS 网关部署](#MinIO-GCS网关部署)
    22      - [GCS 网关快速入门](#GCS-网关快速入门)
    23      - [创建GCS凭据](#创建GCS凭据)
    24      - [创建MinIO GCS Gateway部署](#创建MinIO-GCS-Gateway部署)
    25      - [创建MinIO LoadBalancer服务](#创建MinIO-LoadBalancer服务)
    26      - [更新现有的MinIO GCS部署](#更新现有的MinIO-GCS部署)
    27    - [GCS网关资源清理](#GCS网关资源清理) 
    28  
    29  ## 前提条件
    30  
    31  运行该示例,你需要安装并运行Kubernetes版本>=1.4的集群,而且已经安装 [`kubectl`](https://kubernetes.io/docs/tasks/kubectl/install/) 命令行工具。请访问
    32  [getting started guides](https://kubernetes.io/docs/getting-started-guides/)获取响应平台的安装指导。
    33  ## MinIO Standalone模式部署
    34  
    35  以下部分描述了如何在Kubernetes上部署一个独立的 [MinIO](https://min.io/) 服务。部署使用的是Docker Hub上的 [官方MinIO Docker image](https://hub.docker.com/r/minio/minio/~/dockerfile/) 。
    36  
    37  此部分使用了以下Kubernetes的核心组件:
    38  
    39  - [_Pods_](https://kubernetes.io/docs/user-guide/pods/)
    40  - [_Services_](https://kubernetes.io/docs/user-guide/services/)
    41  - [_Deployments_](https://kubernetes.io/docs/user-guide/deployments/)
    42  - [_Persistent Volume Claims_](https://kubernetes.io/docs/user-guide/persistent-volumes/#persistentvolumeclaims)
    43  
    44  ### MinIO独立模式快速入门
    45  
    46  运行下面的命令快速启动
    47  
    48  ```sh
    49  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-pvc.yaml?raw=true
    50  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-deployment.yaml?raw=true
    51  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-service.yaml?raw=true
    52  ```
    53  
    54  ### 创建持久卷声明
    55  
    56  MinIO需要持久卷来存储对象。如果没有持久卷,MinIO实例中的数据将会存到容器的文件系统中,而且在容器重启时会被清除的干干净净。
    57  创建一个持久卷声明(PVC),为MinIO实例请求存储。Kubernetes寻找与群集中的PVC请求匹配的PV,并自动将其绑定到PVC。
    58  
    59  这是一个PVC的描述
    60  
    61  ```sh
    62  apiVersion: v1
    63  kind: PersistentVolumeClaim
    64  metadata:
    65    # 此名称唯一标识PVC。 将在以下部署中使用。
    66    name: minio-pv-claim
    67    annotations:
    68      volume.alpha.kubernetes.io/storage-class: anything
    69    labels:
    70      app: minio-storage-claim
    71  spec:
    72    # 关于 access modes的更多细节,访问这里: http://kubernetes.io/docs/user-guide/persistent-volumes/#access-modes
    73    accessModes:
    74      - ReadWriteOnce
    75    resources:
    76      # This is the request for storage. Should be available in the cluster.
    77      requests:
    78        storage: 10Gi
    79  ```
    80  
    81  创建一个持久卷声明
    82  
    83  ```sh
    84  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-pvc.yaml?raw=true
    85  persistentvolumeclaim "minio-pv-claim" created
    86  ```
    87  
    88  ### 创建MinIO的部署
    89  
    90  部署封装了副本集和pod - 因此,如果pod掉线,复制控制器会确保另一个pod自动出现。 这样,您就不必担心pod失败,并且可以提供稳定的MinIO服务。
    91  
    92  这是一个部署的描述
    93  
    94  ```sh
    95  apiVersion: extensions/v1beta1
    96  kind: Deployment
    97  metadata:
    98    # This name uniquely identifies the Deployment
    99    name: minio-deployment
   100  spec:
   101    strategy:
   102      type: Recreate
   103    template:
   104      metadata:
   105        labels:
   106          # Label is used as selector in the service.
   107          app: minio
   108      spec:
   109        # Refer to the PVC created earlier
   110        volumes:
   111        - name: data
   112          persistentVolumeClaim:
   113            # Name of the PVC created earlier
   114            claimName: minio-pv-claim
   115        containers:
   116        - name: minio
   117          # Pulls the default MinIO image from Docker Hub
   118          image: minio/minio:RELEASE.2017-05-05T01-14-51Z
   119          args:
   120          - server
   121          - /data
   122          env:
   123          # MinIO access key and secret key
   124          - name: MINIO_ROOT_USER
   125            value: "minio"
   126          - name: MINIO_ROOT_PASSWORD
   127            value: "minio123"
   128          ports:
   129          - containerPort: 9000
   130          # Mount the volume into the pod
   131          volumeMounts:
   132          - name: data # must match the volume name, above
   133            mountPath: "/data"
   134  ```
   135  
   136  创建一个部署
   137  
   138  ```sh
   139  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-deployment.yaml?raw=true
   140  deployment "minio-deployment" created
   141  ```
   142  
   143  ### 创建Miniio服务
   144  
   145  现在您正在运行MinIO部署,您可能希望在内部(集群内)访问它,或者将其作为服务暴露在外部(集群外部,也可能是公共Internet)IP地址,具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP,它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
   146  
   147  在此示例中,我们通过创建LoadBalancer服务来公开MinIO部署。 
   148  这是服务描述。
   149  
   150  ```sh
   151  apiVersion: v1
   152  kind: Service
   153  metadata:
   154    name: minio-service
   155  spec:
   156    type: LoadBalancer
   157    ports:
   158      - port: 9000
   159        targetPort: 9000
   160        protocol: TCP
   161    selector:
   162      app: minio
   163  ```
   164  创建MinIO服务
   165  
   166  ```sh
   167  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-standalone-service.yaml?raw=true
   168  service "minio-service" created
   169  ```
   170  
   171  `LoadBalancer` 服务需要几分钟才能启动。 要检查服务是否已成功创建,请运行命令
   172  
   173  ```sh
   174  kubectl get svc minio-service
   175  NAME            CLUSTER-IP     EXTERNAL-IP       PORT(S)          AGE
   176  minio-service   10.55.248.23   104.199.249.165   9000:31852/TCP   1m
   177  ```
   178  
   179  ### 更新已有的MinIO部署
   180  
   181  您可以更新现有的MinIO部署以使用较新的MinIO版本。 为此,请使用`kubectl set image`命令:
   182  
   183  ```sh
   184  kubectl set image deployment/minio-deployment minio=<replace-with-new-minio-image>
   185  ```
   186  
   187  Kubernetes将重新启动部署以更新镜像。 成功更新后,您将收到以下消息:
   188  
   189  ```
   190  deployment "minio-deployment" image updated
   191  ```
   192  
   193  ### 独立模式资源清理
   194  
   195  你可以清理集群占用的资源,请运行:
   196  
   197  ```sh
   198  kubectl delete deployment minio-deployment \
   199  &&  kubectl delete pvc minio-pv-claim \
   200  && kubectl delete svc minio-service
   201  ```
   202  
   203  ## MinIO分布式服务部署
   204  
   205  以下文档介绍了在Kubernetes上部署[分布式MinIO](https://docs.min.io/cn/distributed-minio-quickstart-guide)服务器的过程。 本示例使用Docker Hub的[官方MinIO Docker镜像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
   206  
   207  此示例使用以下Kubernetes的核心组件:
   208  
   209  - [_Pods_](https://kubernetes.io/docs/concepts/workloads/pods/pod/)
   210  - [_Services_](https://kubernetes.io/docs/concepts/services-networking/service/)
   211  - [_Statefulsets_](https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/)
   212  
   213  ### 分布式快速入门
   214  
   215  运行下面的命令快速启动
   216  
   217  ```sh
   218  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-headless-service.yaml?raw=true
   219  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-statefulset.yaml?raw=true
   220  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-service.yaml?raw=true
   221  ```
   222  
   223  ###创建MinIO Headless服务
   224  
   225  Headless服务控制在其中创建StatefulSets的域。此服务管理的域采用以下格式:`$(service name).$(namespace).svc.cluster.local`(其中“cluster.local”是集群域),此域中的pod采用形式: `$(pod-name-{i}).$(service name).$(namespace).svc.cluster.local`。这里需要DNS来解析在Statefulset中创建的每个pods的URL。
   226  
   227  这是Headless service的描述。
   228  
   229  ```sh
   230  apiVersion: v1
   231  kind: Service
   232  metadata:
   233    name: minio
   234    labels:
   235      app: minio
   236  spec:
   237    clusterIP: None
   238    ports:
   239      - port: 9000
   240        name: minio
   241    selector:
   242      app: minio
   243  ```
   244  
   245  创建Headless服务
   246  
   247  ```sh
   248  $ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-headless-service.yaml?raw=true
   249  service "minio" created
   250  ```
   251  
   252  ###创建MinIO Statefulset
   253  
   254  StatefulSet为每个pod提供确定性名称和唯一身份,从而轻松部署有状态的分布式应用程序。 要启动分布式MinIO,您需要将驱动器位置作为参数传递到minio服务的命令。 然后,您需要在所有参与的pod上运行相同的命令。 StatefulSets提供了一个完美的方式来处理这个要求。
   255  
   256  这是Statefulset的描述。
   257  
   258  ```sh
   259  apiVersion: apps/v1beta1
   260  kind: StatefulSet
   261  metadata:
   262    name: minio
   263  spec:
   264    serviceName: minio
   265    replicas: 4
   266    template:
   267      metadata:
   268        annotations:
   269          pod.alpha.kubernetes.io/initialized: "true"
   270        labels:
   271          app: minio
   272      spec:
   273        containers:
   274        - name: minio
   275          env:
   276          - name: MINIO_ROOT_USER
   277            value: "minio"
   278          - name: MINIO_ROOT_PASSWORD
   279            value: "minio123"
   280          image: minio/minio:RELEASE.2017-05-05T01-14-51Z
   281          args:
   282          - server
   283          - http://minio-0.minio.default.svc.cluster.local/data
   284          - http://minio-1.minio.default.svc.cluster.local/data
   285          - http://minio-2.minio.default.svc.cluster.local/data
   286          - http://minio-3.minio.default.svc.cluster.local/data
   287          ports:
   288          - containerPort: 9000
   289          # These volume mounts are persistent. Each pod in the PetSet
   290          # gets a volume mounted based on this field.
   291          volumeMounts:
   292          - name: data
   293            mountPath: /data
   294    # These are converted to volume claims by the controller
   295    # and mounted at the paths mentioned above.
   296    volumeClaimTemplates:
   297    - metadata:
   298        name: data
   299        annotations:
   300          volume.alpha.kubernetes.io/storage-class: anything
   301      spec:
   302        accessModes:
   303          - ReadWriteOnce
   304        resources:
   305          requests:
   306            storage: 10Gi
   307  ```
   308  
   309  创建Statefulset
   310  
   311  ```sh
   312  $ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-statefulset.yaml?raw=true
   313  statefulset "minio" created
   314  ```
   315  
   316  ### 创建负载均衡服务
   317  
   318  现在您已经运行了MinIO statefulset,您可能希望在内部(集群内)访问它,或将其作为服务暴露在外部(集群外,也可能是公用Internet)的IP地址,具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP,它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
   319  
   320  在此示例中,我们通过创建LoadBalancer服务来公开MinIO部署。
   321   这是服务描述。
   322  
   323  ```sh
   324  apiVersion: v1
   325  kind: Service
   326  metadata:
   327    name: minio-service
   328  spec:
   329    type: LoadBalancer
   330    ports:
   331      - port: 9000
   332        targetPort: 9000
   333        protocol: TCP
   334    selector:
   335      app: minio
   336  ```
   337  创建MinIO service
   338  
   339  ```sh
   340  $ kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-distributed-service.yaml?raw=true
   341  service "minio-service" created
   342  ```
   343  
   344  `LoadBalancer` 服务需要几分钟才能启动。 要检查服务是否已成功创建,请运行命令
   345  
   346  ```sh
   347  $ kubectl get svc minio-service
   348  NAME            CLUSTER-IP     EXTERNAL-IP       PORT(S)          AGE
   349  minio-service   10.55.248.23   104.199.249.165   9000:31852/TCP   1m
   350  ```
   351  
   352  ###更新已经存在的MinIO StatefulSet
   353  您可以更新现有的MinIO StatefulSet以使用较新的MinIO版本。 为此,请使用`kubectl patch statefulset`命令:
   354  
   355  ```sh
   356  kubectl patch statefulset minio --type='json' -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/image", "value":"<replace-with-new-minio-image>"}]'
   357  ```
   358  
   359  成功更新后,您应该会看到下面的输出
   360  
   361  ```
   362  statefulset "minio" patched
   363  ```
   364  
   365  然后如下所示,逐一删除StatefulSet中的所有pod。 Kubernetes将使用新的镜像为您重新启动那些pod。
   366  
   367  ```sh
   368  kubectl delete minio-0
   369  ```
   370  
   371  ### 分布式模式资源清理
   372  
   373  你可以使用以下命令清理集群
   374  ```sh
   375  kubectl delete statefulset minio \
   376  &&  kubectl delete svc minio \
   377  && kubectl delete svc minio-service
   378  ```
   379  
   380  ## MinIO GCS网关部署
   381  
   382  以下部分介绍在Kubernetes上部署[MinIO](https://min.io/)GCS Gateway的过程。 部署使用Docker Hub的[官方MinIO Docker映像](https://hub.docker.com/r/minio/minio/~/dockerfile/)。
   383  
   384  此示例使用以下Kubernetes的核心组件:
   385  
   386  - [_Secrets_](https://kubernetes.io/docs/concepts/configuration/secret/)
   387  - [_Services_](https://kubernetes.io/docs/user-guide/services/)
   388  - [_Deployments_](https://kubernetes.io/docs/user-guide/deployments/)
   389  
   390  ### GCS 网关快速入门
   391  
   392  按照 [这里](https://github.com/minio/minio/blob/master/docs/gateway/gcs.md#create-service-account-key-for-gcs-and-get-the-credentials-file)描述的步骤创建Google云服务认证凭据文件。
   393  
   394  使用上面生成的文件来创建一个Kubernetes`secret`。
   395  
   396  ```sh
   397  kubectl create secret generic gcs-credentials --from-file=/path/to/gcloud/credentials/application_default_credentials.json
   398  ```
   399  
   400  下载 `minio-gcs-gateway-deployment.yaml` 
   401  
   402  ```sh
   403  wget https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-deployment.yaml?raw=true
   404  ```
   405  
   406  使用你的GCS  project ID更新 `gcp_project_id`部分的内容,然后运行 
   407  
   408  ```sh
   409  kubectl create -f minio-gcs-gateway-deployment.yaml
   410  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-service.yaml?raw=true
   411  ```
   412  
   413  ### 创建GCS凭据
   414  
   415  `凭据`旨在保存敏感信息,例如密码,OAuth令牌和ssh密钥。 将这些信息放在一个凭据中比将其逐字地放在pod定义或docker镜像中更安全,更灵活。
   416  
   417  按照 [这里](https://github.com/minio/minio/blob/master/docs/gateway/gcs.md#create-service-account-key-for-gcs-and-get-the-credentials-file)描述的步骤创建Google云服务认证凭据文件。
   418  
   419  使用上面生成的文件来创建一个Kubernetes`secret`。
   420  
   421  ```sh
   422  kubectl create secret generic gcs-credentials --from-file=/path/to/gcloud/credentials/application_default_credentials.json
   423  ```
   424  
   425  ### 创建MinIO GCS Gateway部署
   426  
   427  部署封装了副本集和pod - 因此,如果pod掉线,复制控制器会确保另一个pod自动出现。 这样,您就不必担心pod失败,并且可以提供稳定的MinIO服务。
   428  
   429  MinIO Gateway使用GCS作为其存储后端,需要使用GCP“projectid”来识别您的凭据。 使用GCS项目ID更新“gcp_project_id”部分。 这是部署描述。
   430  
   431  ```sh
   432  apiVersion: extensions/v1beta1
   433  kind: Deployment
   434  metadata:
   435    # This name uniquely identifies the Deployment
   436    name: minio-deployment
   437  spec:
   438    strategy:
   439      type: Recreate
   440    template:
   441      metadata:
   442        labels:
   443          # Label is used as selector in the service.
   444          app: minio
   445      spec:
   446        # Refer to the secret created earlier
   447        volumes:
   448        - name: gcs-credentials
   449          secret:
   450            # Name of the Secret created earlier
   451            secretName: gcs-credentials
   452        containers:
   453        - name: minio
   454          # Pulls the default MinIO image from Docker Hub
   455          image: minio/minio:RELEASE.2017-08-05T00-00-53Z
   456          args:
   457          - gateway
   458          - gcs
   459          - gcp_project_id
   460          env:
   461          # MinIO access key and secret key
   462          - name: MINIO_ROOT_USER
   463            value: "minio"
   464          - name: MINIO_ROOT_PASSWORD
   465            value: "minio123"
   466          # Google Cloud Service uses this variable
   467          - name: GOOGLE_APPLICATION_CREDENTIALS
   468            value: "/etc/credentials/application_default_credentials.json"
   469          ports:
   470          - containerPort: 9000
   471          # Mount the volume into the pod
   472          volumeMounts:
   473          - name: gcs-credentials
   474            mountPath: "/etc/credentials"
   475            readOnly: true
   476  ```
   477  
   478  创建部署
   479  
   480  ```sh
   481  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-deployment.yaml?raw=true
   482  deployment "minio-deployment" created
   483  ```
   484  
   485  ### 创建MinIO LoadBalancer服务
   486  
   487  现在您正在运行MinIO,您可能希望在内部(集群内)访问它,或者将其作为服务暴露在外部(集群外部,也可能是公共Internet)IP地址,具体取决于用例。 您可以使用服务来实现此目的。 有三种主要的服务类型 - 默认类型是ClusterIP,它将集群内部的连接暴露给服务。 NodePort和LoadBalancer是向外部流量提供服务的两种类型。
   488  
   489  在此示例中,我们通过创建LoadBalancer服务来暴露MinIO。 这是服务描述。
   490  
   491  ```sh
   492  apiVersion: v1
   493  kind: Service
   494  metadata:
   495    name: minio-service
   496  spec:
   497    type: LoadBalancer
   498    ports:
   499      - port: 9000
   500        targetPort: 9000
   501        protocol: TCP
   502    selector:
   503      app: minio
   504  ```
   505  创建MinIO服务
   506  
   507  ```sh
   508  kubectl create -f https://github.com/minio/minio/blob/master/docs/orchestration/kubernetes-yaml/minio-gcs-gateway-service.yaml?raw=true
   509  service "minio-service" created
   510  ```
   511  
   512  `LoadBalancer`服务需要几分钟才能启动。 要检查服务是否已成功创建,请运行命令
   513  
   514  ```sh
   515  kubectl get svc minio-service
   516  NAME            CLUSTER-IP     EXTERNAL-IP       PORT(S)          AGE
   517  minio-service   10.55.248.23   104.199.249.165   9000:31852/TCP   1m
   518  ```
   519  
   520  ### 更新现有的MinIO GCS部署
   521  
   522  您可以更新现有的MinIO部署以使用较新的MinIO版本。 为此,请使用`kubectl set image`命令:
   523  
   524  ```sh
   525  kubectl set image deployment/minio-deployment minio=<replace-with-new-minio-image>
   526  ```
   527  
   528  Kubernetes将重新启动部署以更新镜像。 成功更新后,您将收到以下消息:
   529  ```
   530  deployment "minio-deployment" image updated
   531  ```
   532  
   533  ### GCS网关资源清理
   534  
   535  你可以使用下面的命令清理集群
   536  
   537  ```sh
   538  kubectl delete deployment minio-deployment \
   539  &&  kubectl delete secret gcs-credentials 
   540  ```