DEV Community: Felipe Oliveira (pt-BR)

Docker: Parte 2 - Criação de Imagens e Execução de Containers

Felipe Oliveira — Tue, 24 Sep 2024 02:39:01 +0000

Olá, venho anotando os meus estudos no Notion e aos poucos postando aqui também, meu objetivo puro e simples é transmitir conhecimento e ter algum local de referência para buscas.

Seguindo nessa segunda parte de estudos sobre o Docker vamos a algumas observações:

Se não existe nenhum processo rodando dentro do container o mesmo é finalizado.
Ao executarmos os containers através do docker, sem usar extensões como o Docker-compose que veremos mais a frente, temos que passar manualmente os parâmetros sobre o container com informações como nome, portas, variáveis de ambiente, etc.

Dockerfile

Esse arquivo reune as informações necessárias para a execução da nossa aplicação, como o Node do Javascript ou Maven para aplicações Java.

Nele configuramos em scripts os mesmos passos que executamos para rodar a aplicação, indicamos o diretório a ser trabalho, rodamos ‘npm install’, copiamos os arquivos do build e inicializamos o servidor.

Exemplo simplificado:

# Imagem base. Essa versão 'alpine' é uma versão de tamanho reduzido.
# Ao subirmos uma imagem na nuvem somos cobrados pelo tamanho da mesma então
# quanto menor, melhor, nesse caso temos uma redução de mais de 1GB para cerca de 
# 500mb nas imagens alpine.
FROM node:20-alpine

# Cria o diretório
WORKDIR /app

# Adiciona variáveis de ambiente
ENV DB_USER=postgres

# Um asterisco é usado para garantir que tanto o package.json quanto o 
# package-lock.json serão copiados
COPY package*.json ./

# Instala as dependências da aplicação
RUN npm install

# Copia o código-fonte da aplicação
COPY . .

# Cria uma pasta "dist" com o build de produção
RUN npm run build

# Expõe a porta 3000
EXPOSE 3000

# Inicia o servidor usando o build de produção
CMD [ "node", "dist/main.js" ]

Também possuimos um arquivo ignore para que o Docker não inclua eles no build da imagem.

*Como a imagem executará os mesmos passos que executamos para iniciar o projeto, não precisaremos incluir a pasta node_modules, pois a mesma será gerada

Dockerfile
.dockerignore
node_modules
npm-debug.log
dist

Gerando uma imagem a partir do Dockerfile

Com o Dockerfile configurado, conseguimos gerar a imagem com o seguinte comando:

# Aonde "-t" é a tag1.0 é a versão e o ponto especifica a raiz aonde o nosso 
# arquivo Dockerfile está localizado, sendo nesse caso na raiz de onde estamos 
# executando o comando.
# O "." indica que o Dockerfile está na raiz do meu diretório aonde estou
# executando o comando.
docker build -t nome-da-imagem:1.0 .

docker build -t [nome-da-imagem]:[tag] [caminho]

Executando um Container

O container possui uma interface de rede separada do host, para conseguir acessá-lo precisamos passar um comando ao executa-lo fazendo o mapeamento das portas do container para as portas do host.

Aonde do lado direito temos a porta do container e do lado esquerdo a porta do host.

*Se possuirmos alguma variável de ambiente a mesma também deverá ser informada no comando.

## Executar um container

# Mapeando a porta definida no EXPOSE do Dockerfile para uma porta aleatoria 
# no host
docker run -p my-image:1.0

# Mapeando a porta 8080 do container para a porta 3000 no meu host
docker run -p 3000:8080 my-image:1.0

# Com variáveis de ambiente
docker run -d -p 3000:3000 -e NODE_ENV=development -e DB_HOST=db.example.com -e DB_PORT=5432 -e DB_USER=myuser -e DB_PASS=mypassword --name my-node-app my-node-app-image

docker run -d \
  -p 3000:3000 \
  -e NODE_ENV=development \
  -e DB_HOST=db.example.com \
  -e DB_PORT=5432 \
  -e DB_USER=myuser \
  -e DB_PASS=mypassword \
  --name my-node-app \
  my-node-app-image

Melhores Práticas do Dockerfile:

Por fim, deixo aqui um resumo de algumas práticas indicadas na documentação.

Use Multi-Stage builds Quando temos multiplos FROM separando os diferentes estágios do build que podem ser carregados do anterior para o próximo, a fim de organizar o arquivo e deixar definido as responsabilidades.
Selecione a imagem base correta Escolha uma imagem pequena e local confiável (Docker Hub, Verified Publisher, Docker Sponsored Open Source)
Reconstrua (rebuild) suas imagens com frequência As imagens são imutáveis. Ao fazer um build, tiramos um “snapshot” daquele momento, portanto, qualquer alteração subsequente necessita de um novo build na imagem.
Podemos usar um arquivo .dockerignore Podemos inserir arquivos não relevantes para o build aqui.
Desaccople as aplicações Cada container deve ter apenas uma responsabilidade
Organize argumentos multi-linhas É possível separar os argumentos em múltiplas linhas

Exemplo de organização dos argumentos em múltiplas linhas:

RUN npm install -g \
  typescript \
  eslint \
  nodemon \
  jest \
  pm2 \
  && npm cache clean --force

Fontes:

Docker: Parte 1 - Introdução

Felipe Oliveira — Tue, 16 Jul 2024 02:53:58 +0000

Introdução

O Docker é um serviço de virtualização que isola nossa aplicação do sistema operacional do host/computador hospedeiro, evitando o erros na execução da nossa aplicação independente do sistema base (Windows, Linux, Mac, etc).

Ele utiliza o conceito de “containers”, os quais possuem tudo que a nossa aplicação precisa para executar (servidor, banco de dados, etc). Diferente de uma VM, um container não contém o Sistema Operacional dentro do mesmo, ele roda sobre o sistema do host, o que diminui e muito o seu tamanho.

Cada container roda de maneira independente e não enxerga as coisas que são executadas no host/computador hospedeiro.

Arquitetura

Client: Aplicação cliente: CLI/Terminal ou Remote API

Host/Engine: Possui um Daemon que interpreta os comandos do client e executa os mesmos, além disso o host possui os containers e as imagens.

Registry: Repositórios para imagens Docker, exemplos: Docker Hub, AWS ECS, Azure Registry, etc. Da mesma forma podemos ter públicas e privadas.

Fonte: Docker Documentação

Instalação

O Docker possui 2 formas principais de instalação, via Docker Desktop ou via Docker Engine. O primeiro possui uma interface gráfica e cria uma VM para rodar o Docker, mesmo estando em um host Linux, enquanto o segundo funciona através do terminal. Essas duas formas não são muito compatíveis devido as diferenças, e portanto devemos escolher apenas uma para o uso.

Composição

Dockerfile: Define a arquitetura da nossa aplicação como: versão do node/ferramenta vamos usar, qual a versão do banco de dados vamos usar, qual arquitetura nós vamos buildar a aplicação, etc.

Imagem: “É um template somente de leitura com instruções para criar um container. É frequentemente baseada em outra imagem com alguma customização. Eu posso ter uma imagem do Unbuntu a qual eu inseri o servidor Apache por exemplo.” - Docker Documentation

Container: É a nossa imagem instância rodando no host. Ele é “stateless”, ou seja, não persiste informações quando interrompido. Ele não persiste as informações do banco de dados!!! Para isso usamos algo chamado volume ou outras técnicas de persistência, ver documentação:

Persistência

Para que possamos persistir informações de um banco de dados mesmo após um container ser interrompido ou deletado, o Docker disponibiliza algo chamado volume.

Volume: Um volume mapeia no host um espaço que vai ser compártilhado com uma área no filesystem do Docker, vamos fazer o “mount” dessa estrutura.

Exemplo da documentação referente ao MariaDB (Seção: “Where to Store Data”):

https://hub.docker.com/_/mariadb

Comandos Comuns:

# Quantos e quais containers estão em execução
# Exibe ate os containers parados
docker ps
docker ps -a

# Exibe as imagens
docker images
docker images -a

# run: Cria e inicia um novo container com base na imagem 'my-image' dando um nome
# aleatório para o container.
# --name: Atribui o nome 'my-container' para o container referente a imagem
# 'my-image'.
docker run my-image
docker run --name my-container my-image

# -d: roda o container em background
# -p: porta, no exemplo mapeamos a porta 8088 do host para a porta 80 do container
docker run -d my-image
docker run --name my-container -d -p 8088:80 my-image

# Parar um ou todos os containers
docker stop
dcoker stop containerID

# Iniciar um container
docker start containerID

# Remover um container
# Remover uma imagem
docker container rm containerID
docker image rm image-name / imageID

# Gerar a imagem / build
docker image build image-name

# Executar o bash dentro de uma imagem Ubuntu
# -it: de iterativo, esse comando te leva para dentro do container
# bash: nesse caso estamos executando o terminal bash dentro do container
docker run -it ubuntu bash

Fontes: