====== Gerenciando Volumes e Plugins no Docker ======

===== Storage Drivers/Volumes/Bind Mount =====
O Docker usa um driver de armazenamento para criar uma camada de abstração entre os sistemas de arquivos do host e o sistema de arquivos do container do Docker. O Docker suporta vários drivers de armazenamento, cada um com suas próprias características e vantagens. Aqui estão alguns dos mais comuns:

  * **devicemapper**: este é o driver de armazenamento padrão do Docker para sistemas Linux. Ele usa um dispositivo lógico do Linux (LVM) para criar um volume de blocos para o container;
  * **overlay**: este é um driver de armazenamento do Linux que fornece suporte a vários sistemas de arquivos, como o ext3 e o ext4. Ele usa um sistema de arquivos overlay para criar um volume de blocos para o container;
  * **aufs**: este é um driver de armazenamento do Linux que fornece suporte a vários sistemas de arquivos, como o ext3 e o ext4. Ele usa um sistema de arquivos em modo de espelho para criar um volume de blocos para o container;
  * **btrfs**: este é um driver de armazenamento do Linux que fornece suporte a vários sistemas de arquivos, como o ext3 e o ext4. Ele usa um sistema de arquivos Btrfs para criar um volume de blocos para o container;
  * **zfs**: este é um driver de armazenamento do Linux que fornece suporte a vários sistemas de arquivos, como o ext3 e o ext4. Ele usa um sistema de arquivos ZFS para criar um volume de blocos para o container.

Cada um destes drivers de armazenamento tem suas próprias vantagens e desvantagens. Por exemplo, o driver de armazenamento do devicemapper é o driver de armazenamento padrão do Docker para sistemas Linux, mas ele não é compatível com o Windows. O driver de armazenamento do overlay é compatível com o Windows, mas não é o driver de armazenamento padrão do Docker para sistemas Linux.

Qual driver de armazenamento você deve usar? Isso depende de suas necessidades específicas.
Se você precisar usar o Docker no Windows, você terá que usar o driver de armazenamento do overlay. Se você precisar de mais compatibilidade com sistemas de arquivos do Linux, você poderá usar o driver de armazenamento do aufs. Se você precisar de suporte ao Btrfs, você terá que usar o driver de armazenamento do btrfs.

===== Bind Mounts =====
Bind Mounts têm funcionalidade limitada em comparação com volumes, mas ainda são úteis para fins de desenvolvimento ou teste. Você pode usar uma montagem de ligação para montar um arquivo ou diretório de sua máquina host em um contêiner.

Um Bind Mount é especificado no comando de execução do Docker usando a flag ''--mount''.
<code bash>
docker container run --mount type=bind,source=</path/to/file>,target=/path/to/container example/image
</code>

Também é possível especificar o acesso somente leitura a uma montagem de ligação usando a flag :''ro'' conforme mostrado abaixo.
<code bash>
docker run --mount type=bind,source=</path/to/file>,target=/path/to/container, readonly example/image
</code>

Bind Mounts têm funcionalidade limitada em comparação com volumes, que podem ser montados em vários nós ao mesmo tempo, permitindo que os dados sejam compartilhados entre vários pods no Kubernetes. Eles também permitem que os dados sejam migrados para outros nós facilmente, caso um nó fique indisponível.

===== Volumes =====
Os volumes do Docker permitem que os usuários criem pontos de montagem dentro de uma imagem do Docker para que os dados possam ser preservados e compartilhados entre diferentes contêineres. Os volumes do Docker também podem ser usados para compartilhar arquivos entre um host e um contêiner.

Os volumes do Docker são úteis para armazenar dados persistentes gerados e usados por contêineres. Os volumes são mais fáceis de fazer backup, restaurar e migrar do que os dados armazenados na camada gravável de um contêiner. Você pode criar um novo volume usando o comando docker volume create.

Os volumes são o mecanismo preferencial para a persistência de dados gerados e usados por contêineres do Docker. Os volumes são mais fáceis de fazer backup, restaurar e gerenciar do que vincular montagens. Você pode usar volumes para manter dados, arquivos de configuração e imagens carregadas, por exemplo. Os volumes são projetados para manter os dados, independentemente do ciclo de vida do contêiner.

Volumes são mais fáceis de fazer backup ou migrar do que Bind Mounts, porque você não precisa se preocupar com os detalhes do sistema de arquivos subjacente. Os volumes são armazenados em uma parte do sistema de arquivos do host que é gerenciado pelo Docker no diretório /var/lib/docker/volumes no Linux.

==== Tipos de volumes ====
  * Bind Mounts: Uma montagem de ligação compartilha uma parte do sistema de arquivos do host com o contêiner. Isso permite que o contêiner acesse arquivos no host.

  * Volumes nomeados: Um volume nomeado não usa o sistema de arquivos do host. Os dados são armazenados em um diretório no host gerenciado pelo Docker.

  * Volumes Tmpfs: Um volume tmpfs armazena seus dados na memória do host. Isso é útil para armazenar dados que são acessados com frequência, mas podem ser descartados quando o contêiner é interrompido ou reiniciado.

==== Gerenciando Containers com Bind Mount ====
Mapeando o diretório ''site'' para ''/var/www/html'' do container.
<code bash>
mkdir site
echo 'Bind Mount' > site/index.html
</code>

<code bash>
docker container run -di --name web -h web --mount type=bind,source=$PWD/site,target=/var/www/html -p 80:80 php:7.2-apache
</code>

<code bash>
docker container inspect web | grep Mounts -A 5
            "Mounts": [
                {
                    "Type": "bind",
                    "Source": "/home/gean/site",
                    "Target": "/var/www/html"
                }
--
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/home/gean/site",
                "Destination": "/var/www/html",
                "Mode": "",
</code>

<code bash>
docker container rm -f web
web
</code>

==== Use Montagem somente leitura ====
<code bash>
mkdir html
echo 'Site Somente Leitura' > html/index.html
</code>

<code bash>
docker container run -di --name web -h web --mount type=bind,source=$PWD/html,target=/usr/share/nginx/html,readonly -p 80:80 nginx
</code>

<code bash>
curl localhost
Somente Leitura
</code>

**Vamos testar o mapeamento tentando copiar um novo arquivo para o diretório ''/usr/share/nginx/html/''**:
<code bash>
echo 'Novo site' > index.html 
</code>

<code bash>
docker container cp index.html web:/usr/share/nginx/html/
Successfully copied 2.05kB to web:/usr/share/nginx/html/
Error response from daemon: mounted volume is marked read-only
</code>

<code bash>
docker container inspect web | grep Mounts -A5
            "Mounts": [
                {
                    "Type": "bind",
                    "Source": "/home/gean/html",
                    "Target": "/usr/share/nginx/html",
                    "ReadOnly": true
--
        "Mounts": [
            {
                "Type": "bind",
                "Source": "/home/gean/html",
                "Destination": "/usr/share/nginx/html",
                "Mode": "",
</code>

<code bash>
docker container rm -f web
web
</code>

**Descrição das opções**:
  * A flag **–mount** consiste em vários pares de valores-chave, separados por vírgulas e cada uma consistindo em uma tupla **<key> = <value>**. A sintaxe --mount é mais detalhada do que **-v** ou **--volume**, mas a ordem das chaves não é significativa e o valor do sinalizador é mais fácil de entender;
  * A opção **type** pode ser **bind**, **volume** ou **tmpfs**;
  * A opção **source** define o caminho para o arquivo ou diretório no host do daemon e do Docker. Pode ser especificado como source ou **src**;
  * A opção **target** recebe como valor o caminho em que o arquivo ou diretório está montado no container;
  * A opção **readonly**, se presente, faz com que a montagem de ligação seja montada no container como somente leitura.

===== Gerenciando Containers com Volumes =====

==== Volume do tipo host ====
Para mapear um volume no container com um diretório no host hospedeiro, use a flag **-v** do comando docker **run**:

<code bash>
docker container run -dit --name=server -h server -v /srv:/srv busybox
657c62ec8903c03259600973f0ac80e52fbd711409b2edc7cb51fb746eb0fcc7
</code>

Faça um teste copiando arquivos no host hospedeiro, e verifique se o conteúdo é mapeado no volume do container:
<code bash>
docker container exec server ls /srv
</code>

<code bash>
sudo cp /etc/*.conf /srv/
</code>

<code bash>
docker container exec server ls /srv
adduser.conf
ca-certificates.conf
debconf.conf
deluser.conf
e2scrub.conf
fuse.conf
gai.conf
hdparm.conf
host.conf
kernel-img.conf
ld.so.conf
libaudit.conf
logrotate.conf
mke2fs.conf
multipath.conf
nftables.conf
nsswitch.conf
overlayroot.conf
overlayroot.local.conf
pam.conf
resolv.conf
rsyslog.conf
sudo.conf
sudo_logsrvd.conf
sysctl.conf
ucf.conf
usb_modeswitch.conf
xattr.conf
</code>

<code bash>
docker container rm -f server
server
</code>

==== Criar Volumes do tipo não nomeado ====
<code bash>
docker container run -di --name=server -v /volume busybox
321ce4bb049179ce1c4e4988067df2955c2ef2039672d6755127a5b91d021590
</code>

<code bash>
docker container inspect server | grep volume
                "Type": "volume",
                "Source": "/var/lib/docker/volumes/0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34/_data",
                "Destination": "/volume",
                "/volume": {}
</code>

Veja que o Docker criou um hash representando o novo volume criado:
<code bash>
$ docker volume ls
DRIVER    VOLUME NAME
local     0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34
</code>

<code bash>
docker volume inspect 0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34
[
    {
        "CreatedAt": "2024-10-07T18:43:25Z",
        "Driver": "local",
        "Labels": {
            "com.docker.volume.anonymous": ""
        },
        "Mountpoint": "/var/lib/docker/volumes/0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34/_data",
        "Name": "0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34",
        "Options": null,
        "Scope": "local"
    }
]
</code>

Veja também no interior do container o volume:
<code bash>
docker container exec server df -Th /volume
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/vda1            ext4           30.8G      4.1G     26.7G  13% /volume
</code>

<code bash>
docker container exec server df -Th /volume
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/vda1            ext4           30.8G      4.1G     26.7G  13% /volume
</code>

<code bash>
docker container exec server ls volume
</code>

Copie arquivos no host hospedeiro e verifique se o conteúdo é mapeado no volume:
<code bash>
sudo cp /etc/*.conf /var/lib/docker/volumes/0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34/_data
</code>

<code bash>
docker container exec server ls volume
adduser.conf
ca-certificates.conf
debconf.conf
deluser.conf
e2scrub.conf
fuse.conf
gai.conf
hdparm.conf
host.conf
kernel-img.conf
ld.so.conf
libaudit.conf
logrotate.conf
mke2fs.conf
multipath.conf
nftables.conf
nsswitch.conf
overlayroot.conf
overlayroot.local.conf
pam.conf
resolv.conf
rsyslog.conf
sudo.conf
sudo_logsrvd.conf
sysctl.conf
ucf.conf
usb_modeswitch.conf
xattr.conf
</code>

==== Usar Volume de Outro Container ====
Para utilizar um volume existente de outro container use a opção ''--volumes-from'' quando executar um novo container:
<code bash>
docker container run -di --name=client -h client --volumes-from server busybox
9bd272dc94410098b16c5714365e384ae9a1fc4805930d3722f726290634f13b
</code>

Verifique se no novo container o volume mapeado está montado e com conteúdo:
<code bash>
docker container exec client df -Th /volume
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/vda1            ext4           30.8G      4.1G     26.7G  13% /volume
<code bash>

</code>
docker container exec client ls volume
adduser.conf
ca-certificates.conf
debconf.conf
deluser.conf
e2scrub.conf
fuse.conf
gai.conf
hdparm.conf
host.conf
kernel-img.conf
ld.so.conf
libaudit.conf
logrotate.conf
mke2fs.conf
multipath.conf
nftables.conf
nsswitch.conf
overlayroot.conf
overlayroot.local.conf
pam.conf
resolv.conf
rsyslog.conf
sudo.conf
sudo_logsrvd.conf
sysctl.conf
ucf.conf
usb_modeswitch.conf
xattr.conf
<code bash>

</code>
docker container rm -f client
client
</code>

==== Remover Volumes ====
<code bash>
docker container rm -f server
server
</code>

<code bash>
docker volume prune 
WARNING! This will remove anonymous local volumes not used by at least one container.
Are you sure you want to continue? [y/N] y
Deleted Volumes:
0b69e5958d95c6183ad83d2d0e27cda6cdfd15b19b9ca71395014ddb0778fe34

Total reclaimed space: 54.1kB
</code>

Descrição dos comandos
  * **docker run -v /volume:/volume**: Permite criar e mapear um novo volume no momento da execução de um container;
  * **docker container exec**: Permite executar um comando diretamente em um container.
  * **docker volume**: Permite gerenciar volumes no Docker;
  * **docker volume ls**: Lista os volumes disponíveis no Docker;
  * **docker volume inspect**: Exibe informações detalhadas sobre um ou mais volumes;
  * **docker volume rm**: Permite remover um volume disponível no Docker;
  * **docker volume prune**: Remove volumes não utilizados;
  * **docker run –volumes-from**: Permite mapear um volume que está sendo utilizado por outro container.

==== Criar volumes personalizado ====
Para criar um volume definindo o tipo, nome e tamanho, execute o comando abaixo:
<code bash>
docker volume create -d local --opt type=tmpfs --opt device=tmpfs --opt o=size=1000m --name dca
dca
</code>

<code bash>
docker volume ls
DRIVER    VOLUME NAME
local     dca
</code>

<code bash>
docker volume inspect dca
[
    {
        "CreatedAt": "2024-10-07T20:30:31Z",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/dca/_data",
        "Name": "dca",
        "Options": {
            "device": "tmpfs",
            "o": "size=1000m",
            "type": "tmpfs"
        },
        "Scope": "local"
    }
]
</code>

Use a flag -v, apontando o volume personalizado e o diretório mapeado no container:
<code bash>
docker container run -di --name=server -h server -v dca:/backup busybox
7bcf213a863dc2b36b800f02ca5cf89abee1c6c653dd2baaae5ec8e45b0ab5ad
</code>

<code bash>
docker container inspect server | grep volume
                "Type": "volume",
                "Source": "/var/lib/docker/volumes/dca/_data",
</code>

<code bash>
docker container exec server df -Th backup
Filesystem           Type            Size      Used Available Use% Mounted on
tmpfs                tmpfs        1000.0M         0   1000.0M   0% /backup
</code>

Faça um teste copiando arquivos no host hospedeiro, e verifique se o conteúdo é mapeado no volume personalizado do container:
<code bash>
sudo cp /etc/*.conf /var/lib/docker/volumes/dca/_data
</code>

<code bash>
docker container exec server ls backup
adduser.conf
ca-certificates.conf
debconf.conf
deluser.conf
e2scrub.conf
fuse.conf
gai.conf
hdparm.conf
host.conf
kernel-img.conf
ld.so.conf
libaudit.conf
logrotate.conf
mke2fs.conf
multipath.conf
nftables.conf
nsswitch.conf
overlayroot.conf
overlayroot.local.conf
pam.conf
resolv.conf
rsyslog.conf
sudo.conf
sudo_logsrvd.conf
sysctl.conf
ucf.conf
usb_modeswitch.conf
xattr.conf
</code>

Opções do comado docker volume create:
  * **-d**: Define qual será o driver utilizado para a criação do volume;
  * **–opt type**: Define o sistema de arquivos utilizado pelo volume;
  * **–opt device**: Define o dispositivo utilizado pelo volume; –opt size: Define o tamanho do volume;
  * **–name**: Define o nome do volume.

==== Realizar Backup de Volumes ====
Para realizar o backup de um volume existente, use a opção ''--volumes-from'', conforme o exemplo abaixo:
<code bash>
docker container run --rm --volumes-from server -v dca:/backup busybox tar cvf /backup/backup.tar /backup
</code>

Verifique se o arquivo empacotado foi criado no diretório de volume, e aproveite para listar seu conteúdo:
<code bash>
sudo ls /var/lib/docker/volumes/dca/_data
</code>

<code bash>
sudo tar -tf /var/lib/docker/volumes/dca/_data/backup.tar
backup/
backup/xattr.conf
backup/usb_modeswitch.conf
backup/ucf.conf
backup/sysctl.conf
backup/sudo_logsrvd.conf
backup/sudo.conf
backup/rsyslog.conf
backup/resolv.conf
backup/pam.conf
backup/overlayroot.local.conf
backup/overlayroot.conf
backup/nsswitch.conf
backup/nftables.conf
backup/multipath.conf
backup/mke2fs.conf
backup/logrotate.conf
backup/libaudit.conf
backup/ld.so.conf
backup/kernel-img.conf
backup/host.conf
backup/hdparm.conf
backup/gai.conf
backup/fuse.conf
backup/e2scrub.conf
backup/deluser.conf
backup/debconf.conf
backup/ca-certificates.conf
backup/adduser.conf
</code>

==== Backup de Volumes ====
Antes de realizar o restore, remova os arquivos ''.conf'' diretório de volume:
<code bash>
sudo su - -c 'rm -f /var/lib/docker/volumes/dca/_data/*.conf'
</code>

<code bash>
sudo ls /var/lib/docker/volumes/dca/_data/
backup.tar
</code>

Para realizar o restore de um volume existente, use a opção ''--volumes-from'', conforme o exemplo abaixo:
<code bash>
docker container run --rm --volumes-from server -v dca:/backup busybox tar xvf /backup/backup.tar
backup/
backup/xattr.conf
backup/usb_modeswitch.conf
backup/ucf.conf
backup/sysctl.conf
backup/sudo_logsrvd.conf
backup/sudo.conf
backup/rsyslog.conf
backup/resolv.conf
backup/pam.conf
backup/overlayroot.local.conf
backup/overlayroot.conf
backup/nsswitch.conf
backup/nftables.conf
backup/multipath.conf
backup/mke2fs.conf
backup/logrotate.conf
backup/libaudit.conf
backup/ld.so.conf
backup/kernel-img.conf
backup/host.conf
backup/hdparm.conf
backup/gai.conf
backup/fuse.conf
backup/e2scrub.conf
backup/deluser.conf
backup/debconf.conf
backup/ca-certificates.conf
backup/adduser.conf
</code>

<code bash>
sudo ls /var/lib/docker/volumes/dca/_data/
adduser.conf	      deluser.conf  hdparm.conf      libaudit.conf   nftables.conf	     pam.conf	   sudo_logsrvd.conf	xattr.conf
backup.tar	      e2scrub.conf  host.conf	     logrotate.conf  nsswitch.conf	     resolv.conf   sysctl.conf
ca-certificates.conf  fuse.conf     kernel-img.conf  mke2fs.conf     overlayroot.conf	     rsyslog.conf  ucf.conf
debconf.conf	      gai.conf	    ld.so.conf	     multipath.conf  overlayroot.local.conf  sudo.conf	   usb_modeswitch.conf
</code>

<code bash>
docker container rm -f server
server
</code>

**Restore de Volumes**
  * No exemplo apresentado, o volume ''dca'' está montado a partir do container ''server'';
  * O diretório de ''/var/lib/docker/volumes/dca/_data'' do host hospedeiro é montado como volume com o caminho (/backup) dentro do container ''server'';
  * Dentro do container servidor, o comando tar está sendo executado no arquivo ''/backup/backup.tar'' e o seu conteúdo será extraído para o diretório (''/var/lib/docker/volumes/dca/_data''), que é montado pelo volume dca.

===== Gerenciando Plugins =====
Os plugins do Docker são bibliotecas de código que estendem as funcionalidades do Docker.
Eles podem ser usados para criar novos tipos de contêineres, adicionar suporte a novos formatos de imagem ou para integrar o Docker com outros sistemas.

Existem plugins para várias finalidades, incluindo:
  * **Armazenamento**: os plugins de armazenamento permitem que o Docker se conecte a diferentes back-ends de armazenamento, como sistemas de arquivos, bancos de dados ou nuvens públicas;
  * **Rede**: os plugins de rede permitem que o Docker se conecte a diferentes tipos de redes, como VLANs, bridges ou redes virtuais;
  * **Segurança**: os plugins de segurança podem ser usados para gerenciar as políticas de segurança do Docker, como controles de acesso e criptografia;
  * **Ferramentas**: os plugins de ferramentas podem adicionar novas funcionalidades ao Docker, como gerenciamento de logs, monitoramento ou gerenciamento de configurações.

==== Instalar plugins de volume ====

=== nfs-volume-plugin ===
Vamos instalar em todas as instâncias o plugin ''nfs-volume-plugin'', que irá permitir o armazenamento de dados em um servidor NFS.

<code bash>
docker plugin install --alias nfs-volume-plugin --grant-all-permissions trajano/nfs-volume-plugin
</code>

<code bash>
sudo docker plugin ls
</code>

Para desativar um plugin no Docker, utilize a flag disable.
<code bash>
sudo docker plugin disable nfs-volume-plugin:latest
</code>

==== Utilizar volume em bloco no Docker ====
Para criar um volume utilizando o novo plugin, utilize a flag -d (driver) definindo ponto de montagem (mountpoint) e nome:
<code bash>
docker volume create -d local-persist -o mountpoint=/mysql-data --name=mysql-data
</code>

<code bash>
docker volume inspect mysql-data
</code>

==== Instalar servidor NFS na dca-registry ====