PostgreSQL
 sql >> Base de Dados >  >> RDS >> PostgreSQL

Usando o Barman para fazer backup do PostgreSQL - uma visão geral


Os backups de banco de dados desempenham um papel fundamental na criação de uma estratégia eficaz de recuperação de desastres para bancos de dados de produção. Os administradores e arquitetos de banco de dados devem trabalhar continuamente para projetar uma estratégia de backup ideal e eficaz para bancos de dados de missão crítica em tempo real e garantir que os SLAs de recuperação de desastres sejam atendidos. De acordo com minha experiência, isso não é fácil e pode levar de dias a semanas para alcançar uma estratégia de backup impecável. Não é apenas escrever um bom script para fazer backup de bancos de dados e garantir que funcione. Existem vários fatores a serem considerados, vamos dar uma olhada neles:
  • Tamanho do banco de dados: O tamanho do banco de dados desempenha um papel importante ao projetar estratégias de backup. Na verdade, este é um dos principais fatores que definem
    • Tempo gasto pelo backup
    • A carga nos componentes de infraestrutura, como disco, rede, CPU etc.
    • Quantidade de armazenamento de backup necessária e os custos envolvidos
    • Se os bancos de dados estiverem hospedados na nuvem, os custos de armazenamento de backup dependem da quantidade de armazenamento necessária
    • Além disso, o tamanho do banco de dados afeta o RTO
  • Infraestrutura: A estratégia de backup depende muito da infraestrutura dos bancos de dados. O procedimento de backup seria diferente para bancos de dados hospedados em um servidor físico em um data center local em comparação aos hospedados na nuvem.
  • Local de backup: Para onde estão indo os backups? Geralmente, os backups serão colocados em um local remoto, por exemplo, em fita ou armazenamento específico em nuvem, como AWS S3.
  • Ferramenta de backup: Identifique uma ferramenta ideal para realizar backup de banco de dados online que potencialmente garante que um backup consistente tenha sido feito.

Uma boa estratégia de backup de banco de dados deve garantir que RTO (objetivo de tempo de recuperação) e RPO (objetivo de ponto de recuperação) sejam atendidos, o que, por sua vez, ajuda a atingir o objetivo de recuperação de desastres. Os backups em nível de sistema de arquivos podem ser executados em bancos de dados PostgreSQL de várias maneiras. Neste blog, meu foco será em uma ferramenta chamada Barman que é popularmente usada para realizar Backups de Banco de Dados PostgreSQL.

Barman (gerente de backup e recuperação) é uma ferramenta de código aberto baseada em Python desenvolvida por desenvolvedores no 2º Quadrante. Esta ferramenta foi desenvolvida para alcançar a estratégia de backup de banco de dados de nível empresarial para bancos de dados de produção PostgreSQL de missão crítica. Seus recursos e características se assemelham ao RMAN da Oracle. Na minha opinião, barman é uma das melhores opções para bancos de dados PostgreSQL e pode trazer diversos benefícios do ponto de vista operacional para DBAs e engenheiros de infraestrutura.

Vejamos algumas capacidades do Barman:

Vou começar com a visão geral da configuração e depois listar que tipo de backups podem ser realizados

Tecnicamente, barman-cli é uma ferramenta baseada em python e tem dois arquivos de configuração diferentes para lidar. Um arquivo que é a configuração real do banco de dados do qual será feito backup reside em nomes “/etc/barman.d” como .conf e o outro arquivo que tem os parâmetros relacionados ao barman (como local dos backups do barman, servidor do barman, arquivos de log etc.) configurado reside em “/etc” (/etc/barman.conf). Os arquivos de configuração do barman possuem configuração de parâmetros do tipo MySQL.

O conteúdo de exemplo do arquivo /etc/barman.conf é mostrado abaixo 
[barman]
barman_user = barman            ---------> barman user who performs backup/recovery of database
configuration_files_directory = /etc/barman.d    -----> location for DB configuration files
barman_home = /dbbackups/barman    ---> barman home directory
log_file = /dbbackups/barman/logs/barman.log ---> barman log file location
log_level = INFO  -----> level of logging for barman operations
compression = gzip  ----->  backups must be compressed

Instalação do Barman


Vamos dar uma olhada no procedimento de instalação do barman -

Instalando a partir da fonte


Baixe o barman do https://www.pgbarman.org/

Descompacte / descompacte o instalador e execute o seguinte comando como usuário root - 
[[email protected] barman-2.4]# ./setup.py install
/usr/lib64/python2.7/distutils/dist.py:267: UserWarning: Unknown distribution option: 'setup_requires'
  warnings.warn(msg)
/usr/lib64/python2.7/distutils/dist.py:267: UserWarning: Unknown distribution option: 'install_requires'
  warnings.warn(msg)
/usr/lib64/python2.7/distutils/dist.py:267: UserWarning: Unknown distribution option: 'tests_require'
  warnings.warn(msg)
running install
running build
running build_py
creating build
creating build/lib
creating build/lib/barman
copying barman/utils.py -> build/lib/barman
copying barman/fs.py -> build/lib/barman
copying barman/retention_policies.py -> build/lib/barman
copying barman/diagnose.py -> build/lib/barman
copying barman/backup.py -> build/lib/barman
copying barman/recovery_executor.py -> build/lib/barman
copying barman/backup_executor.py -> build/lib/barman
copying barman/config.py -> build/lib/barman
copying barman/process.py -> build/lib/barman
copying barman/output.py -> build/lib/barman
copying barman/__init__.py -> build/lib/barman
copying barman/remote_status.py -> build/lib/barman
copying barman/xlog.py -> build/lib/barman
copying barman/lockfile.py -> build/lib/barman
copying barman/postgres.py -> build/lib/barman
copying barman/server.py -> build/lib/barman
copying barman/cli.py -> build/lib/barman
copying barman/version.py -> build/lib/barman
copying barman/compression.py -> build/lib/barman
copying barman/wal_archiver.py -> build/lib/barman
copying barman/infofile.py -> build/lib/barman
copying barman/exceptions.py -> build/lib/barman
copying barman/hooks.py -> build/lib/barman
copying barman/copy_controller.py -> build/lib/barman
copying barman/command_wrappers.py -> build/lib/barman
running build_scripts
creating build/scripts-2.7
copying and adjusting bin/barman -> build/scripts-2.7
changing mode of build/scripts-2.7/barman from 644 to 755
running install_lib
creating /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/utils.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/fs.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/retention_policies.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/diagnose.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/backup.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/recovery_executor.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/backup_executor.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/config.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/process.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/output.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/__init__.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/remote_status.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/xlog.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/lockfile.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/postgres.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/server.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/cli.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/version.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/compression.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/wal_archiver.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/infofile.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/exceptions.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/hooks.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/copy_controller.py -> /usr/lib/python2.7/site-packages/barman
copying build/lib/barman/command_wrappers.py -> /usr/lib/python2.7/site-packages/barman
byte-compiling /usr/lib/python2.7/site-packages/barman/utils.py to utils.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/fs.py to fs.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/retention_policies.py to retention_policies.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/diagnose.py to diagnose.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/backup.py to backup.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/recovery_executor.py to recovery_executor.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/backup_executor.py to backup_executor.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/config.py to config.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/process.py to process.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/output.py to output.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/__init__.py to __init__.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/remote_status.py to remote_status.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/xlog.py to xlog.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/lockfile.py to lockfile.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/postgres.py to postgres.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/server.py to server.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/cli.py to cli.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/version.py to version.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/compression.py to compression.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/wal_archiver.py to wal_archiver.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/infofile.py to infofile.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/exceptions.py to exceptions.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/hooks.py to hooks.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/copy_controller.py to copy_controller.pyc
byte-compiling /usr/lib/python2.7/site-packages/barman/command_wrappers.py to command_wrappers.pyc
running install_scripts
copying build/scripts-2.7/barman -> /usr/bin
changing mode of /usr/bin/barman to 755
running install_data
copying doc/barman.1 -> /usr/share/man/man1
copying doc/barman.5 -> /usr/share/man/man5
running install_egg_info
Writing /usr/lib/python2.7/site-packages/barman-2.4-py2.7.egg-info

Instalando a partir do repositório


A instalação também pode ser feita via yum da seguinte forma 
[[email protected]~]$ yum install barman

Vamos dar uma olhada nos diferentes tipos de backups que o barman suporta

Backups dinâmicos físicos


Barman suporta Physical Hot Backups, ou seja, backup online de arquivos de dados físicos e arquivos de log de transações do banco de dados usando a metodologia rsync, que também pode estar na forma compactada.

Vamos dar uma olhada nas etapas e comandos para executar o backup RSYNC usando o barman

Arquivo de configuração de banco de dados PostgreSQL nº 1 para barman

[pgdb]
description="Main PostgreSQL server"
conninfo=host=pgserver user=postgres dbname=postgres
ssh_command=ssh [email protected]
archiver=on
backup_method = rsync

“pgdb” é o identificador do banco de dados Postgres para barman e o nome do arquivo de configuração deve ser .conf localizado em /etc/barman.d/. Quando o comando de backup do barman é executado, o barman procura a seção [pgdb] no arquivo pgdb.conf.

O parâmetro backup_method define o tipo de backup a ser feito. Neste caso backup_method é rsync.

Nota:Para que o comando barman backup seja bem-sucedido, a autenticação ssh sem senha deve ser configurada entre os servidores barman e postgres.

#2 parâmetros do arquivo postgresql.conf

wal_level=replica
archive_mode=on
archive_command=’rsync to <ARCHIVE LOCATION>’

Comando de backup do Barman

#3 Verifique se o barman está pronto para realizar backups

[[email protected] pgdb]$ barman check pgdb
Server pgdb:
        PostgreSQL: OK
        is_superuser: OK
        wal_level: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        failed backups: OK (there are 0 failed backups)
        minimum redundancy requirements: OK (have 4 backups, expected at least 0)
        ssh: OK (PostgreSQL server)
        not in recovery: OK
        archive_mode: OK
        archive_command: OK
        continuous archiving: OK
        archiver errors: OK

A saída acima diz que tudo está "OK" para prosseguir com o backup, o que significa que você pode fazer um backup.

Por exemplo, a saída abaixo diz que o backup não pode ser feito porque, de acordo com o barman, o SSH não está funcionando - 
[[email protected]  ~]$ barman check pgdb
Server pgdb:
        PostgreSQL: OK
        is_superuser: OK
        wal_level: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        failed backups: OK (there are 0 failed backups)
        minimum redundancy requirements: OK (have 0 backups, expected at least 0)
        ssh: FAILED (Connection failed using '[email protected] -o BatchMode=yes -o StrictHostKeyChecking=no' return code 127)
        not in recovery: OK
        archive_mode: OK
        archive_command: OK
        continuous archiving: OK
        archiver errors: OK

#4 Realizar backup do banco de dados

[[email protected] ~]$ barman backup pgdb
Starting backup using rsync-exclusive method for server pgdb in /dbbackup/barman_backups/pgdb/base/20180816T153846
Backup start at LSN: 0/1C000028 (00000001000000000000001C, 00000028)
This is the first backup for server pgdb
WAL segments preceding the current backup have been found:
        00000001000000000000000B from server pgdb has been removed
        00000001000000000000000C from server pgdb has been removed
        00000001000000000000000D from server pgdb has been removed
        00000001000000000000000E from server pgdb has been removed
        00000001000000000000000F from server pgdb has been removed
        000000010000000000000010 from server pgdb has been removed
        000000010000000000000011 from server pgdb has been removed
        000000010000000000000012 from server pgdb has been removed
        000000010000000000000013 from server pgdb has been removed
        000000010000000000000014 from server pgdb has been removed
        000000010000000000000015 from server pgdb has been removed
        000000010000000000000016 from server pgdb has been removed
Starting backup copy via rsync/SSH for 20180816T153846
Copy done (time: 1 second)
This is the first backup for server pgdb
Asking PostgreSQL server to finalize the backup.
Backup size: 21.8 MiB
Backup end at LSN: 0/1C0000F8 (00000001000000000000001C, 000000F8)
Backup completed (start time: 2018-08-16 15:38:46.668492, elapsed time: 1 second)
Processing xlog segments from file archival for pgdb
        000000010000000000000016
        000000010000000000000017
        000000010000000000000018
        000000010000000000000019
        00000001000000000000001A
        00000001000000000000001B
        00000001000000000000001C
        00000001000000000000001C.00000028.backup

Para entender se o comando de backup do barman será bem-sucedido, o comando abaixo ajuda -

Backups incrementais


Outra grande capacidade do Barman é a capacidade de fazer backups incrementais. Isso significa que apenas os blocos alterados desde o último backup completo do banco de dados podem ser copiados. Para bancos de dados que sofrem menos alterações de dados, o backup incremental deles pode reduzir o uso de recursos.

Depende muito de rsync e hard-links. Abaixo estão os benefícios dos backups incrementais –
  • Reduz significativamente o tempo de backup diário
  • O volume de dados em backup é reduzido, pois apenas os blocos de dados alterados serão copiados, o que, por sua vez, reduz o uso de recursos de infraestrutura, como largura de banda de rede, espaço em disco, E/S etc.
  • Se você está buscando um RTO muito bom, esse é o recurso que você procura

Os comandos para backup incremental são praticamente os mesmos. Quaisquer backups subsequentes após o primeiro backup feito com a opção backup_method=rsync serão backups incrementais e o barman puxa os WALs usando o utilitário pg_recievexlog.

Backups e recuperação de banco de dados remoto


Essa capacidade do Barman é altamente benéfica para DBAs na minha opinião. A primeira coisa que os DBAs devem procurar é evitar ao máximo sobrecarregar os recursos do servidor de banco de dados de produção durante os backups e fazê-los remotamente seria a melhor opção. Barman aproveita o pg_basebackup, o que torna muito mais fácil criar scripts e automatizá-lo.

Em geral, as opções tradicionalmente disponíveis para backups automatizados serão:
  1. pg_basebackup
  2. cópia tar

As duas opções acima envolvem muito desenvolvimento e teste para garantir que uma estratégia de backup eficaz esteja em vigor para atender às demandas de SLAs e pode representar desafios para grandes bancos de dados com vários espaços de tabela.

Com Barman, é bem simples. Outra capacidade excepcional do barman é o streaming WAL contínuo. Vamos dar uma olhada nisso com um pouco mais de detalhes.
Baixe o whitepaper hoje PostgreSQL Management &Automation with ClusterControlSaiba o que você precisa saber para implantar, monitorar, gerenciar e dimensionar o PostgreSQLBaixe o whitepaper

Backup de streaming com streaming WAL contínuo


Isso faz com que o barman se destaque em comparação com outras ferramentas do mercado. Arquivos WAL ao vivo podem ser transmitidos continuamente para um local de backup remoto usando o Barman. Este é o RECURSO que os DBAs ficariam animados em conhecer. Eu estava animado para saber sobre isso. É extremamente difícil ou quase impossível conseguir isso com scripts criados manualmente ou com uma combinação de ferramentas como pg_basebackup e pg_receivewal. Com streaming WAL contínuo, um melhor RPO pode ser alcançado. Se a estratégia de backup for projetada meticulosamente, não seria exagero dizer que um RPO de quase 0 pode ser alcançado.

Vejamos as etapas, comandos para executar um backup de streaming de barman

#1 alterações de parâmetro postgresql.conf


Seguem configurações a serem feitas no postgresql.conf 
wal_level=replica
max_wal_senders = 2
max_replication_slots = 2
synchronous_standby_names = 'barman_receive_wal'
archive_mode=on
archive_command = 'rsync -a %p [email protected]:INCOMING_WAL_DIRECTORY/%f'
archive_timeout=3600 (should not be 0 or disabled)

#2 Criar slot de replicação usando barman


O slot de replicação é importante para backups de streaming. Caso o fluxo contínuo de WALs falhe por qualquer motivo, todos os WALs não transmitidos podem ser retidos no banco de dados postgres sem serem removidos. 
[[email protected] ~]$ barman receive-wal --create-slot pgdb
Creating physical replication slot 'barman' on server 'pgdb'
Replication slot 'barman' created

#3 Configure o arquivo de configuração do servidor de banco de dados para barman


O identificador de banco de dados para barman é “pgdb”. Um arquivo de configuração chamado pgdb.conf deve ser criado no local /etc/barman.d/ com o seguinte conteúdo 
[pgdb]
description="Main PostgreSQL server"
conninfo=host=pgserver user=postgres dbname=postgres
streaming_conninfo=host=pgserver user=barman
backup_method=postgres
archiver=on
incoming_wals_directory=/dbbackups/barman_backups/pgdb/incoming
streaming_archiver=on
slot_name=barman

streaming_conninfo é o parâmetro a ser configurado para que o barman execute backups de streaming
backup_method deve ser configurado para "postgres" quando o backup de streaming deve ser feito
streaming_archiver deve ser configurado para "on"
slot_name=barman Este parâmetro deve ser configurado quando você precisar que o barman use slots de replicação. Nesse caso, o nome do slot de replicação é barman

Depois que a configuração estiver concluída, faça uma verificação de barman para garantir que os backups de streaming sejam executados com êxito.

#4 Verifique se o barman receive-wal está funcionando bem


Em geral, para o primeiro barman, o receive-wal não funciona imediatamente após as alterações de configuração, pode ocorrer um erro e o comando barman check pode mostrar o seguinte - 
[[email protected]  archive_status]$ barman check pgdb
Server pgdb:
        PostgreSQL: OK
        is_superuser: OK
        PostgreSQL streaming: OK
        wal_level: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        failed backups: OK (there are 0 failed backups)
        minimum redundancy requirements: OK (have 0 backups, expected at least 0)
        pg_basebackup: OK
        pg_basebackup compatible: OK
        pg_basebackup supports tablespaces mapping: OK
        archive_mode: OK
        archive_command: OK
        continuous archiving: OK
        pg_receivexlog: OK
        pg_receivexlog compatible: OK
        receive-wal running: FAILED (See the Barman log file for more details)
        archiver errors: OK

Quando você executa o barman receive-wal, ele pode travar. Para fazer o receive-wal funcionar corretamente pela primeira vez, o comando abaixo deve ser executado. 
[[email protected]  arch_logs]$ barman cron
Starting WAL archiving for server pgdb
Starting streaming archiver for server pgdb

Agora, faça uma verificação de barman novamente, deve estar bom agora. 
[[email protected]  arch_logs]$ barman check pgdb
Server pgdb:
        PostgreSQL: OK
        is_superuser: OK
        PostgreSQL streaming: OK
        wal_level: OK
        replication slot: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        failed backups: OK (there are 0 failed backups)
        minimum redundancy requirements: OK (have 2 backups, expected at least 0)
        pg_basebackup: OK
        pg_basebackup compatible: OK
        pg_basebackup supports tablespaces mapping: OK
        archive_mode: OK
        archive_command: OK
        continuous archiving: OK
        pg_receivexlog: OK
        pg_receivexlog compatible: OK
        receive-wal running: OK
        archiver errors: OK

Se você puder ver, o status do receivexlog mostra ok. Este é um dos problemas que enfrentei.

#5 Verifique se o barman está pronto para fazer backups

[[email protected] ~]$ barman check pgdb
Server pgdb:
        PostgreSQL: OK
        is_superuser: OK
        PostgreSQL streaming: OK
        wal_level: OK
        replication slot: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        failed backups: OK (there are 0 failed backups)
        minimum redundancy requirements: OK (have 4 backups, expected at least 0)
        pg_basebackup: OK
        pg_basebackup compatible: OK
        pg_basebackup supports tablespaces mapping: OK
        archive_mode: OK
        archive_command: OK
        continuous archiving: OK
        pg_receivexlog: OK
        pg_receivexlog compatible: OK
        receive-wal running: OK
        archiver errors: OK

#6 Verifique o status do streaming usando o barman

[[email protected] pgdb]$ barman replication-status pgdb
Status of streaming clients for server 'pgdb':
  Current LSN on master: 0/250008A8
  Number of streaming clients: 1

  1. #1 Sync WAL streamer
     Application name: barman_receive_wal
     Sync stage      : 3/3 Remote write
     Communication   : TCP/IP
     IP Address      : 192.168.1.10 / Port: 52602 / Host: -
     User name       : barman
     Current state   : streaming (sync)
     Replication slot: barman
     WAL sender PID  : 26592
     Started at      : 2018-08-16 16:03:21.422430+10:00
     Sent LSN   : 0/250008A8 (diff: 0 B)
     Write LSN  : 0/250008A8 (diff: 0 B)
     Flush LSN  : 0/250008A8 (diff: 0 B)

O status acima significa que o barman está pronto para executar o backup de streaming. Execute o backup conforme mostrado abaixo - 
[[email protected] arch_logs]$ barman backup pgdb
Starting backup using postgres method for server pgdb in /dbbackup/barman_backups/pgdb/base/20180816T160710
Backup start at LSN: 0/1F000528 (00000001000000000000001F, 00000528)
Starting backup copy via pg_basebackup for 20180816T160710
Copy done (time: 1 second)
Finalising the backup.
Backup size: 21.9 MiB
Backup end at LSN: 0/21000000 (000000010000000000000020, 00000000)
Backup completed (start time: 2018-08-16 16:07:10.401526, elapsed time: 1 second)
Processing xlog segments from file archival for pgdb
        00000001000000000000001F
        000000010000000000000020
        000000010000000000000020.00000028.backup
        000000010000000000000021
Processing xlog segments from streaming for pgdb
        00000001000000000000001F
        000000010000000000000020

Backups centralizados e catalogados


É altamente benéfico para ambientes que executam vários bancos de dados em vários servidores em um ambiente de rede. Esta é uma das características excepcionais do Barman. Trabalhei em ambientes em tempo real onde tive que gerenciar, administrar centenas de bancos de dados e sempre senti a necessidade de backups centralizados de banco de dados e é por isso que o Oracle RMAN se tornou popular para a estratégia de backup de banco de dados Oracle e agora Barman está preenchendo isso espaço para PostgreSQL. Com Barman, engenheiros de DBA e DevOps podem trabalhar para construir um servidor de backup centralizado onde os backups de banco de dados para todos os bancos de dados são mantidos e validados.

O que significa backups catalogados, barman mantém um repositório centralizado onde os status de todos os backups são mantidos. Você pode verificar os backups disponíveis para determinado banco de dados, conforme mostrado abaixo - 
[[email protected] ~]$  barman list-backup pgdb
pgdb 20180816T160924 - Thu Aug 16 16:09:25 2018 - Size: 22.0 MiB - WAL Size: 135.7 KiB
pgdb 20180816T160710 - Thu Aug 16 16:07:11 2018 - Size: 21.9 MiB - WAL Size: 105.8 KiB
pgdb 20180816T153913 - Thu Aug 16 15:39:15 2018 - Size: 21.9 MiB - WAL Size: 54.2 KiB
pgdb 20180816T153846 - Thu Aug 16 15:38:48 2018 - Size: 21.9 MiB - WAL Size: 53.0 KiB

Política de retenção de backup


Políticas de retenção pode ser definido para backups de banco de dados. Os backups podem se tornar obsoletos após um determinado período e os backups obsoletos podem ser excluídos periodicamente.

Existem opções no arquivo de configuração para garantir que os backups sejam mantidos e tornados obsoletos quando o período de retenção exceder -

O primeiro parâmetro a ser configurado é minimum_redundancy . Sempre configure Minimum_redundancy como>0 para garantir que os backups não sejam excluídos acidentalmente.

Exemplo:redundância_mínima =1
  • retention_policy O parâmetro determinará por quanto tempo os backups básicos devem ser retidos para garantir que os SLAs de recuperação de desastres sejam atendidos.
  • wal_retention_policy O parâmetro determinará por quanto tempo os backups wal devem ser retidos. Isso garante que o RPO esperado seja atendido.

As políticas de retenção e redundância existentes para um servidor de banco de dados podem ser verificadas usando o comando barman check da seguinte forma 
[[email protected] ~]$ barman check pgdb
Server pgdb:
        PostgreSQL: OK
        is_superuser: OK
        PostgreSQL streaming: OK
        wal_level: OK
        replication slot: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        failed backups: OK (there are 0 failed backups)
        minimum redundancy requirements: OK (have 4 backups, expected at least 0)
        pg_basebackup: OK
        pg_basebackup compatible: OK
        pg_basebackup supports tablespaces mapping: OK
        archive_mode: OK
        archive_command: OK
        continuous archiving: OK
        pg_receivexlog: OK
        pg_receivexlog compatible: OK
        receive-wal running: OK
        archiver errors: OK

Backups e recuperações paralelas pode ser realizado utilizando várias CPUs, o que realmente torna os backups e recuperações completos mais rápidos. Esse recurso é benéfico para bancos de dados muito grandes dimensionados para TeraBytes.

Para executar backups paralelamente, adicione a seguinte opção no arquivo de configuração do servidor de banco de dados (que é o arquivo /etc/barman.d/pgdb.conf)- 
parallel_jobs = 1

Posso concluir dizendo que o barman é uma ferramenta de nível empresarial que pode ajudar os DBAs a projetar uma estratégia eficaz de recuperação de desastres.
Recursos relacionados ClusterControl for PostgreSQLSaiba mais Usando pg_dump e pg_dumpall para fazer backup do PostgreSQLLeia o blog Principais ferramentas de backup para PostgreSQLLeia o blog Torne-se um DBA do PostgreSQL - Backups lógicos e físicos do PostgreSQLLeia o blog