Guia para Iniciantes do Docker: Comece Rapidamente a Containerizar sua Aplicação

O Docker se tornou uma parte indispensável do desenvolvimento e implantação de software moderno. Apesar da discussão generalizada em torno do Kubernetes, o Docker ainda é a ferramenta preferida para muitas empresas construírem, testarem e implantarem aplicativos. Este artigo irá guiá-lo rapidamente pelos primeiros passos com o Docker, entender seus conceitos principais e fornecer um exemplo prático para ajudá-lo a começar a containerizar sua aplicação.

Conceitos Principais do Docker

Antes de começar a praticar, é essencial entender alguns dos conceitos principais do Docker:

• Imagem (Image): Uma imagem é um modelo somente leitura que contém tudo o que é necessário para executar um aplicativo: código, ambiente de tempo de execução, ferramentas de sistema, bibliotecas e dependências. Semelhante a uma imagem de máquina virtual, mas mais leve.

• Contêiner (Container): Um contêiner é uma instância em execução criada a partir de uma imagem. É uma instância de tempo de execução de uma imagem, contendo o aplicativo e todas as suas dependências. Os contêineres são isolados uns dos outros, possuindo seus próprios sistemas de arquivos, processos e espaço de rede.

• Docker Hub: O Docker Hub é um repositório público de imagens, onde você pode baixar imagens pré-construídas ou enviar suas próprias imagens. Semelhante ao GitHub, mas especializado em imagens Docker.

• Dockerfile: Um Dockerfile é um arquivo de texto que contém todas as instruções para construir uma imagem Docker. Ao escrever um Dockerfile, você pode automatizar o processo de criação de imagens.

• Docker Compose: O Docker Compose é uma ferramenta para definir e executar aplicativos Docker multi-contêiner. Ele permite que você use arquivos YAML para configurar os serviços do seu aplicativo e, em seguida, use um único comando para iniciar ou parar todos os serviços.

Instalação do Docker

Primeiro, você precisa instalar o Docker. O Docker fornece pacotes de instalação para vários sistemas operacionais. Visite o site oficial do Docker e siga as instruções correspondentes para instalar.

Após a instalação, você pode executar o comando docker --version para verificar se o Docker foi instalado corretamente.

Containerizando uma Aplicação Python Simples

Criaremos uma aplicação Python simples e a containerizaremos usando o Docker.

1. Criar a Aplicação Python

Crie um arquivo chamado app.py contendo o seguinte código:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

Esta aplicação Flask simples retornará "Hello, Docker!" na rota raiz /.

2. Criar o Arquivo requirements.txt

A aplicação depende da biblioteca Flask, e precisamos criar um arquivo requirements.txt para declarar essas dependências.

Flask

3. Criar o Dockerfile

Crie um arquivo chamado Dockerfile e adicione o seguinte conteúdo:

# Usar a imagem oficial do Python como imagem base
FROM python:3.9-slim-buster

# Definir o diretório de trabalho
WORKDIR /app

# Copiar o arquivo requirements.txt para o diretório de trabalho
COPY requirements.txt .

# Instalar as dependências
RUN pip install --no-cache-dir -r requirements.txt
```# Copiar o código da aplicação para o diretório de trabalho
COPY app.py .

# Expor a porta 5000
EXPOSE 5000

# Definir o comando de inicialização
CMD ["python", "app.py"]

Explicação do Dockerfile:

• FROM python:3.9-slim-buster: Especifica a imagem base como uma versão slim do Python 3.9.
• WORKDIR /app: Define o diretório de trabalho dentro do contêiner como /app.
• COPY requirements.txt .: Copia o arquivo requirements.txt do diretório atual para o diretório /app do contêiner.
• RUN pip install --no-cache-dir -r requirements.txt: Executa o comando pip dentro do contêiner para instalar as dependências especificadas no arquivo requirements.txt. O parâmetro --no-cache-dir pode reduzir o tamanho da imagem.
• COPY app.py .: Copia o arquivo app.py do diretório atual para o diretório /app do contêiner.
• EXPOSE 5000: Declara que o contêiner estará escutando na porta 5000.
• CMD ["python", "app.py"]: Define o comando a ser executado quando o contêiner for iniciado.

4. Construir a Imagem Docker

No diretório que contém o Dockerfile, execute o seguinte comando para construir a imagem Docker:

docker build -t my-python-app .

• docker build: Comando para construir a imagem.
• -t my-python-app: Atribui um nome à imagem (my-python-app).
• .: Especifica o diretório onde o Dockerfile está localizado (diretório atual).

O processo de construção pode levar algum tempo, dependendo da velocidade da rede e do tamanho das dependências.

5. Executar o Contêiner Docker

Use o seguinte comando para executar o contêiner Docker:

docker run -d -p 5000:5000 my-python-app

• docker run: Comando para executar o contêiner.
• -d: Executa o contêiner em modo detached (em segundo plano).
• -p 5000:5000: Mapeia a porta 5000 da máquina host para a porta 5000 do contêiner.
• my-python-app: Especifica o nome da imagem a ser usada.

6. Verificar a Aplicação

Acesse http://localhost:5000 no seu navegador. Você deverá ver "Hello, Docker!".

7. Parar e Remover o Contêiner

Use o seguinte comando para parar o contêiner:

docker stop 

`` Pode ser visualizado através do comando docker ps.

Use o seguinte comando para remover o contêiner:

docker rm 

Introdução ao Docker Compose

Se sua aplicação for composta por múltiplos serviços, você pode usar o Docker Compose para gerenciá-los.

1. Criar o Arquivo docker-compose.yml

Crie um arquivo chamado docker-compose.yml e adicione o seguinte conteúdo:

version: "3.9"
services:
  web:
    image: my-python-app
    ports:
      - "5000:5000"

Explicação do docker-compose.yml:* version: "3.9": Especifica a versão do arquivo Docker Compose.

• services: Define os serviços da aplicação.
• web: Define um serviço chamado "web".
• image: my-python-app: Especifica a imagem usada pelo serviço.
• ports: Define o mapeamento de portas.

2. Iniciando a Aplicação

No diretório que contém o arquivo docker-compose.yml, execute o seguinte comando para iniciar a aplicação:

docker-compose up -d

• docker-compose up: Comando para iniciar a aplicação.
• -d: Executa os contêineres em modo detached (segundo plano).

3. Parando a Aplicação

Use o seguinte comando para parar a aplicação:

docker-compose down

Melhores Práticas de Segurança do Docker

Como pode ser visto na discussão, a segurança das imagens Docker é uma questão importante. Aqui estão algumas melhores práticas de segurança do Docker:

• Use Imagens Oficiais: Sempre que possível, use imagens fornecidas oficialmente, pois elas geralmente são verificadas e mantidas quanto à segurança.
• Verifique Vulnerabilidades nas Imagens: Use ferramentas como o Trivy para verificar vulnerabilidades conhecidas nas imagens e atualize as imagens prontamente.
• Use o Princípio do Menor Privilégio: Evite executar contêineres como usuário root.
• Limite os Recursos do Contêiner: Use cgroups para limitar o uso de CPU e memória do contêiner.
• Atualize as Imagens Regularmente: Mantenha as imagens atualizadas para corrigir vulnerabilidades de segurança.
• Use Ferramentas de Verificação de Segurança: Ferramentas como Snyk, Clair, etc., podem ser integradas ao seu fluxo de CI/CD para verificar automaticamente as vulnerabilidades da imagem.

ConclusãoEste artigo fornece um guia rápido de introdução ao Docker, abrangendo os conceitos principais, etapas de instalação e um exemplo simples de conteinerização de um aplicativo Python. Ao aprender esses fundamentos, você pode começar a usar o Docker para construir, testar e implantar seus aplicativos. Lembre-se, a segurança é fundamental, sempre preste atenção à segurança das imagens Docker e tome as medidas apropriadas para proteger seus aplicativos. Embora o Kubernetes seja poderoso no gerenciamento de contêineres em larga escala, o Docker ainda é uma solução simples e eficaz em muitos cenários. Ao dominar o Docker, você estará mais bem equipado para enfrentar os desafios do desenvolvimento e implantação de software modernos.