Como posso configurar backups automatizados e criptografados de bancos de dados MySQL ativos em um Ubuntu VPS para o Google Drive usando o Duplicity?

Levei um pouco mais de 12 horas para reunir todas as informações de que precisava, mas aqui está o processo:

Etapa 1: conta do Google

Escolha uma existente ou crie uma nova conta do Google onde você armazenará seus backups. Eu gosto de ter uma conta separada para que meus dados de backup de negócios não se misturem com meus dados pessoais da conta do Google.

Iremos nos referir ao nome da conta do Google como <google_account_name>.

Etapa 2: configurar despejos de banco de dados

Para fazer isso, criaremos um diretório especial para despejos de banco de dados e usaremos o mysqldumpcomando.

Crie um diretório de backup e dê a si mesmo as permissões necessárias

Minha distribuição do Ubuntu veio com um backupusuário, um grupo e um var/backupsdiretório, então por que não usá-los ?

Tornar o backupproprietário do grupo de /var/backups:

sudo chgrp backup /var/backups

Dê ao backupgrupo permissões de leitura e gravação neste diretório:

sudo chmod g+rw /var/backups

Adicione sua própria conta ao backupgrupo:

sudo usermod -aG backup <username>

Isso facilitará o acesso ao conteúdo do diretório de backup.

Pode ser necessário fazer logoff e logon novamente para que a nova associação ao grupo entre em vigor. Para verificar sua participação no grupo, use o comando groups.

Crie uma conta de usuário SQL especial para realizar backups

Faça login no MySQL através da linha de comando:

mysql -u root -p

Crie uma nova conta de usuário do banco de dados

Não queremos nos tornar vulneráveis ​​dando mais permissões do que o absolutamente necessário . Assim, criaremos uma nova conta de usuário de banco de dados com privilégios somente leitura. Para manter a consistência, estou chamando esse usuário backup. Escolha uma senha muito forte para <db_password>.

CREATE USER 'backup'@'localhost' IDENTIFIED BY '<db_password>'

Conceda privilégios somente leitura:

GRANT SELECT,EVENT,TRIGGER,SHOW DATABASES ON *.* TO 'backup'@'localhost';

Configure o comando de backup do banco de dados:

Teste o comando dump (substitua <db_password>pela senha que você definiu anteriormente para o novo usuário do MySQL):

mysqldump --single-transaction --routines --events --triggers --add-drop-table --extended-insert -u backup -h 127.0.0.1 -p<db_password> --all-databases | gzip -9 > /var/backups/sql/all_$(date +"%Y_week_%U").sql.gz

Este comando despejará todos os bancos de dados em um único arquivo, rotulado com o ano e o número da semana atual. Cada vez que executarmos isso, ele atualizará o arquivo de despejo atual. No entanto, quando uma nova semana começa, ela acaba criando um novo arquivo. Assim, mantemos um histórico de instantâneos semanais de nossos bancos de dados. Você pode ajustar a parte da data para tornar esses instantâneos mais ou menos frequentes, dependendo do tamanho do seu banco de dados e do espaço que deseja doar para esses instantâneos.

Etapa 3: instalar dependências para Duplicity

Precisamos das versões mais recentes das seguintes bibliotecas para poder usar a versão mais recente do Duplicity:

• popt
• libbz2
• librsync

Execute os seguintes comandos:

sudo apt-get install libpopt-dev libpopt0
sudo apt-get install libbz2-dev

cd ~
wget https://github.com/librsync/librsync/archive/v2.0.0.tar.gz
tar xzvf v2.0.0.tar.gz -C librsync
cd librsync
sudo cmake .
sudo make all check
sudo make && sudo make install

Atualizar Duplicidade

A versão estável atual em 6 de outubro de 2016 é 0.7.10.

cd ~
wget https://code.launchpad.net/duplicity/0.7-series/0.7.10/+download/duplicity-0.7.10.tar.gz
tar xzvf duplicity*
cd duplicity*
sudo python setup.py install

Configure uma definição para LD_LIBRARY_PATH(consulte Como definir $LD_LIBRARY_PATH no Ubuntu? ):

O Duplicity precisa dessa variável de ambiente para que possa localizar os librsyncobjetos da biblioteca compartilhada que foram instalados anteriormente.

sudo nano /etc/ld.so.conf.d/librsync.so.2.conf

librsync.so.2.conf :

/usr/local/lib

Agora você deve recarregar o cache ldconfig do Ubuntu:

sudo ldconfig

Instalar o PyDrive

Esta é a biblioteca que lida com a negociação OAuth2 entre Duplicity e a API do Google Drive.

pip install pydrive

Etapa 4: configurar a autenticação do Google Drive via OAuth2

Criar credenciais de API

Faça isso por meio do Console do desenvolvedor do Google . Ver:

• https://stackoverflow.com/questions/31370102/how-do-i-backup-to-google-drive-using-duplicity
• http://6ftdan.com/daniepclark/2016/04/21/encrypted-linux-backup-with-google-drive-and-duplicity/

Criar arquivo de configuração:

O PyDrive usa esse arquivo para armazenar credenciais e definições de configuração para a API do Google .

nano /home/<username>/.duplicity/credentials

client_config_backend: settings  
client_config:  
   client_id: <your client ID>.apps.googleusercontent.com
   client_secret: <your client secret>
save_credentials: True
save_credentials_backend: file
save_credentials_file: /home/<username>/.duplicity/gdrive.cache
get_refresh_token: True

Configure a GOOGLE_DRIVE_SETTINGSvariável de ambiente:

export GOOGLE_DRIVE_SETTINGS=/home/<username>/.duplicity/credentials

Eu também recomendaria adicionar GOOGLE_DRIVE_SETTINGSàs variáveis ​​de ambiente sudo :

sudo visudo

Adicione a seguinte linha no final:

Defaults env_keep += "GOOGLE_DRIVE_SETTINGS"

Etapa 5: teste o backup falso não criptografado

(Referência: https://www.digitalocean.com/community/tutorials/how-to-use-duplicity-with-gpg-to-securely-automate-backups-on-ubuntu )

Criaremos alguns arquivos de teste, apenas para verificar se podemos transferi-los para o Google Drive usando o Duplicity com sucesso.

Crie arquivos de teste:

cd ~
mkdir test
touch test/file{1..100}

Executar Duplicidade:

duplicity ~/test gdocs://<google_account_name>@gmail.com/backup

Siga o link de verificação criado e copie e cole o código de verificação recebido de volta no prompt. O Duplicity deve armazenar o token de autenticação que ele cria /home/<username>/.duplicity/gdrive.cachepara que não tenhamos que fazer a etapa de verificação novamente (e assim nosso sistema pode fazer isso automaticamente todas as noites sem nossa entrada).

Etapa 6: criar chave GPG

Você precisará de uma chave para o GPG criptografar seus dados de backup antes de enviá-los para o Google Drive. Para gerar a chave, basta executar o comando:

gpg --gen-key

Siga as instruções fornecidas e certifique-se de escolher uma boa senha. Se ficar preso com uma mensagem sobre "entropia insuficiente", você pode tentar executar sudo apt-get install rng-tools. A própria instalação deve gerar entropia suficiente para que o GPG possa gerar uma chave verdadeiramente aleatória. Consulte https://stackoverflow.com/a/12716881/2970321 .

A "impressão digital" do GPG será exibida após a conclusão. Você precisará do ID da chave pública primária dessa impressão digital. Este é simplesmente o código hexadecimal de 8 dígitos após o /na linha que começa com pub. Consulte https://security.stackexchange.com/a/110146/74909 .

Adicione a senha que você definiu para sua chave GPG a um arquivo secreto:

sudo nano /root/.passphrase
sudo chmod 700 /root/.passphrase

.frase secreta :

PASSPHRASE="my passphrase"

Faça backup de sua chave GPG:

Se você perder sua chave GPG, seus backups criptografados se tornarão inúteis. Portanto, você deve fazer backup de sua chave GPG em algum lugar além do seu VPS.

Por exemplo, para fazer backup em sua máquina local:

gpg --list-keys
gpg -ao ~/gpg-public.key --export <gpg_public_key_id>

gpg --list-secret-keys
gpg -ao ~/gpg-private.key --export-secret-keys <gpg_private_key_id>

Em seguida, na sua máquina local:

scp <username>@<vps_host>:~/gpg-public.key ~/gpg-public.key
scp <username>@<vps_host>:~/gpg-private.key ~/gpg-private.key

Ver:

https://help.ubuntu.com/community/GnuPrivacyGuardHowto#Backing_up_and_restoring_your_keypair

Dependendo da natureza de seus dados, você pode querer considerar colocar a parte privada de sua chave GPG em um pedaço de papel e, em seguida, armazenar esse pedaço de papel em um cofre .

Etapa 7: testar o backup criptografado de despejos SQL

duplicity --encrypt-key <gpg_public_key_id> --exclude="**" --include="/var/backups/sql" / gdocs://<google_account_name>@gmail.com/backup

Etapa 8: coloque o dump do banco de dados e o comando Duplicity juntos em um cronscript

Configurar backup incremental diário

Isso será executado todas as noites, criando backups incrementais. Por padrão, o Duplicity tenta fazer backup de TODOS os arquivos no disco, o que provavelmente não queremos em um VPS. Então, usamos o --excludeparâmetro para que ele ignore tudo, exceto os diretórios que incluímos via --include. Você pode usar vários --includeparâmetros para incluir vários diretórios.

sudo nano /etc/cron.daily/duplicity.inc

duplicity.inc :

#!/bin/sh

test -x $(which duplicity) || exit 0
. /root/.passphrase

export PASSPHRASE
export GOOGLE_DRIVE_SETTINGS=/home/<username>/.duplicity/credentials
# This lets the script find your GPG keys when it is running as root
export GNUPGHOME=/home/<username>/.gnupg

# Run MySQL dump.  This will create a weekly file, and then update the file every additional time this script is run
mysqldump --single-transaction --routines --events --triggers --add-drop-table --extended-insert -u backup -h 127.0.0.1 -p<password> --all-databases | gzip -9 > /var/backups/sql/all_$(date +"%Y_week_%U").sql.gz

# Performs an incremental backup by default.  Since we create a new dump file every week, we have a history
# of weekly snapshots, and the current week is incrementally updated each day.
duplicity --encrypt-key <gpg_public_key_id> --include="/var/backups/sql" --exclude="**" / gdocs://<google_account_name>@gmail.com/backup

Definir permissões:

chmod 755 /etc/cron.daily/duplicity.inc

Configurar um backup completo semanal

Isso será executado uma vez por semana, criando um backup completo e limpando todos, exceto os últimos três backups completos, para economizar espaço. Novamente, você pode ajustar essa frequência e o número de backups a serem retidos de acordo com sua situação.

sudo nano /etc/cron.weekly/duplicity.full

duplicity.full :

#!/bin/sh

test -x $(which duplicity) || exit 0
. /root/.passphrase

export PASSPHRASE
export GOOGLE_DRIVE_SETTINGS=/home/<username>/.duplicity/credentials
# This lets the script find your GPG keys when it is running as root
export GNUPGHOME=/home/<username>/.gnupg

# Run MySQL dump.  This will create a weekly file, and then update the file every additional time this script is run
mysqldump --single-transaction --routines --events --triggers --add-drop-table --extended-insert -u backup -h 127.0.0.1 -p<password> --all-databases | gzip -9 > /var/backups/sql/all_$(date +"%Y_week_%U").sql.gz

# Create a brand new full backup, which contains all the weekly dumps located in /var/backups/sql
duplicity full --encrypt-key <gpg_public_key_id> --include="/var/backups/sql" --exclude="**" / gdocs://<google_account_name>@gmail.com/backup

# Clean out old full backups
duplicity remove-all-but-n-full 3 --force gdocs://<google_account_name>@gmail.com/backup

Definir permissões:

chmod 755 /etc/cron.weekly/duplicity.full

Se suas tarefas nesses cron.*diretórios não estiverem sendo executadas automaticamente por algum motivo (muitas vezes, devido a problemas com permissões), você pode adicionar essas tarefas ao arquivo cron raiz:

sudo crontab -e

Adicione as linhas (tente escolher horários ímpares):

# Incremental backup every day at HH:MM
MM HH * * * /etc/cron.daily/duplicity.inc >> /var/log/backups.log 2>&1
# Full backup every Saturday at HH:MM
MM HH * * 6 /etc/cron.weekly/duplicity.full >> /var/log/backups.log 2>&1

Salvar e sair.

Etapa 9: testar e verificar o backup

Você pode tentar baixar seu backup do Google Drive de volta para ~/test:

sudo duplicity gdocs://<google_account_name>@gmail.com/backup ~/test