Skip to main content
Une version plus récente de ce produit est disponible.
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

Contributeurs
PDF

Pour mettre à niveau Astra Control Center, téléchargez le pack d'installation depuis le site de support NetApp et suivez ces instructions pour mettre à niveau les composants d'Astra Control Center dans votre environnement. 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
Description de la tâche

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

Important N'exécutez pas la commande suivante pendant l'intégralité du processus de mise à niveau pour éviter de supprimer toutes les pods Astra Control Center : kubectl delete -f astra_control_center_operator_deploy.yaml
Astuce 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.
Remarque Les commandes Podman peuvent être utilisées à la place des commandes Docker si vous utilisez le Podman de Red Hat au lieu de Docker Engine.

Téléchargez le pack Astra Control Center

  1. Téléchargez le pack de mise à niveau Astra Control Center (astra-control-center-[version].tar.gz) Du site de support https:mysupport.netapp.com/site/products/all/details/astra-control-center/downloads-tab[NetApp^].

  2. (Facultatif) utilisez la commande suivante pour vérifier la signature du pack :

    openssl dgst -sha256 -verify AstraControlCenter-public.pub -signature astra-control-center-[version].tar.gz.sig astra-control-center-[version].tar.gz

Déballez le bundle et modifiez le répertoire

  1. Extraire les images :

    tar -vxzf astra-control-center-[version].tar.gz

Ajoutez les images à votre registre local

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

Docker

  1. Passez au répertoire Astra :

    cd acc

  2. placez les images du paquet dans le répertoire d'images Astra Control Center dans votre registre local. Exécutez les substitutions suivantes avant d'exécuter la commande :

    • Remplacez BUNDLE_FILE par le nom du fichier bundle Astra Control (par exemple, acc.manifest.yaml).

    • Remplacez MON_REGISTRE par l'URL du référentiel Docker.

    • Remplacez MON_REGISTRE_UTILISATEUR par le nom d'utilisateur.

    • Remplacez MON_REGISTRY_TOKEN par un jeton autorisé pour le Registre.

      kubectl astra packages push-images -m BUNDLE_FILE -r MY_REGISTRY -u MY_REGISTRY_USER -p MY_REGISTRY_TOKEN
Podman

  1. Connectez-vous à votre registre :

    podman login [your_registry_path]

  2. Exécutez le script suivant, en procédant à la substitution <YOUR_REGISTRY> comme indiqué dans les commentaires :

    # You need to be at the root of the tarball.
# You should see these files to confirm correct location:
#   acc.manifest.yaml
#   acc/

# Replace <YOUR_REGISTRY> with your own registry (e.g registry.customer.com or registry.customer.com/testing, etc..)
export REGISTRY=<YOUR_REGISTRY>
export PACKAGENAME=acc
export PACKAGEVERSION=22.08.1-26
export DIRECTORYNAME=acc
for astraImageFile in $(ls ${DIRECTORYNAME}/images/*.tar) ; do
  # Load to local cache
  astraImage=$(podman load --input ${astraImageFile} | sed 's/Loaded image(s): //')

  # Remove path and keep imageName.
  astraImageNoPath=$(echo ${astraImage} | sed 's:.*/::')

  # Tag with local image repo.
  podman tag ${astraImage} ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}

  # Push to the local repo.
  podman push ${REGISTRY}/netapp/astra/${PACKAGENAME}/${PACKAGEVERSION}/${astraImageNoPath}
done

Poser le conducteur du centre de commande Astra mis à jour

  1. Modifier le répertoire :

    cd manifests

  2. 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

    1. Si vous utilisez un registre qui nécessite une authentification, remplacez la ligne par défaut de imagePullSecrets: [] avec les éléments suivants :

      imagePullSecrets:
- name: <name_of_secret_with_creds_to_local_registry>

    2. 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.

    3. Changer [your_registry_path] pour le acc-operator-controller-manager image dans le chemin du registre où vous avez poussé les images dans un étape précédente.

    4. 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
  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
        command:
        - /manager
        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
      imagePullSecrets: []

  3. 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

  4. Vérifiez que les pods sont en cours d'exécution :

    kubectl get pods -n netapp-acc-operator

Mettez à niveau Astra Control Center

  1. Modifier la ressource personnalisée Astra Control Center (CR) (astra_control_center_min.yaml) Et modifiez la version Astra (astraVersion intérieur de Spec) numéro au plus tard :

    kubectl edit acc -n [netapp-acc or custom namespace]
    Remarque Votre chemin de registre doit correspondre au chemin du registre où vous avez poussé les images dans un étape précédente.

  2. Ajoutez les lignes suivantes dans additionalValues intérieur de Spec Dans le CR Astra Control Center :

    additionalValues:
    nautilus:
      startupProbe:
        periodSeconds: 30
        failureThreshold: 600

  3. Effectuez l'une des opérations suivantes :

    1. Si vous n'avez pas votre propre IngresController ou entrée et que vous avez utilisé le Centre de contrôle Astra avec sa passerelle Trafik comme service de type LoadBalancer et que vous souhaitez poursuivre cette configuration, spécifiez un autre champ ingressType (s'il n'est pas déjà présent) et réglez-le sur AccTraefik.

      ingressType: AccTraefik

    2. Si vous voulez passer au déploiement d'entrée générique par défaut du centre de contrôle Astra, fournissez votre propre configuration d'entrée/contrôleur IngressController (avec terminaison TLS, etc.), ouvrez un itinéraire vers le centre de contrôle Astra, et définissez ingressType à Generic.

      ingressType: Generic
      Astuce Si vous omettez le champ, le processus devient le déploiement générique. Si vous ne voulez pas le déploiement générique, assurez-vous d'ajouter le champ.

  4. (Facultatif) Vérifiez que les modules se terminent et deviennent disponibles à nouveau :

    watch kubectl get po -n [netapp-acc or custom namespace]

  5. Attendez que les conditions d'état de l'Astra indiquent que la mise à niveau est terminée et prête :

    kubectl get -o yaml -n [netapp-acc or custom namespace] astracontrolcenters.astra.netapp.io astra

    Réponse :

    conditions:
  - lastTransitionTime: "2021-10-25T18:49:26Z"
    message: Astra is deployed
    reason: Complete
    status: "True"
    type: Ready
  - lastTransitionTime: "2021-10-25T18:49:26Z"
    message: Upgrading succeeded.
    reason: Complete
    status: "False"
    type: Upgrading

  6. Connectez-vous et vérifiez que tous les clusters et applications gérés sont toujours présents et protégés.

  7. Si l'opérateur n'a pas mis à jour le Cert-Manager, mettez à niveau les services tiers, puis.

Mise à niveau de services tiers (facultatif)

Les services tiers Traefik et Cert-Manager ne sont pas mis à niveau au cours des étapes de mise à niveau précédentes. Vous pouvez éventuellement les mettre à niveau à l'aide de la procédure décrite ici ou conserver les versions de service existantes si votre système l'exige.

  • Traefik: Par défaut, Astra Control Center gère le cycle de vie du déploiement Traefik. Réglage externalTraefik à false (Valeur par défaut) indique qu'aucun Traefik externe n'existe dans le système et que Traefik est installé et géré par Astra Control Center. Dans ce cas, externalTraefik est défini sur false.

    D'autre part, si vous avez votre propre déploiement Trafik, définissez externalTraefik à true. Dans ce cas, vous entretenez le déploiement et Astra Control Center ne mettra pas à niveau les CRD, sauf si shouldUpgrade est défini sur true.

  • Cert-Manager: Par défaut, Astra Control Center installe le cert-Manager (et les CRD) sauf si vous avez défini externalCertManager à true. Réglez shouldUpgrade à true Pour mettre à niveau les CRD d'Astra Control Center.

Traefik est mis à niveau si l'une des conditions suivantes est remplie :

  • ExternalTraefik : faux

  • ExternalTraefik: Vrai ET shouldUpgrade: Vrai.

Étapes

  1. Modifiez le acc CR :

    kubectl edit acc -n [netapp-acc or custom namespace]

  2. Modifiez le externalTraefik et le shouldUpgrade pour l'un ou l'autre true ou false au besoin.

    crds:
    externalTraefik: false
    externalCertManager: false
    shouldUpgrade: false

Vérifiez l'état du système

  1. Connectez-vous à Astra Control Center.

  2. Vérifiez que tous vos clusters et applications gérés sont toujours présents et protégés.

Configurer l'entrée pour l'équilibrage de charge

Vous pouvez configurer un objet d'entrée Kubernetes qui gère l'accès externe aux services, comme l'équilibrage de charge dans un cluster.

  • La mise à niveau par défaut utilise le déploiement d'entrée générique. Dans ce cas, vous devrez également configurer un contrôleur d'entrée ou une ressource d'entrée.

  • Si vous ne voulez pas un contrôleur d'entrée et voulez conserver ce que vous avez déjà, définissez ingressType à AccTraefik.

Remarque Pour plus de détails sur le type de service « LoadBalancer » et l'entrée, voir "De formation".

Les étapes diffèrent en fonction du type de contrôleur d'entrée utilisé :

  • Contrôleur d'entrée Nginx

  • Contrôleur d'entrée OpenShift

Ce dont vous avez besoin

  • Dans la spécification CR,

    • Si crd.externalTraefik est présent, il doit être réglé sur false OU

    • Si crd.externalTraefik est true, crd.shouldUpgrade devrait également être true.

  • Le requis "contrôleur d'entrée" doit déjà être déployé.

  • Le "classe d'entrée" correspondant au contrôleur d'entrée doit déjà être créé.

  • Vous utilisez des versions Kubernetes entre et comprenant v1.19 et v1.21.

Étapes du contrôleur d'entrée Nginx

  1. Utilisez le secret existant secure-testing-cert ou créez un secret de type[kubernetes.io/tls] Pour une clé privée TLS et un certificat dans netapp-acc (ou espace de noms personnalisé) comme décrit dans "Secrets TLS".

  2. Déployez une ressource entrée dans netapp-acc (ou espace de noms personnalisés) pour un schéma obsolète ou un nouveau schéma :

    1. Pour un schéma obsolète, suivez cet exemple :

      apiVersion: extensions/v1beta1
kind: IngressClass
metadata:
  name: ingress-acc
  namespace: [netapp-acc or custom namespace]
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  tls:
  - hosts:
    - <ACC address>
    secretName: [tls secret name]
  rules:
  - host: [ACC address]
    http:
      paths:
      - backend:
        serviceName: traefik
        servicePort: 80
        pathType: ImplementationSpecific

    2. Pour un nouveau schéma, suivez cet exemple :

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: netapp-acc-ingress
  namespace: [netapp-acc or custom namespace]
spec:
  ingressClassName: [class name for nginx controller]
  tls:
  - hosts:
    - <ACC address>
    secretName: [tls secret name]
  rules:
  - host: <ACC address>
    http:
      paths:
        - path:
          backend:
            service:
              name: traefik
              port:
                number: 80
          pathType: ImplementationSpecific
Étapes du contrôleur d'entrée OpenShift

  1. Procurez-vous votre certificat et obtenez les fichiers de clé, de certificat et d'autorité de certification prêts à l'emploi par la route OpenShift.

  2. Création de la route OpenShift :

    oc create route edge --service=traefik
--port=web -n [netapp-acc or custom namespace]
--insecure-policy=Redirect --hostname=<ACC address>
--cert=cert.pem --key=key.pem

Vérifiez la configuration de l'entrée

Vous pouvez vérifier la configuration de l'entrée avant de continuer.

  1. Assurez-vous que Traefik a changé en clusterIP De l'équilibreur de charge :

    kubectl get service traefik -n [netapp-acc or custom namespace]

  2. Vérifier les itinéraires dans Traefik :

    Kubectl get ingressroute ingressroutetls -n [netapp-acc or custom namespace]
-o yaml | grep "Host("
    Remarque Le résultat doit être vide.