O Docker revoluciona a forma como empacotamos e executamos aplicações, encapsulando-as com todas as suas dependências – bibliotecas, configurações e ferramentas de sistema – em unidades padronizadas conhecidas como contêineres. Essa abordagem garante que as aplicações funcionem de forma idêntica em qualquer ambiente, eliminando problemas de compatibilidade.

Para otimizar o uso do Docker, é crucial entender a distinção entre dois conceitos fundamentais: **imagens** e **contêineres**.

• Imagens Docker: São modelos estáticos e imutáveis que contêm o código da aplicação, o runtime, bibliotecas, variáveis de ambiente e arquivos de configuração. Uma imagem é a "receita" para criar um contêiner, não sendo executável por si só.
• Contêineres Docker: São instâncias executáveis e isoladas de uma imagem. Eles representam a aplicação em execução, com seu próprio sistema de arquivos, rede e processo. Contêineres são dinâmicos; podem ser iniciados, parados, pausados, removidos e conectados a outros contêineres.

Comandos Fundamentais do Docker

A seguir, uma tabela dos comandos Docker mais utilizados para gerenciar seu ambiente:

Exemplos Práticos de Comandos Docker

1. Obtendo Imagens (docker pull)

Para baixar uma imagem de um registro remoto, como o Docker Hub, utilize o comando docker pull. Por exemplo, para obter a imagem oficial do Python na sua versão 3.9-slim-buster:

docker pull python:3.9-slim-buster

Para verificar as imagens que estão armazenadas localmente em sua máquina, use:

docker images

Este comando listará informações como REPOSITORY (nome do repositório), TAG (rótulo da versão), IMAGE ID (identificador único), CREATED (data de criação) e SIZE (tamanho da imagem).

2. Definindo uma Aplicação com Dockerfile

Considere uma aplicação web simples desenvolvida em Flask, que será encapsulada em um contêiner Docker. Primeiro, criaremos um arquivo requirements.txt para as dependências:

Flask

Em seguida, o código-fonte da aplicação, salvo como app_servidor.py:

# arquivo: app_servidor.py
from flask import Flask

app_docker_flask = Flask(__name__)

@app_docker_flask.route('/')
def pagina_inicial():
   return 'Bem-vindo ao meu Contêiner Flask!'

if __name__ == '__main__':
   app_docker_flask.run(host='0.0.0.0', port=5000)
   

Finalmente, o Dockerfile, que instrui o Docker sobre como construir a imagem da nossa aplicação:

FROM python:3.9-slim-buster
WORKDIR /app_web
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app_servidor.py"]
   

Este Dockerfile baseia-se na imagem Python 3.9, define o diretório de trabalho como /app_web, instala as dependências do Flask e, por fim, executa nossa aplicação na porta 5000.

3. Construindo a Imagem (docker build)

Com o Dockerfile e os arquivos da aplicação no mesmo diretório, podemos construir a imagem Docker. O comando docker build compila as instruções do Dockerfile, criando uma nova imagem:

docker build -t meu-app-flask:v1.0 .

O argumento -t atribui um nome (meu-app-flask) e uma tag de versão (v1.0) à imagem. O ponto (.) indica que o Dockerfile está no diretório atual.

4. Iniciando um Contêiner (docker run)

Após a construção da imagem, podemos iniciar um contêiner a partir dela. O comendo docker run cria e executa uma instância da imagem, mapeando portas para que a aplicação seja acessível externamente:

docker run -d -p 8080:5000 --name cont_flask_web meu-app-flask:v1.0

• -d: Executa o contêiner em modo "detached" (segundo plano).
• -p 8080:5000: Mapeia a porta 8080 da máquina hospedeira para a porta 5000 do contêiner.
• --name cont_flask_web: Atribui um nome descritivo ao contêiner.

Para verificar se a aplicação está funcionando, acesse http://localhost:8080 em seu navegador. Você deverá ver a mensagem "Bem-vindo ao meu Contêiner Flask!".

5. Parando um Contêiner (docker stop)

Para interromper um contêiner em execução sem removê-lo, use docker stop, especificando seu nome ou ID:

docker stop cont_flask_web

6. Removendo um Contêiner (docker rm)

Para remover um contêiner parado do seu sistema, utilize docker rm. Contêineres em execução devem ser parados antes de serem removidos:

docker rm cont_flask_web

7. Excluindo uma Imagem (docker rmi)

Se uma imagem não é mais necessária, ela pode ser removida do armazenamento local com docker rmi. Certifique-se de que nenhum contêiner esteja utilizando a imagem antes de tentar excluí-la:

docker rmi meu-app-flask:v1.0

8. Visualizando Logs do Contêiner (docker logs)

Para inspecionar a saída padrão (stdout/stderr) de um contêiner, que geralmente inclui logs da aplicação, use docker logs:

docker logs cont_flask_web

9. Inspecionando Detalhes do Contêiner (docker inspect)

Para obter informações detalhadas sobre a configuração, status e rede de um contêiner ou imagem, o comando docker inspect é muito útil:

docker inspect cont_flask_web

10. Acessando o Shell do Contêiner (docker exec)

Para executar comandos interativamente dentro de um contêiner em funcionamento, como acessar seu terminal para depuração, use docker exec:

docker exec -it cont_flask_web bash

• -it: Combinação de -i (interativo) e -t (aloca um pseudo-TTY), essencial para interagir com o terminal.
• bash: O comando a ser executado dentro do contêiner (neste caso, o shell bash).