Migrar um cluster local do PostgreSQL para o Google Cloud

Neste artigo, você verá como migrar um cluster local do PostgreSQL para o Google Cloud. Nesta abordagem, usamos o PgBouncer como um pool de conexões para minimizar o tempo de inatividade do aplicativo e buscamos ajudar na configuração de ferramentas para monitorar os resultados. Este artigo foi desenvolvido administradores ou administradores de sistemas do PostgreSQL que trabalham em um ambiente Linux.

No diagrama a seguir, mostramos uma instância de PgBouncer colocada em frente de um mestre local.

Arquitetura de uma instância de PgBouncer colocada na frente de um mestre local.

Com o pool de conexões, os clientes são roteados para um nó alternativo quando ocorre o failover para o Google Cloud, sem precisar reimplantar as configurações do app ou fazer alterações no nível do aplicativo.

O diagrama a seguir ilustra a migração.

Arquitetura de migração para o Google Cloud.

Para realizar a migração, você precisa encerrar o mestre atual e, em seguida, promover a réplica secundária do Google Cloud para o mestre. O PgBouncer redireciona o tráfego para o novo nó mestre no Google Cloud.

Custos

Neste tutorial, usamos o seguinte componente faturável do Google Cloud:

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Objetivos

  • Configurar o PostgreSQL no Google Cloud.
  • Configure a replicação no Compute Engine.
  • Propagar seus dados para uma nova instância.
  • Configurar o cluster do PostgreSQL no Google Cloud.
  • Mudar para o novo servidor.
  • Implementar monitoramento

Antes de começar

Neste tutorial, usamos os comandos gcloud e gsutil, que podem ser executados em uma instância do Cloud Shell iniciada no Console do Cloud . Se você quiser usar gcloud e gsutil na estação de trabalho local, instale o SDK do Cloud. No tutorial, mostramos como executar comandos no Cloud Shell. Se você usa o SDK do Cloud na estação de trabalho, ajuste as instruções de acordo.

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative a API Compute Engine.

    Ative a API

Como configurar o ambiente

Para começar, execute tarefas a seguir:

  • Configurar o PostgreSQL no Google Cloud.
  • Configure a replicação no Compute Engine.

Em seguida, propague os dados para uma nova instância, antes de começar a replicar o mestre.

Configurar o PostgreSQL no Google Cloud

Siga as etapas em Como configurar o PostgreSQL para alta disponibilidade e replicação com espera ativa para configurar o PostgreSQL no Google Cloud em apenas alguns minutos. É possível configurar o PostgreSQL em uma instância de máquina virtual Ubuntu, no Compute Engine.

Configurar a replicação no Compute Engine

Siga as etapas em Como configurar o PostgreSQL no Google Compute Engine e configure o PostgreSQL para execução no modo Hot Standby no Compute Engine. Você usará duas instâncias do Compute Engine. Uma delas executará o servidor PostgreSQL principal e a outra, o servidor em espera.

Ainda que as propriedades para configuração do PostgreSQL sejam diferentes no caso de instâncias principais ou de instâncias subordinadas, os arquivos de propriedade precisam ser idênticos, para permitir failovers sem interrupções.

Uma instância subordinada em um cluster do PostgreSQL é indicada pela presença do arquivo recovery.conf.

Na maioria dos casos, é importante separar o diretório de dados do banco de dados do disco de inicialização. Neste exemplo, você armazena arquivos de banco de dados em uma montagem em /database.

Use os seguintes comandos para modificar o arquivo postgresql.conf na instância mestre e configurar a replicação:

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

Use os seguintes comandos para modificar o arquivo postgresql.conf na réplica:

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

É possível compensar parte da carga no mestre se enviar solicitações Read à réplica.

Propagar os dados

O registro de transações contido no banco de dados mestre é limitado, portanto, na maioria das migrações do PostgreSQL é preciso que os dados sejam propagados para uma nova instância, antes que seja possível iniciar a replicação do mestre. Os dados podem ser propagados de uma das seguintes maneiras:

  • Ao despejar um banco de dados em um script ou arquivo usando Pg_dump.
  • Ao fazer uma cópia binária de um cluster de banco de dados em execução usando Pg_basebackup.
  • Ao copiar a pasta de dados para a réplica usando rsync.
  • Ao restaurar um backup anterior para a réplica.

Entre essas opções, recomendamos que você restaure um backup anterior para a réplica. Essa solução não acarreta nenhum impacto no desempenho quando há grandes volumes de dados sendo transferidos e permite que o cluster atual continue a operar normalmente.

Após a propagação inicial do banco de dados, é possível usar o comando rsync para fornecer mudanças à réplica que ocorreram desde o backup e o comando sincroniza os diretórios de dados entre as duas instâncias. Essa etapa é importante, caso o backup tenha se atrasado muito em relação ao mestre, a ponto de tornar impossível alcançá-lo por meio da replicação normal.

Como configurar o cluster do PostgreSQL no Google Cloud

É possível criar o cluster do PostgreSQL usando a replicação em cascata. Primeiro, migre o banco de dados, conforme exposto no diagrama a seguir.

Arquitetura do seu ambiente atual migrada para o Google Cloud.

Migrar o banco de dados

  1. Faça um backup completo do servidor mestre em execução. O label pode ser qualquer rótulo:

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

    $PGDATA é o principal diretório de dados do PostgreSQL.

  2. Crie um bucket no projeto do Google Cloud chamado gs://pg-repo/.

  3. Transfira o backup para o bucket que você acabou de criar:

    master$ gsutil cp postgresql_AAAAMMDD.tar.gz gs://pg-repo/
    
  4. Transfira o arquivo de backup para o mestre do Google Cloud:

    new_master$ gsutil cp gs://pg-repo/postgresql_AAAAMMDD.tar.gz
    
  5. Restaure o arquivo de backup no mestre do Google Cloud:

    new_master$ (cd / ; tar xvf postgresql_AAAAMMDD.tar.gz)
    
  6. Crie um arquivo recovery.conf no diretório $PG_DATA que inclui o seguinte:

    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. Inicie o serviço PostgreSQL:

    sudo service postgresql start
    
  8. Aguarde até que o servidor mestre do Google Cloud seja sincronizado com o mestre em execução. No registro, você verá algo assim:

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

    Além disso, é possível pesquisar em master pg_stat_replication para determinar se o novo subordinado (chamado cloud_master) está conectado:

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

Criar um banco de dados subordinado

  1. Encerre o banco de dados e o servidor:

    sudo service postgresql stop
    sudo shutdown -h now
    
  2. Para verificar se o serviço parou, execute o seguinte comando:

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

    A saída mostra o status da instância como TERMINATED:

    status: TERMINATED
    

    Em seguida, crie snapshots do disco de dados para ajudar a criar novos subordinados.

  3. No Console do Cloud, acesse a página Snapshots.

    Acessar a página "Snapshots"

  4. A partir do disco do PostgreSQL, crie um novo snapshot.

  5. Inicie o servidor mestre do Google Cloud.

  6. Acesse a página Instâncias de VM, clique no nome da instância mestre e, em seguida, clique em Iniciar.

    O serviço PostgreSQL será iniciado automaticamente.

  7. Para verificar, execute o seguinte comando:

    ps ax | grep postgres
    

    O resultado será similar a este:

     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. No Console do Cloud, acesse a página Instâncias de VM e clique em Criar instância.

  9. Para o disco de inicialização, escolha Ubuntu 14.04.

  10. Clique em Gerenciamento, discos, rede, ssh-keys e adicione um novo disco com base no instantâneo que você criou antes.

  11. Inicie o novo servidor e ative o disco:

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

    sudo apt-get install postgresql && sudo service postgresql stop
    
  13. Configure o diretório de dados e os valores de replicação. Copie os arquivos postgresql.conf e pg_hba.conf do mestre do Google Cloud e edite o arquivo recovery.conf para incluir o seguinte:

    standby_mode = 'on'
    primary_conninfo = 'port=5432 host=${cloud_master_ip} user=${replication_user} application_name=cloud_slave_${identifier}'
    recovery_target_timeline = 'latest'
    
  14. Inicie o serviço PostgreSQL com o novo arquivo de configuração, apontando para o mestre do Google Cloud:

    sudo service postgresql restart
    
  15. Verifique se o serviço está sendo executado:

    ps ax | grep postgres
    
  16. Verifique o servidor mestre do Google Cloud com esta consulta:

    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. Repita essas etapas para criar outros subordinados.

Como fazer a migração para o novo servidor

  1. Altere o arquivo de configuração no PgBouncer para apontar para o novo servidor mestre do Google Cloud.
  2. Na instância do PgBouncer, encerre o PgBouncer, promova o novo mestre usando o arquivo de gatilho failover.postgresql.5432 e reinicie o PgBouncer:

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

Como configurar o monitoramento

O Google fez uma parceria com a Blue Medora (em inglês) para fornecer métricas do PostgreSQL. É possível coletar métricas e registros da instância atual do PostgreSQL e da nova instância do Google Cloud.

Para mais informações sobre o suporte de monitoramento do PostgreSQL da Blue Medora, acesse a página de primeiros passos.

Consultas de amostra

Verifique todas as conexões simultâneas no servidor:

 select * from pg_stat_activity;

(Mestre) Verifique o status da replicação:

select * from pg_stat_replication;

(Mestre) Verifique o atraso na aplicação de dados na réplica:

select pg_xlog_location_diff(write_location, replay_location) from pg_stat_replication;

(Mestre) Verifique o atraso de byte na replicação:

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;

(Subordinado) Verifique se o banco de dados é ou não uma réplica:

select pg_is_in_recovery();

(Subordinado) Verifique os últimos dados recebidos do mestre:

select pg_last_xlog_receive_location();

(Subordinado) Verifique os dados aplicados pela última vez a partir do mestre:

select pg_last_xlog_replay_location();

(Subordinado) Verifique o atraso de replicação em segundos:

select now() - pg_last_xact_replay_timestamp();

Limpeza

Excluir o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Próximas etapas