Skip to main content
È disponibile una versione più recente di questo prodotto.
La versione in lingua italiana fornita proviene da una traduzione automatica. Per eventuali incoerenze, fare riferimento alla versione in lingua inglese.

Aggiornare Astra Control Center

Collaboratori

Per aggiornare Astra Control Center, scaricare il pacchetto di installazione dal NetApp Support Site e completare queste istruzioni. È possibile utilizzare questa procedura per aggiornare Astra Control Center in ambienti connessi a Internet o con connessione ad aria.

Di cosa hai bisogno
  • Prima di eseguire l'aggiornamento, fare riferimento a. "Requisiti dell'ambiente operativo" Per garantire che l'ambiente soddisfi ancora i requisiti minimi per l'implementazione di Astra Control Center. L'ambiente deve avere i seguenti requisiti:

    • Una versione supportata di Astra Trident per determinare la versione in esecuzione, eseguire il seguente comando sul proprio Astra Control Center esistente:

      kubectl get tridentversion -n trident

      Fare riferimento a. "Documentazione di Astra Trident" per eseguire l'aggiornamento da una versione precedente.

    Attenzione Devi eseguire l'aggiornamento ad Astra Trident 22.10 * PRIOR* per eseguire l'aggiornamento a Kubernetes 1.25.
    • Una distribuzione Kubernetes supportata per determinare la versione in esecuzione, eseguire il seguente comando sul proprio Astra Control Center esistente: kubectl get nodes -o wide

    • Risorse cluster sufficienti per determinare le risorse del cluster, eseguire il seguente comando nel cluster Astra Control Center esistente: kubectl describe node <node name>

    • Un registro che puoi utilizzare per inviare e caricare le immagini di Astra Control Center

    • Una classe di storage predefinita per determinare la classe di storage predefinita, eseguire il seguente comando per Astra Control Center esistente: kubectl get storageclass

  • (Solo OpenShift) assicurarsi che tutti gli operatori del cluster siano in buono stato e disponibili.

    kubectl get clusteroperators
  • Assicurarsi che tutti i servizi API siano in buono stato e disponibili.

    kubectl get apiservices
  • Disconnettersi dall'interfaccia utente di Astra Control Center prima di iniziare l'aggiornamento.

A proposito di questa attività

Il processo di aggiornamento di Astra Control Center ti guida attraverso le seguenti fasi di alto livello:

Importante Non eliminare l'operatore di Astra Control Center (ad esempio, kubectl delete -f astra_control_center_operator_deploy.yaml) In qualsiasi momento durante l'aggiornamento o l'operazione di Astra Control Center per evitare di eliminare i pod.
Suggerimento Eseguire gli aggiornamenti in una finestra di manutenzione quando pianificazioni, backup e snapshot non sono in esecuzione.

Scarica ed estrai Astra Control Center

  1. Accedere alla "Pagina di download del prodotto Astra Control Center" Sul sito di supporto NetApp. È possibile selezionare la versione più recente o un'altra versione desiderata dal menu a discesa.

  2. Scarica il bundle contenente Astra Control Center (astra-control-center-[version].tar.gz).

  3. (Consigliato ma opzionale) Scarica il bundle di certificati e firme per Astra Control Center (astra-control-center-certs-[version].tar.gz) per verificare la firma del bundle:

    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

    Viene visualizzato l'output Verified OK una volta completata la verifica.

  4. Estrarre le immagini dal bundle Astra Control Center:

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

Rimuovere il plug-in NetApp Astra kubectl e installarlo di nuovo

Il plug-in della riga di comando Astra kubectl di NetApp consente di risparmiare tempo nell'esecuzione delle attività più comuni associate all'implementazione e all'aggiornamento di Astra Control Center.

  1. Determinare se il plug-in è installato:

    kubectl astra
  2. Eseguire una delle seguenti operazioni:

    • Se il plugin è installato, il comando dovrebbe restituire la guida del plugin kubectl. Per rimuovere una versione esistente di kubectl-astra, eseguire questo comando: delete /usr/local/bin/kubectl-astra.

    • Se il comando restituisce un errore, il plug-in non è installato ed è possibile procedere con la fase successiva per installarlo.

  3. Installare il plug-in:

    1. Elencare i binari del plugin NetApp Astra kubectl disponibili e annotare il nome del file necessario per il sistema operativo e l'architettura della CPU:

      Nota La libreria di plugin kubectl fa parte del bundle tar e viene estratta nella cartella kubectl-astra.
    ls kubectl-astra/
    1. Spostare il binario corretto nel percorso corrente e rinominarlo kubectl-astra:

      cp kubectl-astra/<binary-name> /usr/local/bin/kubectl-astra

Aggiungere le immagini al registro locale

  1. Completare la sequenza di passaggi appropriata per il motore dei container:

Docker
  1. Passare alla directory root del tarball. Vengono visualizzati il file e la directory seguenti:

    acc.manifest.bundle.yaml
    acc/

  2. Trasferire le immagini del pacchetto nella directory delle immagini di Astra Control Center nel registro locale. Eseguire le seguenti sostituzioni prima di eseguire push-images comando:

    • Sostituire <BUNDLE_FILE> con il nome del file bundle di controllo Astra (acc.manifest.bundle.yaml).

    • Sostituire <MY_FULL_REGISTRY_PATH> con l'URL del repository Docker; ad esempio, "https://<docker-registry>".

    • Sostituire <MY_REGISTRY_USER> con il nome utente.

    • Sostituire <MY_REGISTRY_TOKEN> con un token autorizzato per il registro.

      kubectl astra packages push-images -m <BUNDLE_FILE> -r <MY_FULL_REGISTRY_PATH> -u <MY_REGISTRY_USER> -p <MY_REGISTRY_TOKEN>
Podman
  1. Passare alla directory root del tarball. Vengono visualizzati il file e la directory seguenti:

    acc.manifest.bundle.yaml
    acc/

  2. Accedere al Registro di sistema:

    podman login <YOUR_REGISTRY>
  3. Preparare ed eseguire uno dei seguenti script personalizzato per la versione di Podman utilizzata. Sostituire <MY_FULL_REGISTRY_PATH> con l'URL del repository che include le sottodirectory.

    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
    Nota Il percorso dell'immagine creato dallo script deve essere simile al seguente, a seconda della configurazione del Registro di sistema: https://netappdownloads.jfrog.io/docker-astra-control-prod/netapp/astra/acc/22.11.0-82/image:version

Installare l'operatore Astra Control Center aggiornato

  1. Modificare la directory:

    cd manifests
  2. Modificare l'yaml di implementazione dell'operatore di Astra Control Center (astra_control_center_operator_deploy.yaml) per fare riferimento al registro locale e al segreto.

    vim astra_control_center_operator_deploy.yaml
    1. Se si utilizza un registro che richiede l'autenticazione, sostituire o modificare la riga predefinita di imagePullSecrets: [] con i seguenti elementi:

      imagePullSecrets:
      - name: <astra-registry-cred_or_custom_name_of_secret>
    2. Cambiare [your_registry_path] per kube-rbac-proxy al percorso del registro in cui sono state inviate le immagini in a. passaggio precedente.

    3. Cambiare [your_registry_path] per acc-operator al percorso del registro in cui sono state inviate le immagini in a. passaggio precedente.

    4. Aggiungere i seguenti valori a env sezione:

      - 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
  3. Installare l'operatore Astra Control Center aggiornato:

    kubectl apply -f astra_control_center_operator_deploy.yaml

    Esempio di risposta:

    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. Verificare che i pod siano in esecuzione:

    kubectl get pods -n netapp-acc-operator

Aggiornare Astra Control Center

  1. Modificare la risorsa personalizzata Astra Control Center (CR):

    kubectl edit AstraControlCenter -n [netapp-acc or custom namespace]
  2. Modificare il numero di versione di Astra (astraVersion all'interno di Spec) alla versione alla quale si sta eseguendo l'aggiornamento:

    spec:
      accountName: "Example"
      astraVersion: "[Version number]"
  3. Verificare che il percorso del Registro di sistema dell'immagine corrisponda al percorso del Registro di sistema in cui sono state inviate le immagini in passaggio precedente. Aggiornare imageRegistry all'interno di Spec se il registro di sistema è stato modificato dall'ultima installazione.

      imageRegistry:
        name: "[your_registry_path]"
  4. Aggiungere quanto segue al CRDs configurazione all'interno di Spec:

    crds:
      shouldUpgrade: true
  5. Aggiungere le seguenti righe all'interno di additionalValues all'interno di Spec In Astra Control Center CR:

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

    Dopo aver salvato e chiuso l'editor di file, le modifiche verranno applicate e l'aggiornamento avrà inizio.

  6. (Facoltativo) verificare che i pod terminino e diventino nuovamente disponibili:

    watch kubectl get pods -n [netapp-acc or custom namespace]
  7. Attendere che le condizioni di stato di Astra Control indichino che l'aggiornamento è completo e pronto (True):

    kubectl get AstraControlCenter -n [netapp-acc or custom namespace]

    Risposta:

    NAME    UUID                                      VERSION     ADDRESS         READY
    astra   9aa5fdae-4214-4cb7-9976-5d8b4c0ce27f      22.11.0-82  10.111.111.111  True
    Nota Per monitorare lo stato dell'aggiornamento durante l'operazione, eseguire il seguente comando: kubectl get AstraControlCenter -o yaml -n [netapp-acc or custom namespace]
    Nota Per esaminare i registri dell'operatore di Astra Control Center, eseguire il seguente comando:
    kubectl logs deploy/acc-operator-controller-manager -n netapp-acc-operator -c manager -f

Verificare lo stato del sistema

  1. Accedere ad Astra Control Center.

  2. Verificare che la versione sia stata aggiornata. Consultare la pagina supporto nell'interfaccia utente.

  3. Verificare che tutti i cluster e le applicazioni gestiti siano ancora presenti e protetti.