Como usar o comando docker volume create para gerenciar dados

DockerBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como gerenciar efetivamente a persistência de dados no Docker usando o comando docker volume create. Exploraremos o processo fundamental de criação de volumes básicos, que são o método preferido para armazenar dados de contêineres devido à sua natureza gerenciada pelo Docker e à facilidade de backup/migração em comparação com as montagens de ligação (bind mounts).

Com base nos fundamentos, você se aprofundará na criação de volumes com drivers e opções específicas para adaptar seu comportamento. Além disso, o laboratório o guiará na criação de volumes locais com opções de montagem personalizadas e demonstrará como aproveitar o NFS para criar volumes locais, proporcionando flexibilidade para vários cenários de armazenamento de dados.

Criar um volume básico

Nesta etapa, você aprenderá como criar um volume básico do Docker. Volumes são a forma preferida de persistir dados gerados e usados por contêineres Docker. Embora as montagens de ligação (bind mounts) também sejam uma opção, os volumes são gerenciados pelo Docker e geralmente são mais fáceis de fazer backup ou migrar.

Primeiro, vamos criar um volume simples usando o comando docker volume create. Vamos nomear este volume myvolume.

docker volume create myvolume

Você deve ver o nome do volume impresso no console, confirmando sua criação.

Agora, vamos inspecionar o volume para ver seus detalhes usando o comando docker volume inspect. Isso nos mostrará informações como o driver do volume, o ponto de montagem (mountpoint) e o escopo.

docker volume inspect myvolume

A saída fornecerá detalhes sobre o volume. Preste atenção no campo Mountpoint, que mostra a localização na máquina host onde os dados do volume são armazenados. O Docker gerencia essa localização, e você geralmente deve evitar modificar arquivos diretamente neste diretório.

Em seguida, executaremos um contêiner e anexaremos este volume a ele. Usaremos a imagem ubuntu e montaremos myvolume no diretório /app dentro do contêiner. Também executaremos um comando simples para escrever alguns dados em um arquivo dentro do volume montado.

Primeiro, puxe a imagem ubuntu se você não a tiver localmente.

docker pull ubuntu

Agora, execute o contêiner e escreva dados no volume.

docker run -d --name mycontainer -v myvolume:/app ubuntu bash -c "echo 'Hello from the volume!' > /app/greeting.txt && tail -f /dev/null"

Vamos detalhar este comando:

  • docker run -d: Executa o contêiner em modo detached (em segundo plano).
  • --name mycontainer: Atribui o nome mycontainer ao contêiner.
  • -v myvolume:/app: Monta o volume chamado myvolume no diretório /app dentro do contêiner.
  • ubuntu: Especifica a imagem a ser usada.
  • bash -c "echo 'Hello from the volume!' > /app/greeting.txt && tail -f /dev/null": Executa um comando bash dentro do contêiner. Ele escreve a string "Hello from the volume!" em um arquivo chamado greeting.txt no diretório /app (que é o volume montado) e, em seguida, executa tail -f /dev/null para manter o contêiner em execução.

Para verificar se os dados foram escritos no volume, podemos executar um comando dentro do contêiner em execução para ler o arquivo.

docker exec mycontainer cat /app/greeting.txt

Você deve ver a saída "Hello from the volume!", confirmando que os dados foram gravados com sucesso no volume de dentro do contêiner.

Finalmente, vamos parar e remover o contêiner. O volume persistirá mesmo após a remoção do contêiner.

docker stop mycontainer
docker rm mycontainer

Criar um volume com um driver e opções específicos

Nesta etapa, você aprenderá como criar um volume Docker usando um driver específico e fornecendo opções específicas do driver. Embora o driver local padrão seja suficiente para muitos casos de uso, o Docker suporta vários drivers de volume para diferentes backends de armazenamento, como armazenamento de rede ou armazenamento em nuvem.

Continuaremos a usar o driver local, mas demonstraremos como especificá-lo explicitamente e passar opções. O driver local suporta opções como type, device e o para especificar o tipo de sistema de arquivos, o dispositivo a ser montado e as opções de montagem, respectivamente.

Vamos criar um volume chamado myvolume2 usando o driver local e especificar algumas opções. Para este exemplo, usaremos o tipo de sistema de arquivos tmpfs, que armazena dados na memória. Isso é útil para dados temporários que não precisam persistir em reinicializações do host.

docker volume create --driver local --opt type=tmpfs --opt device=tmpfs --opt o=size=100m myvolume2

Vamos detalhar este comando:

  • docker volume create: O comando para criar um volume.
  • --driver local: Especifica explicitamente o driver de volume local.
  • --opt type=tmpfs: Passa a opção type=tmpfs para o driver, especificando o tipo de sistema de arquivos.
  • --opt device=tmpfs: Passa a opção device=tmpfs para o driver, especificando o dispositivo. Para tmpfs, o dispositivo também é tmpfs.
  • --opt o=size=100m: Passa a opção o=size=100m para o driver. A opção o é usada para passar opções de montagem. Neste caso, estamos definindo o tamanho máximo do volume tmpfs para 100 megabytes.
  • myvolume2: O nome do volume a ser criado.

Você deve ver o nome do volume impresso no console após a criação bem-sucedida.

Agora, vamos inspecionar o volume para ver o driver e as opções que foram aplicadas.

docker volume inspect myvolume2

Na saída, você deve ver o campo Driver definido como local e o campo Options listando as opções que fornecemos (type=tmpfs, device=tmpfs, o=size=100m). O Mountpoint mostrará onde este volume tmpfs está montado no host.

Em seguida, executaremos um contêiner e anexaremos este novo volume a ele. Usaremos a imagem ubuntu novamente e montaremos myvolume2 no diretório /data dentro do contêiner.

Primeiro, puxe a imagem ubuntu se você não a tiver localmente (embora provavelmente já a tenha da etapa anterior).

docker pull ubuntu

Agora, execute o contêiner e anexe o volume.

docker run -d --name mycontainer2 -v myvolume2:/data ubuntu tail -f /dev/null

Este comando executa um contêiner ubuntu chamado mycontainer2 em modo detached e monta myvolume2 em /data. tail -f /dev/null mantém o contêiner em execução.

Como myvolume2 é um volume tmpfs, quaisquer dados gravados em /data dentro do contêiner serão armazenados na memória e não persistirão após o contêiner ser parado e removido, ou se o host for reiniciado.

Vamos parar e remover o contêiner.

docker stop mycontainer2
docker rm mycontainer2

O volume myvolume2 ainda existe, mas seu conteúdo (se algum foi escrito) desapareceu porque é um volume tmpfs.

Criar um volume local com opções de montagem

Nesta etapa, você aprenderá como criar um volume Docker local e especificar opções de montagem. As opções de montagem permitem que você controle como o sistema de arquivos é montado, como definir permissões, habilitar recursos específicos ou otimizar o desempenho.

Criaremos um volume local chamado myvolume3 e usaremos a opção o para especificar opções de montagem. Para este exemplo, definiremos as opções uid e gid para garantir que os arquivos criados no volume por um contêiner pertençam a um usuário e grupo específicos no host. Isso pode ser útil para gerenciar permissões ao compartilhar dados entre contêineres e o host.

Primeiro, vamos criar um diretório no host que usaremos como fonte para nosso volume. Isso não é estritamente necessário para um volume local padrão, mas ajuda a ilustrar como as opções de montagem podem afetar o sistema de arquivos subjacente.

mkdir -p ~/project/myvolumedata

Agora, vamos criar o volume myvolume3 usando o driver local e especificar a opção o com uid e gid. Usaremos o ID do usuário e do grupo do usuário labex atual. Você pode encontrar seu ID de usuário e grupo usando os comandos id -u e id -g.

USER_ID=$(id -u)
GROUP_ID=$(id -g)
docker volume create --driver local --opt type=none --opt device=/home/labex/project/myvolumedata --opt o=bind,uid=$USER_ID,gid=$GROUP_ID myvolume3

Vamos detalhar este comando:

  • docker volume create: O comando para criar um volume.
  • --driver local: Especifica o driver de volume local.
  • --opt type=none: Especifica que nenhum tipo de sistema de arquivos deve ser criado automaticamente. Estamos vinculando a um diretório existente.
  • --opt device=/home/labex/project/myvolumedata: Especifica o dispositivo a ser montado, que é o diretório que criamos no host. Observe o uso do caminho absoluto /home/labex/project/myvolumedata.
  • --opt o=bind,uid=$USER_ID,gid=$GROUP_ID: Passa as opções de montagem.
    • bind: Especifica uma montagem de ligação (bind mount), vinculando o volume ao dispositivo especificado (nosso diretório do host).
    • uid=$USER_ID: Define o ID do usuário para arquivos criados no volume para o ID do usuário atual.
    • gid=$GROUP_ID: Define o ID do grupo para arquivos criados no volume para o ID do grupo do usuário atual.
  • myvolume3: O nome do volume.

Você deve ver o nome do volume impresso no console.

Agora, vamos inspecionar o volume para ver as opções.

docker volume inspect myvolume3

Na saída, você deve ver o Driver como local, as Options incluindo type=none, device=/home/labex/project/myvolumedata e o=bind,uid=...,gid=... (com seus IDs de usuário e grupo). O Mountpoint será o mesmo que o caminho do device.

Em seguida, executaremos um contêiner e anexaremos este volume. Usaremos a imagem ubuntu e montaremos myvolume3 em /app dentro do contêiner. Em seguida, criaremos um arquivo dentro do diretório /app do contêiner e verificaremos sua propriedade no host.

Primeiro, puxe a imagem ubuntu se necessário.

docker pull ubuntu

Agora, execute o contêiner e crie um arquivo no volume montado.

docker run --rm -v myvolume3:/app ubuntu bash -c "echo 'Testing ownership' > /app/testfile.txt && ls -l /app/testfile.txt"

Este comando executa um contêiner ubuntu, monta myvolume3 em /app, escreve "Testing ownership" em /app/testfile.txt e, em seguida, lista os detalhes do arquivo dentro do contêiner. Você deve ver o arquivo listado com propriedade root dentro do contêiner, pois os contêineres normalmente são executados como root por padrão.

Agora, vamos verificar a propriedade do arquivo na máquina host no diretório ~/project/myvolumedata.

ls -l ~/project/myvolumedata/testfile.txt

Você deve ver que o arquivo testfile.txt pertence ao usuário e grupo labex no host, graças às opções de montagem uid e gid que especificamos ao criar o volume.

Finalmente, vamos limpar o diretório criado.

rm -rf ~/project/myvolumedata

Criar um volume local usando NFS

Nesta etapa, você aprenderá como criar um volume Docker local que usa um compartilhamento NFS como seu armazenamento de backend. Isso permite que os contêineres armazenem dados em um dispositivo de armazenamento conectado à rede, tornando os dados acessíveis de vários hosts e fornecendo uma solução de armazenamento centralizada.

Para usar NFS com o driver de volume local, você precisa especificar o endereço do servidor NFS e o caminho para o diretório compartilhado usando a opção device e o tipo de sistema de arquivos como nfs usando a opção type. Você também precisa fornecer opções de montagem apropriadas usando a opção o.

Para este ambiente de laboratório, simularemos um compartilhamento NFS usando o endereço de loopback 127.0.0.1 e um diretório no host. Observação: Em um cenário do mundo real, você substituiria 127.0.0.1 pelo endereço IP ou nome de host real do seu servidor NFS e /path/to/nfs/share pelo caminho exportado no servidor NFS.

Primeiro, vamos criar um diretório no host que atuará como nosso compartilhamento NFS simulado.

mkdir -p ~/project/nfs_share

Agora, vamos criar o volume myvolume4 usando o driver local com opções NFS.

sudo docker volume create --driver local --opt type=nfs --opt device=127.0.0.1:/home/labex/project/nfs_share --opt o=addr=127.0.0.1,rw myvolume4

Vamos detalhar este comando:

  • sudo docker volume create: Usamos sudo porque a criação de volumes NFS geralmente requer privilégios de root para executar a operação de montagem no host.
  • --driver local: Especifica o driver de volume local.
  • --opt type=nfs: Especifica o tipo de sistema de arquivos como NFS.
  • --opt device=127.0.0.1:/home/labex/project/nfs_share: Especifica o dispositivo NFS. Este está no formato nfs_server_address:/exported_path. Estamos usando o endereço de loopback e o diretório que acabamos de criar. Observe o uso do caminho absoluto /home/labex/project/nfs_share.
  • --opt o=addr=127.0.0.1,rw: Passa opções de montagem para o cliente NFS.
    • addr=127.0.0.1: Especifica o endereço do servidor NFS.
    • rw: Monta o compartilhamento com permissões de leitura e gravação.
  • myvolume4: O nome do volume.

Você deve ver o nome do volume impresso no console após a criação bem-sucedida.

Agora, vamos inspecionar o volume para ver os detalhes específicos do NFS.

docker volume inspect myvolume4

Na saída, você deve ver o Driver como local, e as Options devem incluir type=nfs, device=127.0.0.1:/home/labex/project/nfs_share e o=addr=127.0.0.1,rw. O Mountpoint mostrará onde este volume NFS está montado no host pelo Docker.

Em seguida, executaremos um contêiner e anexaremos este volume NFS. Usaremos a imagem ubuntu e montaremos myvolume4 em /data dentro do contêiner. Em seguida, criaremos um arquivo dentro do diretório /data do contêiner e verificaremos sua existência no compartilhamento NFS simulado do host.

Primeiro, puxe a imagem ubuntu se necessário.

docker pull ubuntu

Agora, execute o contêiner e crie um arquivo no volume montado.

docker run --rm -v myvolume4:/data ubuntu bash -c "echo 'Data on NFS' > /data/nfs_test.txt && ls -l /data/nfs_test.txt"

Este comando executa um contêiner ubuntu, monta myvolume4 em /data, escreve "Data on NFS" em /data/nfs_test.txt e lista os detalhes do arquivo dentro do contêiner.

Agora, vamos verificar o arquivo na máquina host no diretório ~/project/nfs_share.

ls -l ~/project/nfs_share/nfs_test.txt

Você deve ver o arquivo nfs_test.txt listado, confirmando que os dados gravados dentro do contêiner usando o volume NFS estão presentes no compartilhamento NFS simulado do host.

Finalmente, vamos limpar o diretório criado.

rm -rf ~/project/nfs_share

Resumo

Neste laboratório, você aprendeu como criar e gerenciar volumes Docker usando o comando docker volume create. Você começou criando um volume básico e inspecionando seus detalhes, entendendo como o Docker gerencia o local de armazenamento de dados. Em seguida, você praticou a anexação desse volume a um contêiner e a escrita de dados nele, demonstrando como os volumes fornecem armazenamento persistente para dados de contêineres. O laboratório também abordou a criação de volumes com drivers e opções específicos, incluindo volumes locais com opções de montagem e volumes locais usando NFS, mostrando a flexibilidade e os vários casos de uso dos volumes Docker para diferentes necessidades de armazenamento.