Esegui la migrazione di un cluster PostgreSQL on-premise su Google Cloud

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo articolo spiega come eseguire la migrazione di un cluster PostgreSQL on-premise su Google Cloud. Questo approccio utilizza Pgbouncer come pool di connessioni per ridurre al minimo i tempi di inattività delle applicazioni e aiuta a configurare strumenti per il monitoraggio dei risultati. Questo articolo è rivolto agli amministratori e agli amministratori di sistema PostgreSQL che lavorano in un ambiente Linux.

Il seguente diagramma mostra un'istanza Pgbouncer posizionata di fronte a un master on-premise.

Architettura di un'istanza Pgbouncer posizionata di fronte a un master on-premise.

Con il pool di connessioni, i client vengono indirizzati a un nodo alternativo quando si verifica il failover in Google Cloud, senza dover rieseguire il deployment delle configurazioni delle applicazioni o apportare modifiche a livello di applicazione.

Il seguente diagramma illustra la migrazione.

Architettura della migrazione a Google Cloud.

Per eseguire la migrazione, arresta il master attuale e promuovi la replica subordinata Google Cloud al master. Pgbouncer reindirizza il traffico al nuovo nodo master su Google Cloud.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Puoi utilizzare il Calcolatore prezzi per generare una stima dei costi basata sull'utilizzo previsto.

Obiettivi

  • Configura PostgreSQL in Google Cloud.
  • Configura la replica su Compute Engine.
  • Distribuzione dei dati su una nuova istanza.
  • Configurare il cluster PostgreSQL su Google Cloud.
  • Passa al nuovo server.
  • Implementare il monitoraggio.

Prima di iniziare

Questo tutorial utilizza i comandi gcloud e gsutil, che puoi eseguire da un'istanza Cloud Shell avviata da Google Cloud Console. Se vuoi utilizzare gcloud e gsutil sulla tua workstation locale, installa Google Cloud CLI. Il tutorial mostra come eseguire i comandi in Cloud Shell; se utilizzi l'interfaccia a riga di comando gcloud sulla workstation, modifica le istruzioni di conseguenza.

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Attiva l'API Compute Engine.

    Abilita l'API

  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Attiva l'API Compute Engine.

    Abilita l'API

Configurazione dell'ambiente

Per iniziare, esegui le attività seguenti:

  • Configura PostgreSQL in Google Cloud.
  • Configura la replica su Compute Engine.

Quindi, esegui il seed dei dati in una nuova istanza prima di iniziare a replicare il master.

Configurare PostgreSQL in Google Cloud

Segui i passaggi in Come configurare PostgreSQL per l'alta disponibilità e la replica con hot standby per configurare PostgreSQL su Google Cloud in pochi minuti. Configura PostgreSQL su un'istanza di macchina virtuale Ubuntu su Compute Engine.

Configura la replica su Compute Engine

Segui i passaggi in Come configurare PostgreSQL su Google Compute Engine per configurare PostgreSQL per l'esecuzione in modalità hot standby su Compute Engine. Utilizzerai due istanze Compute Engine. Un'istanza eseguirà il server PostgreSQL principale e l'altra eseguirà il server in standby.

Anche se le proprietà per configurare PostgreSQL sono diverse tra un'istanza master e una subordinata, i file delle proprietà devono essere identici in modo da consentire failover senza interruzioni.

Un'istanza subordinata in un cluster PostgreSQL è indicata dalla presenza del file recovery.conf.

Nella maggior parte dei casi, è importante separare la directory dei dati per il database dal disco di avvio. In questo esempio sono archiviati file di database sotto un punto di montaggio su /database.

Utilizza i comandi seguenti per modificare il file postgresql.conf nell'istanza master per configurare la replica:

wal_level = 'hot_standby'
archive_mode = on
archive_command = 'test ! -f /postgresql/archivedir/%f && cp %p /postgresql/archivedir/%f'
max_wal_senders = 3
listen_addresses = '*'
wal_keep_segments = 8

Utilizza i comandi seguenti per modificare il file postgresql.conf nella replica:

hot_standby = on
standby_mode = on
primary_conninfo = 'host=${PRIMARY_IP} port=5432 user=repuser'

Puoi eseguire l'offset di parte del carico sul master se invii richieste Read alla replica.

Distribuzione dei dati

Poiché il database master contiene un log delle transazioni limitato, la maggior parte delle migrazioni PostgreSQL richiede che i dati vengano sottoposti a seed a una nuova istanza prima di poter iniziare la replica del master. Puoi importare i dati in uno dei seguenti modi:

  • Esegui il dump di un singolo database in uno script o in un file di archivio utilizzando Pg_dump.
  • Acquisisci una copia binaria di un cluster di database in esecuzione utilizzando Pg_basebackup.
  • Copia la cartella di dati nella replica utilizzando rsync.
  • Ripristina un backup precedente nella replica.

Di queste opzioni, ti consigliamo di ripristinare un backup precedente della replica. Questa soluzione non causa alcuna perdita nelle prestazioni durante il trasferimento di grandi volumi di dati e il cluster attuale può continuare a funzionare normalmente.

Dopo il seeding iniziale del database, puoi utilizzare il comando rsync per alimentare le modifiche apportate alla replica verificatasi dopo il backup; il comando sincronizza le directory dei dati tra le due istanze. Questo passaggio è importante se il backup non è rimasto indietro rispetto al master per recuperare la replica normale.

Configurazione del cluster PostgreSQL su Google Cloud

Puoi creare il cluster PostgreSQL utilizzando la replica a cascata. Innanzitutto, esegui la migrazione del database, come mostrato nel diagramma seguente.

È stata eseguita la migrazione dell'architettura dell'ambiente attuale a Google Cloud.

Esegui la migrazione del database

  1. Esegui un backup completo dal server master in esecuzione (label potrebbe essere una qualsiasi etichetta):

    echo "select pg_start_backup('label',true);" |sudo su - postgres -c psql
    sudo tar cvfz postgresql_AAAAMMDD.tar.gz $PGDATA
    

    $PGDATA è la directory di dati principale di PostgreSQL.

  2. Crea un bucket nel progetto Google Cloud denominato gs://pg-repo/.

  3. Trasferisci il backup nel bucket appena creato:

    master$ gsutil cp postgresql_AAAAMMDD.tar.gz gs://pg-repo/
    
  4. Trasferisci il file di backup al master Google Cloud:

    new_master$ gsutil cp gs://pg-repo/postgresql_AAAAMMDD.tar.gz
    
  5. Ripristina il file di backup nel master Google Cloud:

    new_master$ (cd / ; tar xvf postgresql_AAAAMMDD.tar.gz)
    
  6. Crea un file recovery.conf nella directory $PG_DATA che includa quanto segue:

    standby_mode     = 'on'
    primary_conninfo = 'port=5432 host=${running_master_ip} user=${replication_user} application_name=cloud_master'
    trigger_file     = '/tmp/failover.postgresql.5432'
    
  7. Avvia il servizio PostgreSQL:

    sudo service postgresql start
    
  8. Attendi che il server master di Google Cloud si sincronizzi con il master in esecuzione. Nel log puoi vedere:

    tail -f /var/log/postgresql/postgresql*log
    ...
    2018-09-22 17:59:54 UTC LOG:  consistent recovery state reached at 0/230000F0
    2018-09-22 17:59:54 UTC LOG:  database system is ready to accept read only connections
    ...
    

    Inoltre, puoi cercare in master pg_stat_replication per determinare se il nuovo subordinato (chiamato cloud_master) è connesso:

    postgres=# \x
    Expanded display is on.
    postgres=# select * from pg_stat_replication where application_name='cloud_master';
    -[ RECORD 1 ]----+------------------------------
    pid              | 16940
    usesysid         | 16402
    usename          | repmgr
    application_name | cloud_master
    ...
    

Crea un database subordinato

  1. Arresta il database e il server:

    sudo service postgresql stop
    sudo shutdown -h now
    
  2. Per verificare che il servizio sia stato interrotto, esegui questo comando:

    gcloud compute instances describe master-instance-name | grep status
    

    L'output mostra lo stato dell'istanza come TERMINATED:

    status: TERMINATED
    

    Quindi, crea snapshot del disco dati per semplificare la creazione di nuovi subordinati.

  3. In Google Cloud Console, vai alla pagina Snapshots.

    Vai alla pagina Snapshot

  4. Dal disco PostgreSQL, crea un nuovo snapshot.

  5. Avvia il server master Google Cloud.

  6. Vai alla pagina Istanze VM, fai clic su nome-istanza-master, quindi su Avvia.

    Il servizio PostgreSQL si avvia automaticamente.

  7. Per controllare, esegui il comando seguente:

    ps ax | grep postgres
    

    Il risultato dovrebbe essere simile al seguente:

     1398 ?     S   0:00 /usr/lib/postgresql/9.3/bin/postgres -D /var/lib/postgresql/9.3/main -c config_file=/etc/postgresql/9.3/main/postgresql.conf
     1454 ?     Ss  0:00 postgres: checkpointer process
     1455 ?     Ss  0:00 postgres: writer process
     1456 ?     Ss  0:00 postgres: wal writer process
     1457 ?     Ss  0:00 postgres: stats collector process
    
  8. In Google Cloud Console, vai alla pagina Istanze VM, quindi fai clic su Crea istanza.

  9. Per il disco di avvio, scegli Ubuntu 14.04.

  10. Fai clic su Management, dischi, networking, ssh-key e aggiungi un nuovo disco in base allo snapshot creato in precedenza.

  11. Avvia il nuovo server e monta il disco:

    sudo mkdir /database && sudo mount /dev/sdb1 /database
    
  12. Installa PostgreSQL:

    sudo apt-get install postgresql && sudo service postgresql stop
    
  13. Configurare la directory dei dati e i valori di replica. Copia il file postgresql.conf e il file pg_hba.conf dal master Google Cloud e modifica il file recovery.conf in modo da includere quanto segue:

    standby_mode = 'on'
    primary_conninfo = 'port=5432 host=${cloud_master_ip} user=${replication_user} application_name=cloud_slave_${identifier}'
    recovery_target_timeline = 'latest'
    
  14. Avvia il servizio PostgreSQL con il nuovo file di configurazione, che punta al master Google Cloud:

    sudo service postgresql restart
    
  15. Verifica che il servizio sia in esecuzione:

    ps ax | grep postgres
    
  16. Controlla il server master Google Cloud con questa query:

    postgres=# \x
    Expanded display is on.
    postgres=# select * from pg_stat_replication where application_name like 'cloud_slave%';
    -[ RECORD 1 ]----+-----------------------------
    pid              | 2466
    usesysid         | 16402
    usename          | repmgr
    application_name | cloud_slave_1
    ...
    
  17. Ripeti questi passaggi per creare subordinati aggiuntivi.

Passaggio al nuovo server in corso...

  1. Modifica il file di configurazione in Pgbouncer in modo che punti al nuovo server master di Google Cloud.
  2. Nell'istanza Pgbouncer, arresta Pgbouncer, promuovi il nuovo master utilizzando il file di trigger failover.postgresql.5432, quindi riavvia Pgbouncer:

    service pgbouncer stop ; ssh ${cloud_master_ip} 'touch /tmp/failover.postgresql.5432' ; service pgbouncer start
    

Configurazione del monitoraggio

Google ha collaborato con Blue Medora per fornire metriche PostgreSQL. Puoi raccogliere metriche e log sia dall'istanza PostgreSQL esistente che da quella nuova di Google Cloud.

Per ulteriori informazioni sul supporto per il monitoraggio PostgreSQL di Blue Medora, visita la relativa pagina Per iniziare.

Query di esempio

Controlla tutte le connessioni simultanee sul server:

 select * from pg_stat_activity;

(Principale) Controlla lo stato della replica:

select * from pg_stat_replication;

(Master) Controlla per vedere il ritardo nell'applicazione dei dati sulla replica:

select pg_xlog_location_diff(write_location, replay_location) from pg_stat_replication;

(Principale) Controlla il ritardo dei byte nella replica:

select client_hostname, client_addr, pg_xlog_location_diff(pg_stat_replication.sent_location,
  pg_stat_replication.replay_location)AS byte_lag from pg_stat_replication;

(Subordinato) Controlla se il database è una replica o meno:

select pg_is_in_recovery();

(Subordinato) Controlla gli ultimi dati ricevuti dal master:

select pg_last_xlog_receive_location();

(Subordinato) Controlla gli ultimi dati applicati dal master:

select pg_last_xlog_replay_location();

(Subordinato) Verifica il ritardo di replica in secondi:

select now() - pg_last_xact_replay_timestamp();

Pulizia

Elimina il progetto

  1. In Google Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

  • Esplora architetture di riferimento, diagrammi, tutorial e best practice su Google Cloud. Consulta il nostro Centro di architettura cloud.
  • Scopri come utilizzare i prodotti Google Cloud per creare soluzioni end-to-end.