No desenvolvimento de software a eficiência e a consistência são fundamentais. Desenvolvedores e equipes de operações buscam soluções que facilitem o gerenciamento, a implantação e a execução de aplicações de forma uniforme em diversos ambientes. É nesse contexto que surgem os contêineres e o Docker, tecnologias que revolucionaram a maneira como o software é construído, testado e implantado.

O que são Contêineres?

Imagine que você está desenvolvendo uma aplicação que funciona perfeitamente no seu computador. No entanto, ao tentar executá-la em outra máquina, surgem problemas devido a diferenças no sistema operacional, versões de bibliotecas ou configurações. Os contêineres resolvem esse problema ao empacotar a aplicação e todas as suas dependências em uma unidade padronizada, garantindo que ela seja executada de maneira consistente em qualquer ambiente.

Principais características dos contêineres:

Leveza: Compartilham o kernel do sistema host, tornando-os mais eficientes que máquinas virtuais.
Portabilidade: Uma vez criado, um contêiner pode ser executado em diversos ambientes sem modificações.
Isolamento: Operam de forma isolada, garantindo que não interfiram em outras aplicações no mesmo sistema.

O que é Docker?

O Docker é uma plataforma de código aberto que simplifica a criação, o gerenciamento e a implantação de contêineres. Lançado em 2013, tornou-se a solução preferida para conteinerização devido à sua facilidade de uso e robusto ecossistema de ferramentas.

Conceitos-chave no Docker:

Imagens Docker: Servem como modelos para os contêineres, contendo tudo o que é necessário para executar a aplicação, desde o código até as dependências do sistema.
Contêineres Docker: São instâncias em execução das imagens Docker, proporcionando um ambiente isolado para a aplicação.
Dockerfile: Arquivo de texto que define as instruções para construir uma imagem Docker, especificando desde a imagem base até as dependências e configurações necessárias.
Docker Hub: Registro público onde desenvolvedores compartilham e acessam imagens pré-construídas, facilitando o uso de componentes comuns em projetos.
Docker Compose: Ferramenta que permite definir e gerenciar ambientes multi-contêiner usando um arquivo YAML, ideal para aplicações que requerem múltiplos serviços.

Por que usar Docker?

O Docker resolve diversos desafios enfrentados por desenvolvedores:

Consistência entre Ambientes: Garante que a aplicação funcione da mesma forma em diferentes ambientes, eliminando o clássico problema de “funciona na minha máquina”.
Rapidez: Contêineres iniciam e param rapidamente, otimizando pipelines de teste e implantação.
Eficiência de Recursos: Por compartilharem recursos do sistema host, contêineres reduzem a sobrecarga e permitem maior densidade de implantação.
Controle de Versão: Possibilita versionar não apenas o código, mas também o ambiente de execução, facilitando rollbacks e depuração.

Arquitetura do Docker

Compreender a arquitetura do Docker é essencial para otimizar seu uso:

Docker Daemon (dockerd): Processo que gerencia contêineres e lida com objetos Docker, ouvindo solicitações via Docker Engine API.
Cliente Docker (docker): Interface de linha de comando que permite aos usuários interagir com o daemon Docker.
Objetos Docker: Entidades como imagens, contêineres e serviços utilizados para montar uma aplicação no Docker.
Registries Docker: Repositórios para armazenar e compartilhar imagens Docker, sendo o Docker Hub o registry público padrão.

Criando sua Primeira Aplicação com Docker

Vamos colocar em prática criando uma aplicação simples em Python que exibe uma mensagem. Utilizaremos o Docker para executar essa aplicação sem a necessidade de instalar o Python diretamente no sistema host.

Passo 1: Instalar o Docker

No Ubuntu:

Atualize os pacotes:
```
sudo apt update
```
Instale o Docker:
```
sudo apt install docker.io
```
Verifique a instalação:
```
sudo docker run hello-world
```

No macOS e Windows:

Baixe e instale o Docker Desktop a partir do site oficial do Docker.

Passo 2: Escrever o Código Python

Crie um arquivo chamado app.py com o seguinte conteúdo:

print("Olá, Docker!")

Passo 3: Criar o Dockerfile

No mesmo diretório do app.py, crie um arquivo chamado Dockerfile com o seguinte conteúdo:

# Usar uma imagem base do Python
FROM python:3.8-slim

# Definir o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiar o arquivo app.py para o diretório de trabalho
COPY app.py .

# Definir o comando padrão para executar o script Python
CMD ["python", "app.py"]

Passo 4: Construir a Imagem Docker

No terminal, navegue até o diretório que contém o Dockerfile e execute:

sudo docker build -t minha-aplicacao-python .

Passo 5: Executar o Contêiner

Agora que criamos a imagem Docker, podemos rodar nossa aplicação dentro de um contêiner:

sudo docker run minha-aplicacao-python

Se tudo estiver correto, o terminal exibirá:

Olá, Docker!

Isso significa que o contêiner foi criado e executou nosso script Python com sucesso.

Gerenciando Contêineres no Docker

Para verificar quais contêineres estão rodando no momento, use:

sudo docker ps

Se quiser listar todos os contêineres, incluindo os finalizados, execute:

sudo docker ps -a

Para parar um contêiner em execução, use:

sudo docker stop <ID_DO_CONTÊINER>

Substitua <ID_DO_CONTÊINER> pelo ID exibido no docker ps.

Após parar o contêiner, podemos removê-lo:

sudo docker rm <ID_DO_CONTÊINER>

Se quiser remover todos os contêineres de uma vez, use:

sudo docker rm $(sudo docker ps -aq)

Para excluir uma imagem Docker que não está mais em uso:

sudo docker rmi minha-aplicacao-python

Criando e Executando um Contêiner com Parâmetros

Podemos passar argumentos para a aplicação ao executar o contêiner. Vamos modificar nosso app.py para aceitar um nome como entrada:

import sys

nome = sys.argv[1] if len(sys.argv) > 1 else "Mundo"
print(f"Olá, {nome}!")

Agora, reconstruímos a imagem:

sudo docker build -t minha-aplicacao-python .

E podemos executar passando um nome como argumento:

sudo docker run minha-aplicacao-python Daniel

Saída esperada:

Olá, Daniel!

Referências