Questa pagina documenta la versione 18.3.0 di AlloyDB Omni utilizzando l'opzione di deployment orchestratore RPM. Scegli un'altra opzione di deployment.

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Aggiorna i componenti del cluster dell'orchestratore RPM

Seleziona una versione della documentazione:

Questa pagina descrive come aggiornare i pacchetti software del cluster di database AlloyDB Omni, le configurazioni delle risorse e l'orchestratore RPM negli ambienti Red Hat Enterprise Linux (RHEL).

Prima di iniziare

Assicurati di avere il file di specifica del deployment, deployment_spec.yaml, che contiene tutti i dettagli dei componenti dei nodi e dei cluster.

Eseguire l'upgrade dell'orchestratore

L'orchestratore gestisce i cluster di database. Devi eseguire l'upgrade dell'orchestratore sul nodo di controllo prima di eseguire l'upgrade degli altri componenti del cluster.

Ansible

Se gestisci la tua infrastruttura utilizzando i playbook di Ansible, completa i seguenti passaggi:

Controlla la versione installata della raccolta google.alloydbomni_orchestrator sul nodo di controllo eseguendo il seguente comando:
```
ansible-galaxy collection list | grep alloydbomni_orchestrator
```
Per sovrascrivere la versione esistente, scarica l'ultima release stabile del file tar della raccolta ed esegui un'installazione forzata:
```
ansible-galaxy collection install --force google-alloydbomni_orchestrator-NEW_VERSION.tar.gz
```
Sostituisci NEW_VERSION con la versione della nuova raccolta.

alloydbctl

Se utilizzi lo strumento a riga di comando alloydbctl, completa i seguenti passaggi:

Per controllare la versione del pacchetto installato dell'orchestratore RPM alloydbomni_orchestrator sul nodo di controllo, esegui il seguente comando:
```
rpm -q alloydbomni_orchestrator
```
Esegui l'upgrade del pacchetto software sul nodo di controllo utilizzando il gestore di pacchetti:
```
sudo dnf upgrade alloydbomni_orchestrator
```

Aggiornare i componenti del cluster utilizzando Ansible

Google consiglia di eseguire l'aggiornamento utilizzando il ruolo Ansible fornito.

Crea un playbook denominato update.yaml che faccia riferimento al ruolo update della raccolta dell'orchestratore. Devi impostare il valore del parametro update_action su update_rpm.

Per impostazione predefinita, il ruolo update aggiorna sia il piano di controllo sia il piano dati. Per aggiornare solo i componenti del piano di controllo o del piano dati, imposta il parametro dell'altro piano su false.
```
---
- hosts: all
  become: true
  vars:
    update_action: "update_rpm"
    ansible_user: SSH_USER
    ansible_ssh_private_key_file: PRIVATE_KEY_PATH
    update_control_plane: true # Optional argument if you want to only update data plane components
    update_data_plane: true # Optional argument if you want to only update control plane components
  roles:
    - role: google.alloydbomni_orchestrator.update
```
Sostituisci quanto segue:
- SSH_USER: il nome utente SSH che ha accesso ai nodi del cluster.
- PRIVATE_KEY_PATH: il percorso del file della chiave SSH privata.
- update_action: l'ambito dell'aggiornamento. Imposta questo valore su update_rpm.
- update_control_plane: facoltativo. Imposta su false per aggiornare solo i componenti del piano dati. Il valore predefinito è true.
- update_data_plane: facoltativo. Imposta su false per aggiornare solo i componenti del piano di controllo. Il valore predefinito è true.
Per eseguire un aggiornamento su tutti i nodi specificati, esegui il playbook con il file di inventario:
```
ansible-playbook -i DEPLOYMENT_SPEC update.yaml
```
Sostituisci DEPLOYMENT_SPEC con il percorso del file di specifica del deployment.

Assicurati che il file di specifica del deployment definisca la versione installata per ogni componente del cluster. Il ruolo di aggiornamento aggiorna i componenti in base alla configurazione delle versioni nel file di inventario:
- Se la versione di un componente corrisponde alla versione installata, il ruolo di aggiornamento non apporta modifiche a quel componente.
- Se modifichi la versione di un componente in una versione di destinazione specifica, il componente viene aggiornato a quella versione.
- Se lasci vuoto il campo della versione di un componente, il componente viene aggiornato all'ultima versione disponibile nel repository configurato.

Nota: se un aggiornamento del pacchetto non riesce durante un processo di orchestrazione attivato da Ansible, il ruolo Ansible dell'orchestratore di AlloyDB Omni utilizza l'integrità transazionale integrata per il ripristino. Prima che il ruolo Ansible esegua l'aggiornamento, acquisisce automaticamente le versioni dei pacchetti esistenti. Se l'aggiornamento non riesce, le strutture di blocco e di salvataggio del ruolo Ansible eseguono automaticamente il downgrade alla versione del pacchetto installata in precedenza. Nelle topologie ad alta affidabilità (HA), questo processo di ripristino ignora attentamente i nodi primari se i nodi di standby non riescono o esegue i failover HA se i nodi primari non riescono. In questo modo si contribuisce a mantenere la stabilità del cluster ed evitare tempi di inattività.

Aggiornare manualmente i componenti del cluster

Se non utilizzi l'orchestratore Ansible o se vuoi un controllo granulare sul processo di aggiornamento, puoi aggiornare manualmente i componenti RPM per ogni nodo del cluster. Ti consigliamo di eseguire gli aggiornamenti software durante il periodo di manutenzione pianificato.

Il processo di aggiornamento manuale prevede l'aggiornamento dei seguenti due piani:

Piano di controllo (componenti dell'orchestratore RPM): il piano di controllo è il livello che controlla e gestisce i cluster di database. In un deployment RPM, il piano di controllo include cluster_manager, node_manager ed etcd.
Piano dati (cluster di database): il piano dati contiene i componenti del cluster di database, incluso il motore del database AlloyDB Omni stesso, monitor, nonché servizi come pgBackRest, PgBouncer, keepalived e HAProxy. L'upgrade del piano dati applica gli aggiornamenti della versione del database, le patch di sicurezza e i miglioramenti delle prestazioni direttamente ai cluster di database.

Indipendentemente dall'architettura di riferimento, i passaggi per aggiornare il piano di controllo rimangono gli stessi. Devi aggiornare i componenti del piano di controllo prima di aggiornare il piano dati. I passaggi per aggiornare il piano dati variano in base all'architettura di deployment del database.

Per aggiornare un servizio o un pacchetto, segui questi passaggi:

Arresta il servizio:
```
sudo systemctl stop SERVICE
```
Esegui l'upgrade del pacchetto utilizzando uno dei seguenti comandi:
- Per eseguire l'aggiornamento all'ultima versione disponibile:
```
sudo dnf upgrade PACKAGE
```
- Per eseguire l'aggiornamento a una versione specifica:
```
sudo dnf upgrade PACKAGE-VERSION
```
Avvia il servizio:
```
sudo systemctl start SERVICE
```

Sostituisci quanto segue:

SERVICE: il nome del servizio da arrestare e avviare, ad esempio pgbouncer o keepalived.
PACKAGE: il nome del pacchetto da aggiornare, ad esempio pgbouncer o alloydbomni18.
VERSION: la versione del pacchetto di destinazione da installare, ad esempio 18.3.0 o 18.3.0-2.rhel9.

Aggiornare manualmente il piano di controllo

Per aggiornare il piano di controllo, segui questi passaggi sui nodi designati:

Per arrestare il gestore dei cluster su tutti i nodi del gestore dei cluster, esegui il seguente comando:

Nota: prima di aggiornare altri componenti del piano di controllo, arresta il gestore dei cluster su tutti i nodi del gestore dei cluster.
```
sudo systemctl stop alloydbomni_cluster_manager
```

Per aggiornare etcd su tutti i nodi DCS, esegui i seguenti comandi in sequenza:

sudo systemctl stop etcd
sudo dnf upgrade etcd
sudo systemctl start etcd

Per aggiornare il gestore dei nodi su tutti i nodi, esegui i seguenti comandi in sequenza:

sudo systemctl stop alloydbomni_node_manager
sudo dnf upgrade alloydbomni_node_manager
sudo systemctl start alloydbomni_node_manager

Dopo aver aggiornato i componenti del control plane, puoi aggiornare il gestore dei cluster su tutti i nodi del gestore dei cluster e riavviarlo, se necessario.
```
sudo dnf upgrade alloydbomni_cluster_manager
sudo systemctl start alloydbomni_cluster_manager
```

Aggiornare manualmente il piano dati

Per aggiornare il piano dati, aggiorna il database e i servizi di assistenza nell'ordine specificato per l'architettura di deployment. Per ogni servizio, devi seguire una sequenza rigorosa di arresto del servizio, upgrade del pacchetto e avvio del servizio.

Segui le istruzioni per il deployment in base all'architettura di riferimento.

Recupera lo stato del cluster utilizzando il comando alloydbctl get e imposta il formato di output su YAML:
```
alloydbctl get -d DEPLOYMENT_SPEC -t RESOURCE_TYPE -n CLUSTER_NAME -o yaml
```
Sostituisci quanto segue:
- RESOURCE_TYPE: il tipo di risorsa da ispezionare, ad esempio DBCluster.
- CLUSTER_NAME: il nome del cluster di database.
- DEPLOYMENT_SPEC: il percorso del file di specifica del deployment.
Nell'output YAML, prendi nota di instanceList nella sezione status.

Trova il nodo il cui ruolo è impostato su Primary. Tutti gli altri nodi del database sono i nodi di standby.
Aggiorna prima tutti i componenti del piano dati in esecuzione sui nodi di standby e poi aggiorna questi componenti sul nodo primario. Segui questi passaggi per aggiornare i componenti del piano dati su ogni nodo.
1. Per aggiornare AlloyDB Omni, esegui i seguenti comandi in sequenza:
```
sudo systemctl stop alloydbomni18
sudo dnf upgrade alloydbomni18
sudo systemctl start alloydbomni18
```
  Nota: per eseguire il downgrade del nodo primario attivo in modo sicuro, esegui un failover. Per ulteriori informazioni, consulta Eseguire un failover.
2. Per aggiornare il monitor, esegui i seguenti comandi in sequenza:
```
sudo systemctl stop alloydbomni_monitor
sudo dnf upgrade alloydbomni_monitor
sudo systemctl start alloydbomni_monitor
```
3. Per aggiornare pgBackRest, esegui i seguenti comandi in sequenza:
```
sudo dnf upgrade pgbackrest
```
4. Per aggiornare PgBouncer, esegui i seguenti comandi in sequenza:
```
sudo systemctl stop pgbouncer
sudo dnf upgrade pgbouncer
sudo systemctl start pgbouncer
```
5. Per aggiornare keepalived, esegui i seguenti comandi in sequenza:
```
sudo systemctl stop keepalived
sudo dnf upgrade keepalived
sudo systemctl start keepalived
```
  Nota: se l'architettura di riferimento include i bilanciatori del carico, keepalived e pgbouncer vengono eseguiti sui nodi del bilanciatore del carico. Aggiorna prima questi componenti sui nodi del bilanciatore del carico di standby e poi aggiornali sul nodo del bilanciatore del carico primario.
6. Per aggiornare HAProxy, esegui i seguenti comandi in sequenza:
```
sudo systemctl stop haproxy
sudo dnf upgrade haproxy
sudo systemctl start haproxy
```