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

04/25/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é.

Ce dont vous avez besoin

Avant de procéder à la mise à niveau, reportez-vous à la section "De l’environnement opérationnel" Pour garantir que votre environnement respecte les exigences minimales en matière de déploiement d’Astra Control Center. Votre environnement doit disposer des éléments suivants :
- Une version d’Astra Trident prise en charge pour déterminer la version que vous exécutez, exécutez la commande suivante contre votre Astra Control Center existant :
  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.
- Une distribution Kubernetes prise en charge pour déterminer la version que vous exécutez, exécutez la commande suivante par rapport à votre Astra Control Center existant : kubectl get nodes -o wide
- Suffisamment de ressources de cluster pour déterminer les ressources de cluster, exécutez la commande suivante dans votre cluster Astra Control Center existant : kubectl describe node <node name>
- Registre que vous pouvez utiliser pour diffuser et télécharger des images Astra Control Center
- Une classe de stockage par défaut pour déterminer votre classe de stockage par défaut, exécutez la commande suivante avec votre Astra Control Center existant : kubectl get storageclass
(OpenShift uniquement) Assurez-vous que tous les opérateurs de cluster sont en bon état et disponibles.
```
kubectl get clusteroperators
```
Assurez-vous que tous les services API sont dans un état sain et disponibles.
```
kubectl get apiservices
```
Déconnectez-vous de l’interface utilisateur de l’Astra Control Center avant de commencer la mise à niveau.

Description de la tâche

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

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.
Téléchargez le pack contenant Astra Control Center (astra-control-center-[version].tar.gz).
(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 :
```
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

Le plug-in de ligne de commande NetApp Astra kubectl permet de gagner du temps lors de l’exécution des tâches courantes associées au déploiement et à la mise à niveau d’Astra Control Center.

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. Pour supprimer une version existante de kubectl-astra, exécutez la commande suivante : 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 ce fichier et ce répertoire:

acc.manifest.bundle.yaml
acc/
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=22.11.0-82
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=22.11.0-82
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/22.11.0-82/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_or_custom_name_of_secret>
```
Changer [your_registry_path] pour le kube-rbac-proxy image dans le chemin du registre où vous avez poussé les images dans un étape précédente.
Changer [your_registry_path] 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

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: [your_registry_path]/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: [your_registry_path]/acc-operator:[version x.y.z]
        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
```