Criando um Ambiente Docker para Desenvolvimento em Python 3.8

Introdução

Após instalarmos o Docker no Ubuntu 22.04, o próximo passo é configurar um ambiente de desenvolvimento isolado para Python 3.8. Para isso, utilizamos dois arquivos fundamentais no ecossistema Docker: o Dockerfile e o docker-compose.yml. Esses arquivos permitem definir e gerenciar nosso ambiente de maneira eficiente e reprodutível.

Este artigo explica cada comando e configuração utilizados na criação do ambiente, destacando a importância desses arquivos.

Criação da Estrutura do Projeto

O primeiro passo é criar uma estrutura organizada para armazenar nosso ambiente Docker. No terminal, executamos:

mkdir -p ~/projetos/python-dev && cd ~/projetos/python-dev

Explicação:

• mkdir -p ~/projetos/python-dev → Cria a pasta python-dev dentro da pasta projetos. O argumento -p garante que toda a hierarquia de diretórios seja criada se ainda não existir.
• cd ~/projetos/python-dev → Entra na pasta do projeto.

Criando o Dockerfile

O Dockerfile define a configuração do nosso container, especificando o sistema base, dependências e comandos necessários para criar o ambiente Python.

Criamos um arquivo chamado Dockerfile dentro da pasta do projeto:

touch Dockerfile

Agora, editamos esse arquivo e adicionamos o seguinte conteúdo:

# Usa a imagem oficial do Python 3.8 como base

FROM python:3.8

# Define o diretório de trabalho dentro do container

WORKDIR /app

# Copia os arquivos de requisitos (se existirem) para o container

COPY requirements.txt .

# Instala as dependências do Python

RUN pip install --no-cache-dir -r requirements.txt

# Mantém o container rodando

CMD ["python3"]

Explicação do Dockerfile:

1. FROM python:3.8 → Define a imagem base do container. Essa imagem oficial já contém o Python 3.8 pré-instalado.
2. WORKDIR /app → Define /app como diretório de trabalho dentro do container. Isso significa que todos os comandos executados pelo Docker ocorrerão nesse diretório.
3. COPY requirements.txt . → Copia o arquivo requirements.txt (caso exista) do host para o container. Esse arquivo geralmente contém as bibliotecas Python necessárias para o projeto.
4. RUN pip install --no-cache-dir -r requirements.txt → Instala as dependências listadas em requirements.txt, evitando o uso do cache para economizar espaço.
5. CMD ["python3"] → Define o comando padrão a ser executado quando o container iniciar. Neste caso, ele inicia um terminal Python interativo.

Criando o Arquivo docker-compose.yml

O docker-compose.yml é um arquivo de configuração que permite gerenciar múltiplos containers e definir seus comportamentos de maneira mais organizada.

Criamos o arquivo:

touch docker-compose.yml

E adicionamos o seguinte conteúdo:

version: "3.8" # esta linha(comando) está obsoleta e pode ser omitida

services:

  python:

    build: .

    container_name: python_dev

    volumes:

      - .:/app

    stdin_open: true

    tty: true

Explicação do docker-compose.yml:

1. version: "3.8" → Define a versão do Docker Compose utilizada. (Esta linha pode ser omitida)
2. services: → Inicia a definição dos serviços que serão criados (neste caso, apenas um chamado python).
3. python: → Define o nome do serviço. (é este nome que chamamos para rodar o contêiner)
4. build: . → Especifica que a construção do container deve usar o Dockerfile na pasta atual (.).
5. container_name: python_dev → Define o nome do container como python_dev, facilitando sua identificação.
6. volumes: → Mapeia o diretório atual (.) para o diretório /app dentro do container, garantindo que as alterações feitas no código no host sejam refletidas no container.
7. stdin_open: true e tty: true → Mantêm o terminal aberto para interações dentro do container, permitindo que comandos sejam executados interativamente.

Construindo e Executando o Container

Agora que criamos os arquivos de configuração, podemos construir e rodar o ambiente.

1. Construção da Imagem

docker-compose build

Esse comando lê o Dockerfile e cria uma imagem personalizada do ambiente Python.

2. Execução do Container

docker-compose run --rm python

Este comando:

• Inicia o serviço python definido no docker-compose.yml.
• O argumento --rm remove o container quando ele for encerrado.

Se tudo estiver correto, você verá o terminal do Python 3.8 rodando dentro do container.

Por Que Utilizamos Dockerfile e docker-compose.yml?

Vantagens do Dockerfile:

✅ Define um ambiente padronizado para desenvolvimento, eliminando problemas de dependências. 

✅ Garante reprodutibilidade: qualquer desenvolvedor pode recriar o ambiente com o mesmo comportamento. 

✅ Facilita a criação de imagens personalizadas que podem ser usadas em produção.

Vantagens do docker-compose.yml:

✅ Simplifica a execução e gerenciamento de containers, permitindo iniciar múltiplos serviços com um único comando. 

✅ Define volumes que sincronizam o código entre o host e o container automaticamente. 

✅ Facilita a configuração de múltiplos ambientes (desenvolvimento, testes, produção).

Conclusão

Assim, configuramos um ambiente de desenvolvimento Python 3.8 dentro do Docker, utilizando Dockerfile e docker-compose.yml. Explicamos cada comando, destacamos suas funcionalidades e benefícios, garantindo que o ambiente seja reprodutível e eficiente.

Agora que temos o ambiente configurado, podemos integrá-lo ao VS Code para um fluxo de desenvolvimento mais produtivo. 🚀