minio/docs
1
0
Fork 0
mirror of https://github.com/minio/docs.git synced 2025-07-30 07:03:26 +03:00
Code Activity

DOCS-1021: Adding helm information (#1060)

Browse Source 
Closes #1021 
Closes #1055 
Closes #968 
Closes #943 


---------

Co-authored-by: Andrea Longo <feorlen@users.noreply.github.com>
Co-authored-by: Pedro Juarez <pjuarezd@users.noreply.github.com>
This commit is contained in:
Ravind Kumar
2023-11-16 12:56:20 -05:00
committed by GitHub
parent 09ce8edb48
commit c770ba9d76
17 changed files with 1577 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
source/operations/install-deploy-manage/deploy-minio-tenant-helm.rst Normal file
View File

@ -0,0 +1,244 @@
.. _deploy-tenant-helm:
======================================
Deploy a MinIO Tenant with Helm Charts
======================================
.. default-domain:: minio
.. contents:: Table of Contents
:local:
:depth: 1
Overview
--------
Helm is a tool for automating the deployment of applications to Kubernetes clusters.
A `Helm chart <https://helm.sh/docs/topics/charts/>`__ is a set of YAML files, templates, and other files that define the deployment details.
The following procedure uses a Helm Chart to deploy a Tenant managed by the MinIO Operator.
This procedure requires the Kubernetes cluster have a valid :ref:`Operator <deploy-operator-kubernetes>` deployment.
You cannot use the MinIO Operator Tenant chart to deploy a Tenant independent of the Operator.
.. important::
The MinIO Operator Tenant Chart is *distinct* from the community-managed :minio-git:`MinIO Chart <minio/tree/master/helm/minio>`.
The Community Helm Chart is community built, maintained, and supported.
MinIO does not guarantee support for any given bug, feature request, or update referencing that chart.
The Operator Tenant Chart is officially maintained and supported by MinIO.
MinIO strongly recommends the official Helm Chart for Operator and Tenants for production environments.
Prerequisites
-------------
You must meet the following requirements to install a MinIO Tenant with Helm:
- An existing Kubernetes cluster
- The ``kubectl`` CLI tool on your local host with version matching the cluster.
- `Helm <https://helm.sh/docs/intro/install/>`__ version 3.8 or greater.
- `yq <https://github.com/mikefarah/yq/#install>`__ version 4.18.1 or greater.
- An existing :ref:`MinIO Operator installation <deploy-operator-kubernetes>`.
This procedure assumes your Kubernetes cluster access grants you broad administrative permissions.
For more about Tenant installation requirements, including supported Kubernetes versions and TLS certificates, see the :ref:`Tenant deployment prerequisites <deploy-minio-distributed-prereqs-storage>`.
This procedure assumes familiarity the with referenced Kubernetes concepts and utilities.
While this documentation may provide guidance for configuring or deploying Kubernetes-related resources on a best-effort basis, it is not a replacement for the official :kube-docs:`Kubernetes Documentation <>`.
.. _deploy-tenant-helm-repo:
Deploy a MinIO Tenant using Helm Charts
---------------------------------------
The following procedure deploys a MinIO Tenant using the MinIO Operator Chart Repository.
This method supports a simplified installation path compared to the :ref:`local chart installation <deploy-tenant-helm-local>`.
You can modify the Operator deployment after installation.
.. important::
Do not use the ``kubectl krew`` or similar methods to update or manage the MinIO Tenant installation.
If you use Helm charts to deploy the Tenant, you must use Helm to manage that deployment.
#. Validate the Operator Repository Contents
Use ``helm search`` to check the latest available chart version in the Operator Repo:
.. code-block:: shell
:class: copyable
helm search repo minio-operator
The response should resemble the following:
.. code-block:: shell
:class: copyable
NAME CHART VERSION APP VERSION DESCRIPTION
minio-operator/minio-operator 4.3.7 v4.3.7 A Helm chart for MinIO Operator
minio-operator/operator 5.0.10 v5.0.10 A Helm chart for MinIO Operator
minio-operator/tenant 5.0.10 v5.0.10 A Helm chart for MinIO Operator
The ``minio-operator/minio-operator`` is a legacy chart and should **not** be installed under normal circumstances.
If your ``minio-operator/operator`` version is behind the latest available chart, upgrade the operator *first*.
#. Deploy the Helm Chart
Use the ``helm install`` command to deploy the Tenant Chart.
If you need to override values in the default :ref:`values <minio-operator-chart-tenant-values>` file, you can use the ``--set`` operation for any single key-value.
Alternatively, specify your own ``values.yaml`` using the ``--f`` parameter to override multiple values at once:
.. code-block:: shell
:class: copyable
helm install \
--namespace MINIO_TENANT_NAMESPACE \
--create-namespace \
MINIO_TENANT_NAME minio-operator/tenant
#. Validate the Tenant installation
Check the contents of the specified namespace to ensure all pods and services have started successfully.
.. code-block:: shell
:class: copyable
kubectl get all -n MINIO_TENANT_NAMESPACE
All pods and services should have a READY state before proceeding.
#. Expose the Tenant Console port
Use ``kubectl port-forward`` to temporarily forward traffic from the MinIO pod to your local machine:
.. code-block:: shell
:class: copyable
kubectl --namespace MINIO_TENANT_NAMESPACE port-forward svc/MINIO_TENANT_NAME-console 9443:9443
.. note::
To configure long term access to the pod, configure :kube-docs:`Ingress <concepts/services-networking/ingress/>` or similar network control components within Kubernetes to route traffic to and from the pod.
Configuring Ingress is out of the scope for this documentation.
#. Login to the MinIO Console
Access the Tenant's :ref:`minio-console` by navigating to ``http://localhost:9443`` in a browser.
Log in to the Console with the default credentials ``myminio | minio123``.
If you modified these credentials in the ``values.yaml`` specify those values instead.
#. Expose the Tenant MinIO S3 API port
To test the MinIO Client :mc:`mc` from your local machine, forward the MinIO port and create an alias.
* Forward the Tenant's MinIO port:
.. code-block:: shell
:class: copyable
kubectl port-forward svc/minio 9000 -n MINIO_TENANT_NAMESPACE
* Create an alias for the Tenant service:
.. code-block:: shell
:class: copyable
mc alias set myminio https://localhost:9000 minio minio123 --insecure
You can use :mc:`mc mb` to create a bucket on the Tenant:
.. code-block:: shell
:class: copyable
mc mb myminio/mybucket --insecure
If you deployed your MinIO Tenant using TLS certificates minted by a trusted Certificate Authority (CA) you can omit the ``--insecure`` flag.
.. _deploy-tenant-helm-local:
Deploy a Tenant using a Local Helm Chart
----------------------------------------
The following procedure deploys a Tenant using a local copy of the Helm Charts.
This method may support easier pre-configuration of the Tenant compared to the :ref:`repo-based installation <deploy-tenant-helm-repo>`
#. Download the Helm charts
On your local host, download the Tenant Helm charts to a convenient directory:
.. code-block:: shell
:class: copyable
:substitutions:
curl -O https://raw.githubusercontent.com/minio/operator/master/helm-releases/tenant-|operator-version-stable|.tgz
Each chart contains a ``values.yaml`` file you can customize to suit your needs.
For example, you may wish to change the MinIO root user credentials or the Tenant name.
For more about customizations, see `Helm Charts <https://helm.sh/docs/topics/charts/>`__.
#. The following Helm command creates a MinIO Tenant using the standard chart:
.. code-block:: shell
:class: copyable
:substitutions:
helm install \
--namespace MINIO_TENANT_NAMESPACE \
--create-namespace \
MINIO_TENANT_NAME tenant-|operator-version-stable|.tgz
To deploy more than one Tenant, create a Helm chart with the details of the new Tenant and repeat the deployment steps.
Redeploying the same chart updates the previously deployed Tenant.
#. Expose the Tenant Console port
Use ``kubectl port-forward`` to temporarily forward traffic from the MinIO pod to your local machine:
.. code-block:: shell
:class: copyable
kubectl --namespace MINIO_TENANT_NAMESPACE port-forward svc/myminio-console 9443:9443
.. note::
To configure long term access to the pod, configure :kube-docs:`Ingress <concepts/services-networking/ingress/>` or similar network control components within Kubernetes to route traffic to and from the pod.
Configuring Ingress is out of the scope for this documentation.
#. Login to the MinIO Console
Access the Tenant's :ref:`minio-console` by navigating to ``http://localhost:9443`` in a browser.
Log in to the Console with the default credentials ``myminio | minio123``.
#. Expose the Tenant MinIO port
To test the MinIO Client :mc:`mc` from your local machine, forward the MinIO port and create an alias.
* Forward the Tenant's MinIO port:
.. code-block:: shell
:class: copyable
kubectl port-forward svc/myminio-hl 9000 -n MINIO_TENANT_NAMESPACE
* Create an alias for the Tenant service:
.. code-block:: shell
:class: copyable
mc alias set myminio https://localhost:9000 minio minio123 --insecure
This example uses the non-TLS ``myminio-hl`` service, which requires :std:option:`--insecure <mc.--insecure>`.
If you have a TLS cert configured, omit ``--insecure`` and use ``svc/minio`` instead.
You can use :mc:`mc mb` to create a bucket on the Tenant:
.. code-block:: shell
:class: copyable
mc mb myminio/mybucket --insecure

6
source/operations/install-deploy-manage/deploy-minio-tenant.rst
View File

@ -789,3 +789,9 @@ Kubernetes provides multiple options for configuring external access to services
.. cond:: k8s and not (openshift or eks)
.. include:: /includes/k8s/steps-deploy-tenant-cli.rst
.. toctree::
:titlesonly:
:hidden:
/operations/install-deploy-manage/deploy-minio-tenant-helm

233
source/operations/install-deploy-manage/deploy-operator-helm.rst
View File

@ -18,7 +18,6 @@ Helm is a tool for automating the deployment of applications to Kubernetes clust
A `Helm chart <https://helm.sh/docs/topics/charts/>`__ is a set of YAML files, templates, and other files that define the deployment details.
The following procedure uses a Helm Chart to install the :ref:`MinIO Kubernetes Operator <minio-operator-installation>` to a Kubernetes cluster.
Prerequisites
-------------
@ -35,27 +34,172 @@ For more about Operator installation requirements, including supported Kubernete
This procedure assumes familiarity the with referenced Kubernetes concepts and utilities.
While this documentation may provide guidance for configuring or deploying Kubernetes-related resources on a best-effort basis, it is not a replacement for the official :kube-docs:`Kubernetes Documentation <>`.
.. _minio-k8s-deploy-operator-helm-repo:
Procedure
---------
Install the MinIO Operator using Helm Charts
--------------------------------------------
The following procedure installs the Operator using the MinIO Operator Chart Repository.
This method supports a simplified installation path compared to the :ref:`local chart installation <minio-k8s-deploy-operator-helm-local>`.
You can modify the Operator deployment after installation.
Install Operator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. important::
Do not use ``kubectl krew`` or similar methods to update or manage the MinIO Operator installation.
If you use Helm charts to install the Operator, you must use Helm to manage that installation.
#. Add the MinIO Operator Repo to Helm
MinIO maintains a Helm-compatible repository at https://operator.min.io.
Add this repository to Helm:
.. code-block:: shell
:class: copyable
helm repo add minio-operator https://operator.min.io
You can validate the repo contents using ``helm search``:
.. code-block:: shell
:class: copyable
helm search repo minio-operator
The response should resemble the following:
.. code-block:: shell
:class: copyable
NAME CHART VERSION APP VERSION DESCRIPTION
minio-operator/minio-operator 4.3.7 v4.3.7 A Helm chart for MinIO Operator
minio-operator/operator 5.0.10 v5.0.10 A Helm chart for MinIO Operator
minio-operator/tenant 5.0.10 v5.0.10 A Helm chart for MinIO Operator
The ``minio-operator/minio-operator`` is a legacy chart and should **not** be installed under normal circumstances.
#. Install the Operator
Run the ``helm install`` command to install the Operator:
.. code-block:: shell
:class: copyable
helm install
--namespace minio-operator \
--create-namespace \
operator minio-operator/operator
#. Verify the Operator installation
Check the contents of the specified namespace (``minio-operator``) to ensure all pods and services have started successfully.
.. code-block:: shell
:class: copyable
kubectl get all -n minio-operator
The response should resemble the following:
.. code-block:: shell
NAME READY STATUS RESTARTS AGE
pod/console-68d955874d-vxlzm 1/1 Running 0 25h
pod/minio-operator-699f797b8b-th5bk 1/1 Running 0 25h
pod/minio-operator-699f797b8b-nkrn9 1/1 Running 0 25h
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/console ClusterIP 10.43.195.224 <none> 9090/TCP,9443/TCP 25h
service/operator ClusterIP 10.43.44.204 <none> 4221/TCP 25h
service/sts ClusterIP 10.43.70.4 <none> 4223/TCP 25h
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/console 1/1 1 1 25h
deployment.apps/minio-operator 2/2 2 2 25h
NAME DESIRED CURRENT READY AGE
replicaset.apps/console-68d955874d 1 1 1 25h
replicaset.apps/minio-operator-699f797b8b 2 2 2 25h
#. (Optional) Enable NodePort Access to the Console
You can enable :kube-docs:`Node Port <concepts/services-networking/service/#type-nodeport>` access to the ``service/console`` service to allow simplified access to the MinIO Operator.
You can skip this step if you intend to configure the Operator Console service to use a Kubernetes Load Balancer, ingress, or similar control plane component that enables external access.
Edit the ``service/console`` and set the ``spec.ports[0].nodePort`` and ``spec.type`` fields as follows:
.. code-block:: yaml
spec:
ports:
- name: http
port: 9090
protocol: TCP
targetPort: 9090
nodePort: 39090
type: NodePort
You can attempt to connect to the MinIO Operator Console by specifying port ``39090`` on any of the worker nodes in the deployment.
#. Retrieve the Console Access Token
The MinIO Operator uses a JSON Web Token (JWT) saved as a Kubernetes Secret for controlling access to the Operator Console.
Use the following command to retrieve the JWT for login.
You must have permission within the Kubernetes cluster to read secrets:
.. code-block:: shell
:class: copyable
kubectl get secret/console-sa-secret -n minio-operator -o json | jq -r ".data.token" | base64 -d
The output should resemble the following:
.. code-block:: shell
eyJhbGciOiJSUzI1NiIsImtpZCI6IlRtV2x3Z1RILVREaThhQm9iemFfLW95NHFHT0ZZOHFBRjlZalBRcWZiSDgifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJtaW5pby1vcGVyYXRvciIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJjb25zb2xlLXNhLXNlY3JldCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50Lm5hbWUiOiJjb25zb2xlLXNhIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiY2M1ZjEwYzktYzU1ZC00MjNiLTgxM2MtNmU5ZDY2ZGI5NDYyIiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Om1pbmlvLW9wZXJhdG9yOmNvbnNvbGUtc2EifQ.F-Pt5nU9xaugjRksWAOTShBW_eNTf8UwXvLfGxEK6l3_41NYsLgvTg5m0hYLUiYr6v2HwkEu0XzqTJbPoeSrFds8BOjeiCoP2Lmw4tRPo9tSXhAq-_elWt83YpJl-zjUpna5nVSWJWXKgj1Iga-9gw-Q63UygEcyTJ9_AwCNU9T0HdPzqccS9XrEUdsXFQxR9RwZY4TGC8K7cD9sc_OmfEiuyilRgyC_gFRvtCQfFv1DP0GKyjMGo2ffu-2Tq2U7zK5epWdqmNSvbIa0ZRoPlPedZ6nYY935lNgTIIW1oykRYrgwZZiv4CzfTH2gPswjtPc5ICtDDRUjYEhdTq3gtw
If the output includes a trailing ``%`` make sure to omit it from the result.
#. Log into the MinIO Operator Console
If you configured the ``svc/console`` service for access through ingress, a cluster load balancer, you can access the Console using the configured hostname and port.
If you configured the service for access through NodePorts, specify the hostname of any worker node in the cluster with that port as ``HOSTNAME:NODEPORT`` to access the Console.
Alternatively, you can use ``kubectl port forward`` to temporary forward ports for the Console:
.. code-block:: shell
:class: copyable
kubectl port-forward svc/console -n minio-operator 9090:9090
You can then use ``http://localhost:9090`` to access the MinIO Operator Console.
Once you access the Console, use the Console JWT to log in.
You can now :ref:`deploy and manage MinIO Tenants using the Operator Console <deploy-minio-distributed>`.
You can also :ref:`deploy a tenant using Helm Charts <deploy-tenant-helm>`.
.. _minio-k8s-deploy-operator-helm-local:
Install the MinIO Operator using Local Helm Charts
--------------------------------------------------
The following procedure installs the Operator using a local copy of the Helm Charts.
This method may support easier pre-configuration of the Operator compared to the :ref:`repo-based installation <minio-k8s-deploy-operator-helm-repo>`
#. Download the Helm charts
On your local host, download the Operator and Tenant Helm charts to a convenient directory:
On your local host, download the Operator Helm charts to a convenient directory:
.. code-block:: shell
:class: copyable
:substitutions:
curl -O https://raw.githubusercontent.com/minio/operator/master/helm-releases/operator-|operator-version-stable|.tgz
curl -O https://raw.githubusercontent.com/minio/operator/master/helm-releases/tenant-|operator-version-stable|.tgz
Each chart contains a ``values.yaml`` file you can customize to suit your needs.
For example, you may wish to change the MinIO root user credentials or the Tenant name.
The chart contains a ``values.yaml`` file you can customize to suit your needs.
For more about customizations, see `Helm Charts <https://helm.sh/docs/topics/charts/>`__.
#. Deploy Operator
@ -375,73 +519,6 @@ Install Operator
Append the ``nodePort`` value to the externally-accessible IP address of a worker node in your Kubernetes cluster.
You can now :ref:`deploy and manage MinIO Tenants using the Operator Console <deploy-minio-distributed>`.
Deploy a Tenant
~~~~~~~~~~~~~~~
You can deploy a MinIO Tenant using either the :ref:`Operator Console <minio-operator-console>` or Helm.
To deploy a Tenant with the Console, see :ref:`Deploy and Manage MinIO Tenants <minio-installation>`.
To deploy a Tenant with Helm:
#. The following Helm command creates a MinIO Tenant using the standard chart:
.. code-block:: shell
:class: copyable
:substitutions:
helm install \
--namespace tenant-ns \
--create-namespace \
tenant-ns tenant-|operator-version-stable|.tgz
To deploy more than one Tenant, create a Helm chart with the details of the new Tenant and repeat the deployment steps.
Redeploying the same chart updates the previously deployed Tenant.
#. Expose the Tenant Console port
Use ``kubectl port-forward`` to temporarily forward traffic from the MinIO pod to your local machine:
.. code-block:: shell
:class: copyable
kubectl --namespace tenant-ns port-forward svc/myminio-console 9443:9443
.. note::
To configure long term access to the pod, configure :kube-docs:`Ingress <concepts/services-networking/ingress/>` or similar network control components within Kubernetes to route traffic to and from the pod.
Configuring Ingress is out of the scope for this documentation.
#. Login to the MinIO Console
Access the Tenant's :ref:`minio-console` by navigating to ``http://localhost:9443`` in a browser.
Log in to the Console with the default credentials ``myminio | minio123``.
#. Expose the Tenant MinIO port
To test the MinIO Client :mc:`mc` from your local machine, forward the MinIO port and create an alias.
* Forward the Tenant's MinIO port:
.. code-block:: shell
:class: copyable
kubectl port-forward svc/myminio-hl 9000 -n tenant-ns
* Create an alias for the Tenant service:
.. code-block:: shell
:class: copyable
mc alias set myminio https://localhost:9000 minio minio123 --insecure
This example uses the non-TLS ``myminio-hl`` service, which requires :std:option:`--insecure <mc.--insecure>`.
If you have a TLS cert configured, omit ``--insecure`` and use ``svc/minio`` instead.
You can use :mc:`mc mb` to create a bucket on the Tenant:
.. code-block:: shell
:class: copyable
mc mb myminio/mybucket --insecure
You can also :ref:`deploy a tenant using Helm Charts <deploy-tenant-helm>`.

168
source/operations/install-deploy-manage/upgrade-minio-operator.rst
View File

@ -134,59 +134,151 @@ The following steps back up the existing yaml files, perform some clean up, and
Upgrade Operator to |operator-version-stable|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. *(Optional)* Update each MinIO Tenant to the latest stable MinIO Version.
Upgrading MinIO regularly ensures your Tenants have the latest features and performance improvements.
Test upgrades in a lower environment such as a Dev or QA Tenant, before applying to your production Tenants.
See :ref:`minio-k8s-upgrade-minio-tenant` for a procedure on upgrading MinIO Tenants.
.. tab-set::
2. Verify the existing Operator installation.
Use ``kubectl get all -n minio-operator`` to verify the health and status of all Operator pods and services.
If you installed the Operator to a custom namespace, specify that namespace as ``-n <NAMESPACE>``.
.. tab-item:: Upgrade using MinIO Kubernetes Plugin
You can verify the currently installed Operator version by retrieving the object specification for an operator pod in the namespace.
The following example uses the ``jq`` tool to filter the necessary information from ``kubectl``:
The following procedure upgrades the MinIO Operator using the :mc:`kubectl minio <kubectl minio init>` plugin.
.. code-block:: shell
:class: copyable
If you installed the Operator using :ref:`Helm <minio-k8s-deploy-operator-helm>`, use the :guilabel:`Upgrade using Helm` instructions instead.
kubectl get pod -l 'name=minio-operator' -n minio-operator -o json | jq '.items[0].spec.containers'
The output resembles the following:
.. code-block:: json
:emphasize-lines: 8-10
1. *(Optional)* Update each MinIO Tenant to the latest stable MinIO Version.
Upgrading MinIO regularly ensures your Tenants have the latest features and performance improvements.
Test upgrades in a lower environment such as a Dev or QA Tenant, before applying to your production Tenants.
See :ref:`minio-k8s-upgrade-minio-tenant` for a procedure on upgrading MinIO Tenants.
2. Verify the existing Operator installation.
Use ``kubectl get all -n minio-operator`` to verify the health and status of all Operator pods and services.
If you installed the Operator to a custom namespace, specify that namespace as ``-n <NAMESPACE>``.
You can verify the currently installed Operator version by retrieving the object specification for an operator pod in the namespace.
The following example uses the ``jq`` tool to filter the necessary information from ``kubectl``:
.. code-block:: shell
:class: copyable
kubectl get pod -l 'name=minio-operator' -n minio-operator -o json | jq '.items[0].spec.containers'
The output resembles the following:
.. code-block:: json
:emphasize-lines: 8-10
:substitutions:
{
"env": [
{
"name": "CLUSTER_DOMAIN",
"value": "cluster.local"
"env": [
{
"name": "CLUSTER_DOMAIN",
"value": "cluster.local"
}
],
"image": "minio/operator:v|operator-version-stable|",
"imagePullPolicy": "IfNotPresent",
"name": "minio-operator"
}
],
"image": "minio/operator:v4.5.8",
"imagePullPolicy": "IfNotPresent",
"name": "minio-operator"
}
3. Download the latest stable version of the MinIO Kubernetes Plugin
3. Download the latest stable version of the MinIO Kubernetes Plugin
.. include:: /includes/k8s/install-minio-kubectl-plugin.rst
.. include:: /includes/k8s/install-minio-kubectl-plugin.rst
4. Run the initialization command to upgrade the Operator
4. Run the initialization command to upgrade the Operator
Use the :mc-cmd:`kubectl minio init` command to upgrade the existing MinIO Operator installation
Use the :mc-cmd:`kubectl minio init` command to upgrade the existing MinIO Operator installation:
.. code-block:: shell
:class: copyable
.. code-block:: shell
:class: copyable
kubectl minio init
kubectl minio init
5. Validate the Operator upgrade
5. Validate the Operator upgrade
You can check the Operator version by reviewing the object specification for an Operator Pod using a previous step.
.. include:: /includes/common/common-k8s-connect-operator-console.rst
.. tab-item:: Upgrade using Helm
The following procedure upgrades an existing MinIO Operator Installation using Helm.
If you installed the Operator using :ref:`the MinIO Kubernetes Plugin <deploy-operator-kubernetes>`, use the :guilabel:`Upgrade using MinIO Kubernetes Plugin` instructions instead.
1. *(Optional)* Update each MinIO Tenant to the latest stable MinIO Version.
Upgrading MinIO regularly ensures your Tenants have the latest features and performance improvements.
Test upgrades in a lower environment such as a Dev or QA Tenant, before applying to your production Tenants.
See :ref:`minio-k8s-upgrade-minio-tenant` for a procedure on upgrading MinIO Tenants.
#. Verify the existing Operator installation.
Use ``kubectl get all -n minio-operator`` to verify the health and status of all Operator pods and services.
If you installed the Operator to a custom namespace, specify that namespace as ``-n <NAMESPACE>``.
Use the ``helm list`` command to view the installed charts in the namespace:
.. code-block:: shell
:class: copyable
helm list -n minio-operator
The result should resemble the following:
.. code-block:: shell
:class: copyable
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
operator minio-operator 1 2023-11-01 15:49:54.539724775 -0400 EDT deployed operator-5.0.x v5.0.x
#. Update the Operator Repository
Use ``helm repo update minio-operator`` to update the MinIO Operator repo.
If you set a different alias for the MinIO Operator repository, specify that to the command.
You can use ``helm repo list`` to review your installed repositories.
Use ``helm search`` to check the latest available chart version after updating the Operator Repo:
.. code-block:: shell
:class: copyable
helm search repo minio-operator
The response should resemble the following:
.. code-block:: shell
:class: copyable
:substitutions:
NAME CHART VERSION APP VERSION DESCRIPTION
minio-operator/minio-operator 4.3.7 v4.3.7 A Helm chart for MinIO Operator
minio-operator/operator |operator-version-stable| v|operator-version-stable| A Helm chart for MinIO Operator
minio-operator/tenant |operator-version-stable| v|operator-version-stable| A Helm chart for MinIO Operator
The ``minio-operator/minio-operator`` is a legacy chart and should **not** be installed under normal circumstances.
#. Run ``helm upgrade``
Helm uses the latest chart to upgrade the MinIO Operator:
.. code-block:: shell
:class: copyable
helm upgrade -n minio-operator \
operator minio-operator/operator
If you installed the MinIO Operator to a different namespace, specify that to the ``-n`` argument.
If you used a different installation name from ``operator``, replace the value above with the installation name.
The command results should return success with a bump in the ``REVISION`` value.
#. Validate the Operator upgrade
You can check the Operator version by reviewing the object specification for an Operator Pod using a previous step.
.. include:: /includes/common/common-k8s-connect-operator-console.rst
You can check the Operator version by reviewing the object specification for an Operator Pod using a previous step.
.. include:: /includes/common/common-k8s-connect-operator-console.rst
Upgrade MinIO Operator 4.2.3 through 4.5.7 to 4.5.8
---------------------------------------------------

92
source/operations/install-deploy-manage/upgrade-minio-tenant.rst
View File

@ -10,27 +10,21 @@ Upgrade a MinIO Tenant
:local:
:depth: 1
Prerequisites
-------------
.. _minio-upgrade-tenant-plugin:
MinIO Kubernetes Operator and Plugin
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Upgrade the Tenant using the MinIO Kubernetes Plugin
----------------------------------------------------
This procedures on this page *requires* a valid installation of the MinIO Kubernetes Operator and assumes the local host has a matching installation of the MinIO Kubernetes Operator.
This procedure assumes the latest stable Operator and Plugin, version |operator-version-stable|.
The following procedure upgrades the MinIO Operator using the :mc:`kubectl minio tenant upgrade` command.
See :ref:`deploy-operator-kubernetes` for complete documentation on deploying the MinIO Operator.
If you deployed the Tenant using :ref:`Helm <deploy-tenant-helm>`, use the :ref:`minio-upgrade-tenant-helm` procedure instead.
Install the Plugin
~~~~~~~~~~~~~~~~~~
This procedure *requires* a valid installation of the MinIO Kubernetes Operator and assumes the local host has a matching installation of the MinIO Kubernetes Operator and plugin.
This procedure assumes the latest stable Operator version |operator-version-stable|.
.. include:: /includes/k8s/install-minio-kubectl-plugin.rst
Procedure (CLI)
---------------
This procedure documents upgrading pods running on a MinIO Tenant.
See :ref:`deploy-operator-kubernetes` for complete documentation on deploying the MinIO Operator.
.. important::
@ -76,3 +70,73 @@ This may result in downtime until the upgrade process completes.
- Replace ``TENANT_NAMESPACE`` with the namespace of the Tenant.
See MinIO's `DockerHub Repository <https://hub.docker.com/r/minio/minio>`__ for a list of available release tags.
.. _minio-upgrade-tenant-helm:
Upgrade the Tenant using the MinIO Helm Chart
---------------------------------------------
This procedure upgrades an existing MinIO Tenant using Helm Charts.
If you deployed the Tenant using the :ref:`MinIO Kubernetes Plugin <minio-k8s-deploy-minio-tenant>`, use the :ref:`minio-upgrade-tenant-plugin` procedure instead.
1. Verify the existing MinIO Tenant installation.
Use ``kubectl get all -n TENANT_NAMESPACE`` to verify the health and status of all Tenant pods and services.
Use the ``helm list`` command to view the installed charts in the namespace:
.. code-block:: shell
:class: copyable
helm list -n TENANT_NAMESPACE
The result should resemble the following:
.. code-block:: shell
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
CHART_NAME TENANT_NAMESPACE 1 2023-11-01 15:49:58.810412732 -0400 EDT deployed tenant-5.0.x v5.0.x
#. Update the Operator Repository
Use ``helm repo update minio-operator`` to update the MinIO Operator repo.
If you set a different alias for the MinIO Operator repository, specify that to the command.
You can use ``helm repo list`` to review your installed repositories.
Use ``helm search`` to check the latest available chart version after updating the Operator Repo:
.. code-block:: shell
:class: copyable
helm search repo minio-operator
The response should resemble the following:
.. code-block:: shell
:class: copyable
:substitutions:
NAME CHART VERSION APP VERSION DESCRIPTION
minio-operator/minio-operator 4.3.7 v4.3.7 A Helm chart for MinIO Operator
minio-operator/operator |operator-version-stable| v|operator-version-stable| A Helm chart for MinIO Operator
minio-operator/tenant |operator-version-stable| v|operator-version-stable| A Helm chart for MinIO Operator
The ``minio-operator/minio-operator`` is a legacy chart and should **not** be installed under normal circumstances.
#. Run ``helm upgrade``
Helm uses the latest chart to upgrade the Tenant:
.. code-block:: shell
:class: copyable
helm upgrade -n minio-tenant \
CHART_NAME minio-operator/tenant
The command results should return success with a bump in the ``REVISION`` value.
#. Validate the Tenant Upgrade
Check that all services and pods are online and functioning normally.