# Como fazer e restaurar um Docker backup Em instalações Docker, dados são distribuídos entre diferentes objetos e arquivos. Justamente por isso, infelizmente, não existe um **método universal para criar backups** de dados individuais no Docker. Combinar diferentes comandos para a realização de um Docker backup é a solução que recomendamos. Neste tutorial, ensinamos como salvar e restaurar dados no Docker. Nosso Digital Guide já explicou [o que é backup](https://www.ionos.com/digitalguide/server/security/what-is-a-backup/ "O que é backup"), apresentou diferentes [estratégias de backup](https://www.ionos.com/digitalguide/server/know-how/backup-strategies/ "Estratégias de backup") e detalhou como criar backups de bancos de dados. Agora, demonstraremos como criar Docker backups. ## O que levar em consideração ao fazer um Docker backup? Ao contrário do [*mysqldump*, utilizado em backups do MySQL](https://www.ionos.com/pt-br/digitalguide/servidor/seguranca/mysql-dump/) e do [*pg\_dump*, usado em backups do PostgreSQL](https://www.ionos.com/digitalguide/server/security/postgresql-backup/ "Backup de PostgreSQL"), **não existe uma ferramenta que se dedique exclusivamente a realizar Docker backups**. Embora os comandos `docker backup volume` e `docker backup container` não consigam obter sucesso, há formas alternativas de se incluir componentes individuais do Docker em processos de backup. Entretanto, antes de tudo, você deve decidir que componentes gostaria de incluir no backup. ### Que componentes devem ser incluídos em um Docker backup? Via de regra, você deve fazer backup de **todos os dados que não podem ser recuperados** em caso de perda. Em se tratando de Docker, pelo menos três tipos de dados se encaixam nessa categoria: 1. **Objetos Docker**: São gerenciados pelo Docker *daemon*; dados são armazenados em um diretório especial. Não existe correspondência direta entre os arquivos nele localizados e os dados presentes no contêiner Docker. Crie backups para os seguintes objetos Docker: - Contêineres Docker - Volumes Docker - Imagens Docker 2. **Arquivos *build***: São gerenciados pelo usuário e podem ser encontrados em pastas arbitrárias no sistema host. Arquivos*build*podem ser facilmente copiados e compactados. Crie backups para os seguintes arquivos*build* do Docker: - Pasta do projeto Docker Compose - Dockerfiles 3. **Bancos de dados** em contêineres: São exportados de contêineres como arquivos *dump*. Crie backups para os bancos de dados dos seguintes sistemas: - Bancos de dados MySQL - Bancos de dados PostgreSQL A criação de Docker backups envolve **a gravação de dados em arquivos compactados no sistema host**. Estes arquivos são, então, copiados do sistema local para o sistema de backup. Pode ser interessante automatizar processos se muitos Docker backups estiverem sendo criados ao mesmo tempo. **Scripts que simplificam a criação de Docker backups** podem ser encontrados no GitHub. O desenvolvedor Andreas Laub, por exemplo, disponibiliza diversos [scripts para Docker backup](https://github.com/alaub81/backup_docker_scripts "Docker backup scripts — github.com") de código aberto. Citação > “Com esses scripts, você pode fazer backup do seu ambiente Docker. Existem opções para o projeto Compose, MySQL, MariaDB, PostgreSQL e para volumes normais de Docker”. Tradução livre. Fonte: https://github.com/alaub81/backup\_docker\_scripts Nota Aconselhamos a realização de backups de dados do Portainer periodicamente, se você usa este software para administrar o seu ambiente Docker. ### Onde dados de contêineres Dockerdevem ser armazenados? Passo essencial para a realização de backups é a cópia de dados. Antes de tudo, você deve descobrir onde eles ficam armazenados. [Volumes Docker](https://www.ionos.com/digitalguide/server/know-how/docker-container-volumes/ "Volumes de contêineres Docker") nada mais são que **locais de armazenamento para transferências entre contêineres Docker e o sistema host**, ou entre múltiplos contêineres. Um [contêiner Docker](https://www.ionos.com/digitalguide/server/know-how/docker-container/ "Contêiner Docker") é criado a partir de uma [imagem Docker](https://www.ionos.com/digitalguide/server/know-how/docker-images/ "Imagens Docker") do tipo somente leitura. **Fazer alterações em um contêiner em execução é arriscado** e pode resultar em perdas, caso o contêiner seja excluído. Por isso, realize backups permanentes desses dados antes de exportá-los de um contêiner em execução. Dados de contêineres também podem ser armazenados no contêiner em execução, juntamente com volumes Docker. Dados estes que **permanecem na camada de armazenamento gravável do sistema de arquivos do contêiner**. Na maioria dos casos, isso não deveria ocorrer. Portanto, configure o seu sistema de forma inteligente ao usar volumes Docker. Definir onde, exatamente, dados de contêineres devem ser armazenados é uma tarefa complexa, pois existem diferentes tipos de volumes Docker. As **diferenças são sutis**, e dizem respeito à localização e à destinação dos dados quando o contêiner é removido, já que ambas **dependem do tipo de volume** em questão. Apresentamos, abaixo, os principais componentes de armazenamento do Docker:
Componente de armazenamento Docker Localização Após remoção do contêiner
Camada gravável do contêiner Sistema de arquivos Union Dados são perdidos
*Bind mount* Pasta no sistema de arquivos host Dados são mantidos
Volume nomeado Dentro do ambiente Docker Dados são mantidos
Volume anônimo Dentro do ambiente Docker Dados são perdidos
## Passo a passo para fazer um Docker backup Geralmente, para criar um **arquivo *tarball*** durante um Docker backup, usa-se o comando `tar`. Esta é a estrutura geral dele: ```none tar -cvf .tar ``` No entanto, **o caminho completo para a pasta compactada é incluído no arquivo**, quando habilitado, o que pode causar erros durante o processo de restauração. Para contornar este problema, há uma abordagem alternativa: ```none cd && tar -cvf .tar . ``` Primeiro, você precisa **modificar a pasta a ser arquivada** e aplicar o comando `tar` à pasta atual, indicada por um ponto ( . ) no terminal. A combinação desses dois passos com o operador `&&` garante que a compactação seja realizada somente se a alteração da pasta de destino for bem-sucedida. Os arquivos *.tar* criados durante o processo de compactação de dados do Docker podem ser encontrados no sistema host. Estes arquivos compactados devem ser **transferidos para um sistema de backup**, para que o backup seja criado. Para isso, faça uso de algum tipo de armazenamento externo ou em nuvem. Ainda, utilize ferramentas especiais que ajudam com a transferência, como Rsync e S3. Dica Aprenda como [criar backup de servidor com Rsync](https://www.ionos.com/pt-br/digitalguide/servidor/ferramentas/rsync-backup-em-servidor/) no nosso artigo especializado. A tabela abaixo esboça os **passos necessários para a criação de Docker backups**, com os respectivos comandos. Em alguns casos, mais de uma abordagem pode ser usada:
Objeto Docker Criação de backup Exemplo de comando
Contêiner Docker Salvar como imagem Docker `docker container commit `
Imagem Docker Exportar como arquivo *tarball* e enviar ao registro `docker image save`–output`.tar `/ docker image push ``
Volume Docker Montar volume no contêiner e criar arquivos *tarball* a partir do contêiner `docker run --rm --volumes-from --volume bash -c "tar -cvf .tar "`
Pasta do projeto Docker Compose Criar arquivo *tarball*; versionamento com Git `tar -cvf .tar `
Dockerfile Salvar arquivo; versionamento com Git `tar -cvf .tar `
Suponhamos que seus arquivos de backup sejam armazenados em `/backup/ diretório inicial` ao serem criados. Neste caso, crie a seguinte pasta, como passo preparatório: ```none mkdir -p ~/backup/ ``` ### Criar backup do Docker contêiner Dados presentes em contêineres Docker **são armazenados em camadas do tipo somente leitura, em um sistema de arquivos Union**. Um contêiner Docker é baseado em uma imagem somente leitura, contendo, ainda, camada adicional gravável, além de camadas de imagem. Você deve criar uma nova imagem, a partir do contêiner em execução, para **fazer um backup permanente dos dados da camada gravável**. Para tanto, utilize o comando `docker commit`. Faça backup do conteúdo da imagem como arquivo *tarball* seguindo os passos descritos abaixo: 1. Grave o sistema de arquivos Docker como imagem ```none docker container commit ``` 2. Exporte a imagem resultante como arquivo compactado *tarball* ```none docker image save --output ~/backup/.tar ``` Alternativamente, envie a imagem resultante ao repositório, utilizando, para tanto, o comando `docker image push`: ```none docker image push ``` Nota O comando `docker container export` também pode ser usado para exportar o sistema de arquivos do contêiner. No entanto, este procedimento reduz todas as camadas a uma só. Por conta disso, não recomendamos a utilização do comando para a criação de Docker backups. ### Criar backup de imagem Docker Abordagem semelhante é adotada para **fazer backup de uma imagem Docker presente no host local**. Da mesma forma, dados de imagem devem ser gravados em um arquivo *tarball*: ```none docker image save --output ~/backup/.tar ``` ### Criar backup de volume Docker Fazer backup de volumes Docker é um processo mais complexo, pois é preciso separá-los entre *bind mounts*, nomeados e anônimos. O acesso a um volume *bind mount* pode ser feito diretamente, pelo sistema de arquivos host. Exatamente por isso, a geração do arquivo *tarball* relativo à pasta é simples: ```none cd && tar -cvf ~/backup/.tar . ``` Realizar backups de volumes nomeados e anônimos é diferente, pois ambos **só podem ser acessados por meio de contêineres Docker em execução**. O segredo para compactar dados contidos nestes volumes Docker é iniciar um contêiner com acesso aos volumes, portanto. Ao fazer isso, arquive os dados dos volumes por meio do contêiner em execução. O passo a passo esclarece o processo: 1. Interrompa o contêiner com acesso ao volume ```none docker stop ``` 2. Inicie um contêiner temporário e extraia os dados do volume O contêiner temporário tem acesso aos volumes desejados, bem como à pasta de backup no host. ```none docker run --rm --volumes-from --volume ~/backup:/backup ubuntu bash -c "cd && tar -cvf /backup/.tar ." ``` 3. Reinicie o contêiner com acesso ao volume ```none docker start ``` O comando para **extrair dados de volumes Docker é complexo**. Observe, em detalhes, seus componentes individuais:
Componente do comando Explicação
`--rm` Instrui o Docker a remover o novo contêiner após fazer backup do volume.
`--volumes-from ` Monta volumes do contêiner especificado no novo contêiner e torna os dados nele contidos acessíveis.
`--volume ~/backup:/backup` Cria *bind mount* entre a pasta `~/backup/` no sistema host e a pasta `/backup/` dentro do contêiner.
`ubuntu` Especifica que o novo contêiner deve carregar uma imagem Ubuntu Linux.
`bash -c "cd …"` Cria arquivo *tarball* de dados de volume dentro da pasta `/backup/` do contêiner recém-iniciado. A conexão dessa pasta com a pasta `~/backup/`, no sistema host, torna o arquivo compactado acessível fora do Docker.
### Criar backup da pasta do projeto Docker Compose Um arquivo *tarball* também deve ser criado para que o **backup da pasta do projeto Docker Compose** seja realizado com sucesso: ```none cd && tar -cvf ~/backup/.tar . ``` Nota Recomendamos que você faça o versionamento do arquivo `docker-compose.yaml` com Git. O armazenamento de dados sensíveis, como senhas, em arquivos *.env* separados é importante. Exclua-os de verificações de versões com `.gitignore`. ### Criar backup de Dockerfile Mude a pasta que contém o Dockerfile e gere um arquivo *tarball* do mesmo, para a realização de um **backup completo**. Para tanto, faça uso do código abaixo: ```none cd && tar -cvf ~/backup/.tar ./Dockerfile ``` Nota Recomendamos que você faça o versionamento do arquivo *Dockerfile* com Git. O armazenamento de dados sensíveis, como senhas, em arquivos *.env* separados é importante. Exclua-os de verificações de versões com `.gitignore`. ### Criar backups de bancos de dados em contêineres Docker Atualmente, bancos de dados são, em sua grande maioria, baseados em contêineres. Assim, ferramentas de backup específicas para bancos de dados são amplamente utilizadas na **criação de backups de bancos de dados executados em contêineres Docker**. Entre elas estão *mysqldump* e *pg\_dump*. Ambas operam dentro de contêineres Docker. O comando `docker exec` executa a ação, como mostra o exemplo abaixo, relativo a um banco de dados MySQL. Observe que o comando `mysqldump` opera dentro do contêiner. O *dump* resultante é enviado à saída padrão do *shell* do host e gravado na pasta de backup do host local, por meio de um redirecionamento: ```none docker exec /usr/bin/mysqldump --user=root --password= > ~/backup/.sql ``` O **backup de um banco de dados PostgreSQL** executado em um contêiner Docker é feito de forma similar. Caso o nome de usuário e a senha do banco de dados estejam armazenados no arquivo *.pgpass* dentro do contêiner, um backup com formato personalizado de *dump* deve ser criado assim: ```none docker exec pg_dump --format=custom --dbname= > ~/backup/.dump ``` Também é possível criar um clássico **SQL *dump* de texto simples**. Basta que você adicione as opções `--clean` e `--if-exists` ao comando, com o objetivo de limpar o banco de dados de destino antes da importação, para que o *dump* seja importado do sistema de origem sem mensagens de erro: ```none docker exec pg_dump --format=plain --clean --if-exists --dbname= > ~/backup/.dump ``` ## Passo a passo para restaurar um Docker backup Agora que você já sabe como criar backups de dados do Docker, deve aprender **como restaurar dados a partir de um Docker backup**. Suponhamos que todos os backups que você realizou estejam salvos na pasta `~/backup/` do host local. Primeiramente, copie os backups da mídia de backup para a pasta de backup. ### Restaurar contêineres Docker a partir de um backup Lembre-se que geramos uma nova imagem a partir de um contêiner em execução, e a salvamos como arquivo compactado *tarball*, para criarmos o backup de um contêiner Docker. Par **restaurar uma imagem Docker a partir do arquivo *tarball*** correspondente, use o comando `docker image load`: ```none docker image load --input ~/backup/.tar ``` Agora, **inicie um novo contêiner a partir da imagem resultante**. Para iniciar um novo contêiner em segundo plano, faça uso da opção `-detach`: ```none docker run --detach ``` Dica Use o comando `docker image ls` para obter uma lista das imagens Docker disponíveis, bem como dos respectivos nomes e IDs. ### Restaurar imagens Docker a partir de um backup Já ensinamos como **recuperar uma imagem Docker a partir de um arquivo *tarball***: utilizando o comando `docker image load`: ```none docker image load --input ~/backup/.tar ``` ### Restaurar volumes Docker a partir de um backup Restaurar dados de volumes Docker a partir de backups é um processo complexo, pois os passos exatos a serem realizados dependem de cada cenário de implementação. Mostraremos, neste tutorial, como **sobrescrever dados de volume a partir de um backup**, supondo que o sistema seja o mesmo em que o backup foi criado, e que lá estejam presentes contêineres, volumes e outros objetos Docker envolvidos. Caso o sistema tenha sido configurado recentemente, o procedimento será ainda mais complicado. A restauração de um backup de volume Docker requer um **contêiner temporário com acesso ao volume**. O funcionamento deste comando já foi descrito por nosso tutorial. Siga nosso passo a passo detalhado: 1. Interrompa os contêineres que utilizam o volume ```none docker stop ``` 2. Inicie um contêiner temporário com acesso ao volume e copie os dados de backup no volume Docker ```none docker run --rm --volumes-from --volume ~/backup:/backup ubuntu bash -c "cd && tar -xvf /backup/.tar" ``` 3. Reinicie os contêineres que utilizam o volume ```none docker start ``` ### Restaurar pasta do projeto Docker Compose a partir de um backup O processo de restauração da pasta do projeto Docker Compose, a partir de um backup, é bastante direto. Navegue até a pasta do Docker Compose e descompacte o arquivo *tarball* dentro dela. O processo substituirá os dados existentes. ```none cd && tar -xvf ~/backup/.tar ``` ### Restaurar Dockerfile a partir de um backup O processo de restauração de um Dockerfile, a partir de um arquivo *tarball*, é simples. Basta descompactar o arquivo *tarball* dentro da pasta do Dockerfile, para que o Dockerfile existente seja substituído. ```none cd && tar -xvf ~/backup/.tar ``` ### Restaurar bancos de dados de contêineres Docker a partir de um backup Use o comando `docker exec` para restaurar um banco de dados armazenado em um contêiner Docker, a partir de um backup. A opção `--interactive` inicia o contêiner no modo interativo e mantém a entrada padrão aberta. Gere o conteúdo do *dump* MySQL usando o comando `cat`, canalizando a saída para o comando Docker no host local. O comando `mysql`, executado dentro do contêiner, **processa as declarações SQL que reconstroem o banco de dados**. ```none cat ~/backup/.sql | docker exec --interactive < id contêiner> /usr/bin/mysql --user=root --password= ``` O processo de restauração de um banco de dados PostgreSQL é um pouco mais complexo. Para realizá-lo, utilize duas ferramentas de auxílio, que podem ser aplicadas dependendo do formato do *dump* do banco de dados. Execute a ferramenta `pg_restore tool` dentro do contêiner para **restaurar um banco de dados no formato PostgreSQL personalizado**. Use o redirecionamento de entrada para alimentar o arquivo *dump* como entrada: ```none docker exec --interactive pg_restore --dbname= < ~/backup/.dump ``` A **restauração de um *dump* de banco de dados PostgreSQL em texto simples** é similar à restauração de um *dump* MySQL. Gere o arquivo *dump* com o comando `cat` e canalize a saída para o comando `docker exec` com a opção `--interactive`. O comando `psql` é executado dentro do contêiner, para processar comandos SQL e reconstruir o banco de dados. ```none cat ~/backup/.sql | docker exec --interactive psql --user=root --password= ``` This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/seguranca/docker-backup/](https://www.ionos.com/pt-br/digitalguide/servidor/seguranca/docker-backup/) for AI/LLM consumption.