La version française est une traduction automatique. La version anglaise prévaut sur la française en cas de divergence.

Mettez à niveau Astra Control Center

11/06/2023 Contributeurs

Pour mettre à niveau Astra Control Center, téléchargez le pack d’installation depuis le site de support NetApp et suivez ces instructions. Vous pouvez utiliser cette procédure pour mettre à niveau Astra Control Center dans des environnements connectés à Internet ou à air comprimé.

Avant de commencer

Avant de procéder à la mise à niveau, assurez-vous que votre environnement respecte toujours le "Configuration minimale requise pour le déploiement d’Astra Control Center". Votre environnement doit disposer des éléments suivants :

Version d’Astra Trident prise en charge
Details
Déterminez la version de Trident que vous exécutez :
kubectl get tridentversion -n trident
Reportez-vous à la section "Documentation Astra Trident" pour effectuer une mise à niveau à partir d’une ancienne version.

Vous devez effectuer une mise à niveau vers Astra Trident 22.10 * AVANT* pour la mise à niveau vers Kubernetes 1.25.
Distribution Kubernetes prise en charge
Details
Déterminez la version Kubernetes que vous exécutez :
kubectl get nodes -o wide
Ressources du cluster suffisantes
Details
Déterminer les ressources disponibles du cluster :
kubectl describe node <node name>
Registre que vous pouvez utiliser pour diffuser et télécharger des images Astra Control Center
Classe de stockage par défaut
Details
Déterminez votre classe de stockage par défaut :
kubectl get storageclass
Services d’API sains et disponibles
Details
Assurez-vous que tous les services API sont en état de santé et disponibles :
kubectl get apiservices
(OpenShift uniquement) opérateurs de cluster sains et disponibles
Details
S’assurer que tous les opérateurs du groupe d’instruments sont en état de fonctionnement et disponibles.
kubectl get clusteroperators

Dans le cadre de cette procédure, vous devrez le faire Si vous mettez à niveau Astra Control Center. Vous ne pouvez pas effectuer la mise à niveau vers des versions antérieures d’Astra Control Center à l’aide de cet opérateur mis à jour.

Description de la tâche

Le processus de mise à niveau d’Astra Control Center vous guide à travers les étapes de haut niveau suivantes :

Déconnectez-vous de l’interface utilisateur de l’Astra Control Center avant de commencer la mise à niveau.

Téléchargez et extrayez Astra Control Center
Retirez le plug-in NetApp Astra kubectl et réinstallez-le
Ajoutez les images à votre registre local
Poser le conducteur du centre de commande Astra mis à jour
Mettez à niveau Astra Control Center
Vérifiez l’état du système

Ne supprimez pas l’opérateur du centre de contrôle Astra (par exemple, kubectl delete -f astra_control_center_operator_deploy.yaml) À tout moment pendant la mise à niveau ou l’opération Astra Control Center pour éviter de supprimer des modules.

Effectuez les mises à niveau dans une fenêtre de maintenance lorsque les planifications, les sauvegardes et les snapshots ne sont pas en cours d’exécution.

Téléchargez et extrayez Astra Control Center

Accédez au "Page de téléchargement des produits Astra Control Center" Sur le site de support NetApp. Vous pouvez sélectionner la dernière version ou une autre version souhaitée dans le menu déroulant.
(Recommandé mais facultatif) Téléchargez le lot de certificats et de signatures pour Astra Control Center (astra-control-center-certs-[version].tar.gz) pour vérifier la signature du paquet.
Développez pour plus d’informations
tar -vxzf astra-control-center-certs-[version].tar.gz
openssl dgst -sha256 -verify certs/AstraControlCenter-public.pub -signature certs/astra-control-center-[version].tar.gz.sig astra-control-center-[version].tar.gz
La sortie s’affiche Verified OK une fois la vérification terminée.
Extraire les images du pack Astra Control Center :
```
tar -vxzf astra-control-center-[version].tar.gz
```

Retirez le plug-in NetApp Astra kubectl et réinstallez-le

Vous pouvez utiliser le plug-in de ligne de commande NetApp Astra kubectl pour envoyer les images vers un référentiel Docker local.

Déterminez si le plug-in est installé :
```
kubectl astra
```
Faites l’une des actions suivantes :
- Si le plug-in est installé, la commande doit renvoyer l’aide du plug-in kubectl et vous pouvez supprimer la version existante de kubectl-astra : delete /usr/local/bin/kubectl-astra.
- Si la commande renvoie une erreur, le plug-in n’est pas installé et vous pouvez passer à l’étape suivante pour l’installer.
Installez le plug-in :
1. Répertoriez les binaires NetApp Astra kubectl disponibles et notez le nom du fichier dont vous avez besoin pour votre système d’exploitation et votre architecture de processeur :
  
  La bibliothèque de plug-ins kubectl fait partie du bundle tar et est extraite dans le dossier kubectl-astra.
```
ls kubectl-astra/
```
1. Déplacez le bon binaire dans le chemin actuel et renommez-le kubectl-astra:
  cp kubectl-astra/<binary-name> /usr/local/bin/kubectl-astra

Ajoutez les images à votre registre local

Suivez la séquence d’étapes appropriée pour votre moteur de mise en conteneurs :

Docker

Accédez au répertoire racine du tarball. Vous devriez voir le acc.manifest.bundle.yaml et les répertoires suivants :

acc/
kubectl-astra/
acc.manifest.bundle.yaml
Envoyez les images du package dans le répertoire d’images Astra Control Center vers votre registre local. Effectuez les remplacements suivants avant d’exécuter le push-images commande :
- Remplacez <BUNDLE_FILE> par le nom du fichier bundle Astra Control (acc.manifest.bundle.yaml).
- Remplacer <MY_FULL_REGISTRY_PATH> par l’URL du référentiel Docker, par exemple "https://<docker-registry>".
- Remplacez <MY_REGISTRY_USER> par le nom d’utilisateur.
- Remplacez <MY_REGISTRY_TOKEN> par un jeton autorisé pour le registre.
  kubectl astra packages push-images -m <BUNDLE_FILE> -r <MY_FULL_REGISTRY_PATH> -u <MY_REGISTRY_USER> -p <MY_REGISTRY_TOKEN>

Podman

Accédez au répertoire racine du tarball. Vous devriez voir ce fichier et ce répertoire:

acc.manifest.bundle.yaml
acc/
Connectez-vous à votre registre :
```
podman login <YOUR_REGISTRY>
```

Préparez et exécutez l’un des scripts suivants qui est personnalisé pour la version de Podman que vous utilisez. Remplacez <MY_FULL_REGISTRY_PATH> par l’URL de votre référentiel qui inclut tous les sous-répertoires.

Podman 4

export REGISTRY=<MY_FULL_REGISTRY_PATH>
export PACKAGENAME=acc
export PACKAGEVERSION=23.07.0-25
export DIRECTORYNAME=acc
for astraImageFile in $(ls ${DIRECTORYNAME}/images/*.tar) ; do
astraImage=$(podman load --input ${astraImageFile} | sed 's/Loaded image: //')
astraImageNoPath=$(echo ${astraImage} | sed 's:.*/::')
podman tag ${astraImageNoPath} ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
podman push ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
done

Podman 3

export REGISTRY=<MY_FULL_REGISTRY_PATH>
export PACKAGENAME=acc
export PACKAGEVERSION=23.07.0-25
export DIRECTORYNAME=acc
for astraImageFile in $(ls ${DIRECTORYNAME}/images/*.tar) ; do
astraImage=$(podman load --input ${astraImageFile} | sed 's/Loaded image: //')
astraImageNoPath=$(echo ${astraImage} | sed 's:.*/::')
podman tag ${astraImageNoPath} ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
podman push ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
done

Le chemin d’accès à l’image que le script crée doit ressembler aux éléments suivants, selon la configuration de votre registre :

https://netappdownloads.jfrog.io/docker-astra-control-prod/netapp/astra/acc/23.07.0-25/image:version

Poser le conducteur du centre de commande Astra mis à jour

Modifier le répertoire :
```
cd manifests
```

Modifiez le yaml de déploiement de l’opérateur Astra Control Center (astra_control_center_operator_deploy.yaml) pour faire référence à votre registre local et à votre secret.

vim astra_control_center_operator_deploy.yaml

Si vous utilisez un registre qui nécessite une authentification, remplacez ou modifiez la ligne par défaut de imagePullSecrets: [] avec les éléments suivants :
```
imagePullSecrets: [{name: astra-registry-cred}]
```
Changer ASTRA_IMAGE_REGISTRY pour le kube-rbac-proxy image dans le chemin du registre où vous avez poussé les images dans un étape précédente.
Changer ASTRA_IMAGE_REGISTRY pour le acc-operator image dans le chemin du registre où vous avez poussé les images dans un étape précédente.

Ajoutez les valeurs suivantes à la env section :

- name: ACCOP_HELM_UPGRADETIMEOUT
  value: 300m

Exemple astra_control_Center_Operator_Deploy.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    control-plane: controller-manager
  name: acc-operator-controller-manager
  namespace: netapp-acc-operator
spec:
  replicas: 1
  selector:
    matchLabels:
      control-plane: controller-manager
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        control-plane: controller-manager
    spec:
      containers:
      - args:
        - --secure-listen-address=0.0.0.0:8443
        - --upstream=http://127.0.0.1:8080/
        - --logtostderr=true
        - --v=10
        image: ASTRA_IMAGE_REGISTRY/kube-rbac-proxy:v4.8.0
        name: kube-rbac-proxy
        ports:
        - containerPort: 8443
          name: https
      - args:
        - --health-probe-bind-address=:8081
        - --metrics-bind-address=127.0.0.1:8080
        - --leader-elect
        env:
        - name: ACCOP_LOG_LEVEL
          value: "2"
        - name: ACCOP_HELM_UPGRADETIMEOUT
          value: 300m
        image: ASTRA_IMAGE_REGISTRY/acc-operator:23.07.25
        imagePullPolicy: IfNotPresent
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8081
          initialDelaySeconds: 15
          periodSeconds: 20
        name: manager
        readinessProbe:
          httpGet:
            path: /readyz
            port: 8081
          initialDelaySeconds: 5
          periodSeconds: 10
        resources:
          limits:
            cpu: 300m
            memory: 750Mi
          requests:
            cpu: 100m
            memory: 75Mi
        securityContext:
          allowPrivilegeEscalation: false
      imagePullSecrets: []
      securityContext:
        runAsUser: 65532
      terminationGracePeriodSeconds: 10

Installez le nouveau conducteur du centre de contrôle Astra :

kubectl apply -f astra_control_center_operator_deploy.yaml

Exemple de réponse :

namespace/netapp-acc-operator unchanged
customresourcedefinition.apiextensions.k8s.io/astracontrolcenters.astra.netapp.io configured
role.rbac.authorization.k8s.io/acc-operator-leader-election-role unchanged
clusterrole.rbac.authorization.k8s.io/acc-operator-manager-role configured
clusterrole.rbac.authorization.k8s.io/acc-operator-metrics-reader unchanged
clusterrole.rbac.authorization.k8s.io/acc-operator-proxy-role unchanged
rolebinding.rbac.authorization.k8s.io/acc-operator-leader-election-rolebinding unchanged
clusterrolebinding.rbac.authorization.k8s.io/acc-operator-manager-rolebinding configured
clusterrolebinding.rbac.authorization.k8s.io/acc-operator-proxy-rolebinding unchanged
configmap/acc-operator-manager-config unchanged
service/acc-operator-controller-manager-metrics-service unchanged
deployment.apps/acc-operator-controller-manager configured

Vérifiez que les pods sont en cours d’exécution :
```
kubectl get pods -n netapp-acc-operator
```