Como fazer backup de um Docker Volume

Verificação do ambiente:

$ docker volume ls
DRIVER    VOLUME NAME
$ docker container ls -a
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
$ docker image ls -a
REPOSITORY      TAG       IMAGE ID       CREATED             SIZE
ubuntu-volume   latest    beb3081df225   About an hour ago   77.9MB

/tmp/volume/volume$ cat Dockerfile
FROM ubuntu:22.04
VOLUME /app
WORKDIR /app

Execução de container utilizando volume sem mapeamento, criação de arquivos de teste e a simulação de uma saída inesperada:

/tmp/volume/volume$ docker container run -it ubuntu-volume
/bin/bash
root@adb37bf1d48d:/app#
root@adb37bf1d48d:/app# ls
root@adb37bf1d48d:/app# touch teste1.txt
root@adb37bf1d48d:/app# touch teste2.txt
root@adb37bf1d48d:/app# ls
teste1.txt teste2.txt
root@adb37bf1d48d:/app# exit # saída inesperada
/tmp/volume/volume$
/tmp/volume/volume$ docker container ls -a
CONTAINER ID   IMAGE           COMMAND       CREATED         STATUS
        PORTS     NAMES
adb37bf1d48d   ubuntu-volume   "/bin/bash"   2 minutes ago   Exited (0) 4 seconds ago             sweet_nash

Volume criado:

$ docker volume ls
DRIVER    VOLUME NAME
local     9b1d5ee392c8fea1df2c48f71e2db90a5ceed3a30eee699914f1c2941ac617bf

$ docker volume inspect 9b1d5ee392c8fea1df2c48f71e2db90a5ceed3a30eee699914f1c2941ac617bf
[
    {
        "CreatedAt": "2024-08-25T15:03:33-03:00",
        "Driver": "local",
        "Labels": {
            "com.docker.volume.anonymous": ""
        },
        "Mountpoint": "/var/lib/docker/volumes/9b1d5ee392c8fea1df2c48f71e2db90a5ceed3a30eee699914f1c2941ac617bf/_data",
        "Name": "9b1d5ee392c8fea1df2c48f71e2db90a5ceed3a30eee699914f1c2941ac617bf",
        "Options": null,
        "Scope": "local"
    }
]

Não é recomendável manipular o diretório do volume.

$ docker container ls -a
CONTAINER ID   IMAGE           COMMAND       CREATED         STATUS
        PORTS     NAMES
adb37bf1d48d   ubuntu-volume   "/bin/bash"   5 minutes ago   Exited (0) 3 minutes ago             sweet_nash

Criação de outro container que mapeará o volume utilizado pelo container que teve sua saída inesperada para backup dos dados:

/tmp/volume/volume$ docker container run --volumes-from adb37bf1d48d 
    --rm -v $(pwd):/backup ubuntu:22.04 tar cvf /backup/backup_vol.tar /app
Unable to find image 'ubuntu:22.04' locally
22.04: Pulling from library/ubuntu
857cc8cb19c0: Already exists
Digest: sha256:adbb90115a21969d2fe6fa7f9af4253e16d45f8d4c1e930182610c4731962658
Status: Downloaded newer image for ubuntu:22.04
tar: Removing leading `/' from member names
/app/
/app/teste2.txt
/app/teste1.txt

Explicação do comando

Este comando Docker executa uma série de operações usando um contêiner temporário para criar um backup de dados de outro contêiner. Vou explicar cada parte do comando para que você entenda seu funcionamento completo.

Comando Completo

docker container run --volumes-from adb37bf1d48d \
    --rm -v $(pwd):/backup ubuntu:22.04 \
    tar cvf /backup/backup_vol.tar /app

Explicação dos Componentes

1. docker container run: Este comando cria e executa um contêiner a partir de uma imagem especificada (neste caso, ubuntu:22.04).

2. --volumes-from adb37bf1d48d:

   • Este parâmetro monta todos os volumes de outro contêiner (adb37bf1d48d) no novo contêiner.

   • adb37bf1d48d é o ID ou nome do contêiner existente do qual você está montando os volumes. Todos os volumes que estão em uso por esse contêiner serão montados no novo contêiner que está sendo criado.

3. --rm:

   • Esta opção remove automaticamente o contêiner assim que ele terminar de executar. Isso é útil para evitar acúmulo de contêineres temporários.

4. -v $(pwd):/backup:

   • Este parâmetro monta um volume do host dentro do contêiner.

   • $(pwd) é uma substituição de comando que retorna o diretório atual (onde você está executando o comando).

   • Isso significa que o diretório atual do host será montado no contêiner no caminho /backup.

5. ubuntu:22.04:

   • A imagem Docker a ser usada para criar o contêiner. Neste caso, é a imagem ubuntu na versão 22.04.

6. tar cvf /backup/backup_vol.tar /app:

   • Este é o comando a ser executado dentro do contêiner.

   • tar cvf: Cria um arquivo tar (.tar).

   • /backup/backup_vol.tar: Define o nome e o caminho do arquivo tar que será criado. Ele será armazenado no diretório /backup dentro do contêiner, que corresponde ao diretório atual do host por causa do volume montado.

   • /app: É o diretório dentro do contêiner que está sendo arquivado. Este diretório está montado a partir do volume do contêiner original (adb37bf1d48d).

O Que Este Comando Faz?

1. Cria um contêiner temporário usando a imagem ubuntu:22.04.

2. Monta os volumes do contêiner adb37bf1d48d no novo contêiner.

3. Monta o diretório atual do host (onde o comando foi executado) no contêiner no caminho /backup.

4. Executa o comando tar para criar um arquivo de backup (backup_vol.tar) do diretório /app no contêiner. Este diretório está montado a partir dos volumes do contêiner adb37bf1d48d.

5. O arquivo de backup (backup_vol.tar) é salvo no diretório atual do host.

6. Após o término do comando tar, o contêiner é removido automaticamente por causa da opção --rm.

Resumo

Este comando cria um backup dos dados armazenados em um volume de outro contêiner (adb37bf1d48d) e salva esse backup como um arquivo tar (backup_vol.tar) no diretório atual do host. O contêiner é criado temporariamente para realizar esta tarefa e é removido logo após a conclusão do backup.

Verificação do arquivo compactado do backup no diretório atual:

/tmp/volume/volume$ ls
Dockerfile  backup_vol.tar
/tmp/volume/volume$ tar -xvf backup_vol.tar
app/
app/teste2.txt
app/teste1.txt
/tmp/volume/volume$ ls
Dockerfile  app  backup_vol.tar

Restaurar o backup em um novo volume mapeado:

$ docker volume create novo_volume
$ docker volume ls
DRIVER    VOLUME NAME
local     9b1d5ee392c8fea1df2c48f71e2db90a5ceed3a30eee699914f1c2941ac617bf
local     novo_volume
$ docker container run -v $(pwd):/backup
-v novo_volume:/app ubuntu:22.04 tar xvf /backup/backup_vol.tar
app/
app/teste2.txt
app/teste1.txt
$ docker volume inspect novo_volume
[
    {
        "CreatedAt": "2024-08-25T15:52:25-03:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/novo_volume/_data",
        "Name": "novo_volume",
        "Options": null,
        "Scope": "local"
    }
]
$ sudo tree /var/lib/docker/volumes/novo_volume/
[sudo] password for marcelo:
/var/lib/docker/volumes/novo_volume/
└── _data
    ├── teste1.txt
    └── teste2.txt

1 directory, 2 files
$ docker container run -it -v novo_volume:/app ubuntu:22.04 /bin/bash
root@67ce322dab08:/# ls
app  boot  etc   lib    lib64   media  opt   root  sbin  sys  usr
bin  dev   home  lib32  libx32  mnt    proc  run   srv   tmp  var
root@67ce322dab08:/# cd app
root@67ce322dab08:/app# ls
teste1.txt  teste2.txt

Explicação do conjunto de comandos executados

Este conjunto de comandos Docker ilustra como criar um volume, restaurar arquivos de um backup para esse volume, e depois verificar o conteúdo do volume dentro de um contêiner. Vou explicar cada passo detalhadamente.

Passo a Passo Explicado

1. Criação de um Novo Volume:

   $ docker volume create novo_volume

   • Aqui, um novo volume chamado novo_volume é criado. Volumes Docker são usados para armazenar dados persistentes, que podem ser compartilhados entre diferentes contêineres.

   • Este comando retorna o nome do volume criado, que será novo_volume.

2. Listando os Volumes Existentes:

   $ docker volume ls

   • Este comando lista todos os volumes disponíveis no Docker.

   • Na saída, você vê dois volumes: um volume com um nome gerado automaticamente (9b1d5ee392c8...) e o volume novo_volume que você acabou de criar.

3. Restaurando Arquivos de um Backup para o Volume:

   $ docker container run -v $(pwd):/backup -v novo_volume:/app ubuntu:22.04 tar xvf /backup/backup_vol.tar

   • -v $(pwd):/backup: Monta o diretório atual do host ($(pwd)) no contêiner no caminho /backup. Isso permite que o contêiner acesse arquivos no diretório atual do host.

   • -v novo_volume:/app: Monta o volume novo_volume no contêiner no caminho /app. Isso significa que qualquer arquivo extraído para /app dentro do contêiner será armazenado no volume novo_volume.

   • ubuntu:22.04: A imagem Docker usada para criar o contêiner.

   • tar xvf /backup/backup_vol.tar: Executa o comando tar dentro do contêiner para extrair (xvf) o conteúdo do arquivo backup_vol.tar localizado em /backup para o diretório /app.

   • Após a execução, o volume novo_volume agora contém os arquivos teste1.txt e teste2.txt no diretório /app.

4. Inspecionando o Volume:

   $ docker volume inspect novo_volume

   • Este comando exibe informações detalhadas sobre o volume novo_volume.

   • A saída mostra o caminho de montagem (Mountpoint), onde os dados do volume estão fisicamente armazenados no host (/var/lib/docker/volumes/novo_volume/_data).

5. Verificando o Conteúdo do Volume Diretamente no Host:

   $ sudo tree /var/lib/docker/volumes/novo_volume/

   • O comando tree exibe a estrutura de diretórios e arquivos dentro do volume novo_volume no host.

   • A saída mostra que o volume contém dois arquivos: teste1.txt e teste2.txt, que foram extraídos do arquivo tar.

6. Acessando o Volume de Dentro de um Contêiner:

   $ docker container run -it -v novo_volume:/app ubuntu:22.04 /bin/bash

   • -it: Inicia o contêiner em modo interativo com um terminal (/bin/bash).

   • -v novo_volume:/app: Monta o volume novo_volume no diretório /app dentro do contêiner.

   • ubuntu:22.04 /bin/bash: Usa a imagem ubuntu:22.04 para iniciar o contêiner e executa o shell Bash (/bin/bash).

   Dentro do contêiner:

   • ls: Lista os diretórios e arquivos na raiz do sistema de arquivos do contêiner, onde o diretório /app aparece como montado.

   • cd app e ls: Navega para o diretório /app e lista os arquivos, confirmando que teste1.txt e teste2.txt estão presentes no volume montado.

Resumo

Este conjunto de comandos demonstra o processo completo de criação de um volume Docker, restauração de arquivos de um backup para o volume, e verificação dos arquivos restaurados tanto no host quanto de dentro de um contêiner. Isso é útil em cenários onde você precisa garantir que os dados de backup foram restaurados corretamente e estão acessíveis para uso em outros contêineres.

VolumesDocker Documentation