Notes App

Docker Intensivo do Zero

2022-11-01

Voltar

Algumas dicas de utilização do Docker, da imersão FullCycle.

Para instalar uma nova imagem de container utilizamos o comando:

$ docker run --name nome_do_container nome_da_imagem

Algumas imagens não possuem processos, logo quando iniciamos um container ele fecha automaticamente. É o caso, por exemplo de uma imagem do Ubuntu. Para esses casos devemos atrelar a execução da imagem ao processo que queremos. No caso da imagem do Ubuntu podemos rodar o processo do shell bash. Para termos acesso a linha de comando do container utilizamos as opções -ti.
Sendo assim para iniciarmos um container de nome terminal-ubuntu rodando o processo bash e com acesso a linha de comando devemos executar o seguinte comando:

$ docker run -ti --name terminal-ubuntu ubuntu bash

Para sairmos do terminal do container utilizamos as teclas Ctrl + D e encerrarmos o container.
Para reiniciar o container utilizamos o comando:

$ docker start nome_do_container ou container_ID

No caso de containers como o do Ubuntu devemos executar um comando com o processo para rodar o container (nesse caso o bash).

$ docker exec -ti nome_do_container bash

Para acessarmos serviços em containers através de endereços da rede, é necessário fazer a publicação de portas. Para isso utilizamos a opção -p porta_local:porta_container.
Para exemplificar vamos criar um container do servidor Nginx:

$ docker run -p 8000:80 --name servidor-nginx nginx

Com esse container iniciado conseguimos acessar o serviço através de locahost:8000 e podemos editar seus arquivos com o comando:

$ docker exec -ti servidor-nginx bash

Resumindo, o comando docker run inicia o container e o comando docker exec executa um comando contra um container que está executando.
Nesse momento o container não irá persistir as modificações executadas nele. As alterações feitas em um container não são gravadas no container e são perdidas quando encerramos a execução do container. Para mantermos as modificações em um container devemos ou criar uma nova imagem do container ou apontar um ponto de montagem para o container no sistema local.
Para verificarmos as imagens gravadas em nossa máquina utilizamos o comando:

$ docker images

Esse comando retorna as imagens que já estão gravadas localmente em nossa máquina. Para removermos as imagens gravas em nosso sistema devemos utilizar o comando:

$ docker rmi nome_da_imagem

Esse comando só funciona quando não temos nenhum container criado com a imagem (mesmo que ele não esteja em execução). Sendo assim devemos primeiramente excluir os containers que tenham sido criados com a imagem antes de excluir a imagem. Para isso utilizamos a opção:

$ docker rm nome_do_container ou container_ID

Para trabalhar com diretórios locais nos containers utilizamos a opção -v caminho_local:caminho_container. Desse modo temos nosso diretório local mapeado dentro do container.

$ docker run -p 8000:80 --name servidor-nginx -v $(pwd):/usr/share/nginx/html nginx

O comando acima mapeia o diretorio local onde está sendo executado o docker para o diretório html do Nginx. Desse modo podemos iniciar um projeto em um novo diretório criando o container diretamente no local a ser editado (atenção para as permissões de acesso ao diretório.

$ docker run -p 8000:80 --name servidor-notes -v $(pwd)/html:/usr/share/nginx/html nginx

Para criarmos imagens personalizadas do docker devemos criar um arquivo chamado Dockerfile.
Esse arquivo deve ter a seguinte estrutura:

FROM imagem_base
COPY origem_dos_arquivos destino_dos_arquivos_no_container
... outras instruções de acordo com a necessidade
CMD ["comando_a_ser_executado"]

Um exemplo de Dockerfile para executar um servidor nginx com um arquivo index.html ficaria como segue:

FROM nginx:latest
COPY html/index.html /usr/share/nginx/html/index.html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Criado o arquivo Dockerfile devemos fazer um build da imagem partindo do diretório de origem.

$ docker build -t nome_da_imagem_criada:versão(opcional) .

Com isso temos uma imagem criada com os arquivos criados localmente. Essa imagem terá todos os processos para executar mais os arquivos criados para serem executados.
Quando criamos uma imagem personalizada podemos publicá-la no Docker Hub com o comando docker push nome_da_imagem.

Para criarmos containers de forma automatizada, podendo inclusive criar mais de um simultaneamente criamos um arquivo com nome docker-compose.yaml. Esse arquivo irá conter as informações para a criação do(s) container(s) semelhante ao Dockerfile, conforme o exemplo abaixo:

version: '3'
services:  
    mysql:    
      image: mysql:5.7    
      restart: always    
      platform: linux/amd64    
      environment:      
        MYSQL_ROOT_PASSWORD: root      
        MYSQL_DATABASE: teste_docker      
        MYSQL_PASSWORD: root    
      ports:      
        - 3308:3306    
      volumes:      
        - ./mysql:/var/lib/mysql

O código acima cria um container com mysql, definindo a senha para o usuário root as portas da máquina local e do container e indica o diretório local que irá receber os arquivos do banco de dados do container (/var/lib/mysql).
Para executar esse arquivo e consequentemente subir esse container devemos executar o comando:

$ docker-compose up -d

Com isso criamos o container com o mysql em execução. Os arquivos do mysql (inclusive os arquivos padrão do mysql) são criados na máquina local no diretório indicado.

Quando criamos um container com o docker-compose podemos executar comandos utilizando o próprio docker-compose exec e chamando a imagem pelo nome definido como service:

$ docker-compose exec mysql bash

Quando incluimos novos containers através do docker-compose temos a integração entre eles. Por exemplo, se tivermos um container rodando mysql e outro rodando golang e precisamos conectar o segundo ao DB do primeiro, devemos referenciar o endereço da conexão pelo nome do serviço, diferente de quando nos comunicamos com o container através da máquina local, ou seja se para acessarmos o DB pela máquina local utilizamos o endereço localhost, através do container iniciado pelo compose devemos acessar o endereço do serviço, no caso mysql.