Curso
Princípios de Engenharia de Software em Python
4 h
69.8K
Imagine que você trabalhou em um problema de machine learning de ponta a ponta e chegou à melhor solução com os melhores modelos. Porém, quando você envia seu código para o time de engenharia, o que funcionava no seu computador não roda nos servidores deles, que podem ter outro sistema operacional e versões diferentes de bibliotecas.
Mesmo com todo o seu cuidado e esforço, isso pode acontecer e é bem frustrante. A maioria dos desenvolvedores passa por isso pelo menos uma vez. Qual é a solução? É aí que entra o Docker. Com o Docker, você define um ambiente preciso e consistente para o seu projeto, garantindo que o código rode sem dor de cabeça, independentemente do sistema ou da configuração por trás.
Este tutorial apresenta o Docker e seus conceitos relacionados, explicando por que ele é importante para cientistas de dados. Além disso, vamos ajudar você a instalar a ferramenta e a usá-la no seu próximo projeto com exemplos. Por fim, você vai conhecer as melhores práticas do mercado ao usar Docker e tirar todas as suas dúvidas.
O que são Docker, containers e imagens?
Docker é uma plataforma para criar, executar e distribuir aplicações.
Containers são pacotes leves, independentes e executáveis que trazem tudo o que a aplicação precisa para rodar: código, runtime, bibliotecas, variáveis de ambiente e arquivos de configuração.
Uma imagem Docker é um arquivo somente leitura que contém todas as instruções necessárias para criar um container. As imagens são usadas para criar e iniciar novos containers em tempo de execução.
O Docker ajuda desenvolvedores a empacotar suas aplicações junto com as dependências em um container, que pode rodar em qualquer máquina com Docker instalado.
De certa forma, é como se você ganhasse uma máquina nova para um projeto. Você instalaria os pacotes necessários, copiaria os arquivos e executaria os scripts. E ainda poderia enviar essa “máquina” para outro lugar. É um exemplo simplificado, mas dá para entender a ideia.
Como containers Docker se diferenciam de máquinas virtuais?
Assim que definimos containers, surge a dúvida: qual a diferença em relação às máquinas virtuais, já que ambas permitem rodar múltiplos ambientes isolados na mesma máquina física?
Dê uma olhada na diferença de arquitetura na imagem abaixo e veja se você identifica.
Imagem do autor
Cada máquina virtual é um ambiente isolado que pode rodar sistemas operacionais e configurações diferentes. Isso também significa que cada VM precisa de uma cópia completa do sistema operacional, consumindo muitos recursos. Já aplicações em containers rodam em um ambiente isolado sem exigir uma cópia completa do sistema operacional, o que as torna mais leves e eficientes.
Embora as máquinas virtuais sejam úteis, containers geralmente são suficientes e ideais para distribuir aplicações.
Por que Docker para cientistas de dados?
Você talvez esteja se perguntando por que aprender Docker sendo cientista de dados. Não é papel do time de DevOps cuidar da infraestrutura?
Boa pergunta — mas o Docker é extremamente importante para cientistas de dados, mesmo quando há um time de DevOps. Vamos entender por que ele é tão útil.
Integração com o time de DevOps
Ter um time de DevOps não anula os benefícios do Docker; pelo contrário, ele ajuda a aproximar desenvolvimento e operações. Cientistas de dados podem empacotar seu código em Docker e repassar para o DevOps cuidar do deploy e do scale. Em times de data science mais estruturados, isso é comum.
Ambiente consistente e reprodutibilidade
Cientistas de dados lidam com dependências e configurações complexas que precisam ser instaladas e mantidas. O ambiente deve permanecer idêntico para obter resultados semelhantes. O Docker permite criar e compartilhar um ambiente consistente com todas as dependências e configurações pré-instaladas, fácil de replicar por outras pessoas.
Portabilidade
Containers Docker rodam em qualquer ambiente com Docker instalado: laptops, servidores e plataformas em nuvem. Isso facilita mover seu trabalho entre ambientes diferentes.
Isolamento de recursos
O Docker permite rodar vários containers na mesma máquina, cada um com recursos isolados. Isso ajuda a gerenciar recursos com mais eficiência e evita conflitos com outras aplicações. Quando você tem vários projetos de ML, esse recurso pode salvar o dia.
Colaboração facilitada
Com o Docker, cientistas de dados podem compartilhar seu trabalho com qualquer pessoa, inclusive times remotos, em forma de containers. Colaboração é parte essencial do trabalho em equipe, e o Docker reduz a fricção nesse processo.
Muitos profissionais experientes concordam: com o Docker, cientistas de dados focam no que importa sem se preocupar com a infraestrutura por trás.
Tutorial de Docker: usando Docker no seu próximo projeto
Como já vimos a necessidade do Docker para cientistas de dados, vamos direto ao ponto para ganhar velocidade. Primeiro, precisamos instalar o Docker na máquina e nos familiarizar com os comandos mais usados.
Instalando o Docker na sua máquina ou servidor local
O Docker está disponível para os principais sistemas operacionais: Linux, Windows e Mac. A instalação é simples e melhor detalhada na documentação oficial.
- Instruções para instalar o Docker no Linux.
- Instruções para instalar o Docker no Windows.
- Instruções para instalar o Docker no Mac.
Se você quiser criar suas próprias imagens e enviá-las para o Docker Hub (como mostrado em alguns comandos abaixo), crie uma conta no Docker Hub. Pense no Docker Hub como um repositório central onde desenvolvedores armazenam e compartilham suas imagens Docker.
Conhecendo os comandos mais comuns do Docker
Depois de configurar o Docker na sua máquina (ou servidor), o próximo passo é se familiarizar com alguns comandos. Aqui está a lista de comandos de referência na documentação oficial do Docker.
Para ajudar você a começar, destacamos os dez comandos mais usados que você certamente vai encontrar.
- docker run: executa um container a partir de uma imagem. A flag -p mapeia uma porta da máquina host para uma porta do container. Por exemplo, o comando abaixo executa um container a partir da imagem "nginx" e mapeia a porta 80 do host para a porta 80 do container.
docker run -p 80:80 nginx- docker ps: lista todos os containers em execução. Útil quando temos vários containers isolados rodando na mesma máquina.
docker ps- docker stop: interrompe um container em execução.
docker stop <container_id>- docker rm: remove um container parado.
docker rm <container_id>- docker images: lista todas as imagens na máquina host. Útil para ver as imagens locais disponíveis antes de criar um container a partir delas.
docker images- docker rmi: remove uma imagem.
docker rmi <image_id>- docker build: cria uma imagem a partir de um Dockerfile. A flag -t define o nome da imagem e o . no final indica o contexto de build, que é o diretório atual.
docker build -t my_image .- docker exec: executa um comando dentro de um container em execução.
docker exec -it <container_id> /bin/bash- docker pull: baixa uma imagem de um registry, como o Docker Hub.
docker pull <image_name>- docker push: envia uma imagem para um registry.
docker push <image_name>
Agora que aprendemos a configurar o Docker e os comandos mais comuns, o próximo objetivo é dockerizar uma aplicação de machine learning.
Quer tirar uma certificação Docker? Confira nosso guia para conquistar uma Docker certification!
Dockerizando uma aplicação simples de machine learning
Dockerizar qualquer aplicação de machine learning é mais fácil do que você imagina se seguir uma abordagem em três passos.
Imagem do autor.
Vamos usar um script de machine learning para iniciantes, mantendo tudo simples, já que o objetivo é demonstrar como dockerizar um script. O exemplo constrói um modelo simples de regressão logística no conjunto de dados iris.
# Load the libraries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Load the iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Train a logistic regression model
clf = LogisticRegression()
clf.fit(X_train, y_train)
# Make predictions
y_pred = clf.predict(X_test)
# Print the accuracy of the model
accuracy_score = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy_score}')1. Definindo o ambiente
Você precisa conhecer exatamente o ambiente atual para conseguir replicá-lo em outro lugar. A forma mais simples (e comum) é criar um arquivo requirements.txt listando todas as bibliotecas usadas no projeto, com suas versões.
Veja como fica o conteúdo do arquivo:
scikit-learn==1.2.0
Observação: aplicações de machine learning mais complexas usam mais bibliotecas, como NumPy, pandas, matplotlib e outras. Por isso, criar um arquivo requirements.txt faz muito mais sentido do que simplesmente instalar bibliotecas soltas (voltaremos a isso nas melhores práticas).
2. Escreva um Dockerfile
O próximo passo é criar um arquivo chamado Dockerfile que crie o ambiente e execute a aplicação nele. Em outras palavras, é o nosso manual de instruções para o Docker, indicando qual deve ser o ambiente, seu conteúdo e os passos de execução.
FROM python:3.9
WORKDIR /src
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python","iris_classification.py"]Esse Dockerfile usa a imagem oficial do Python como base, define o diretório de trabalho, copia o arquivo requirements.txt e instala as dependências, copia o código da aplicação e executa o comando python iris_classification.py para iniciar a aplicação.
3. Faça o build da imagem
O passo final para criar um ambiente reprodutível é gerar uma imagem (um “molde”) que pode ser usada para criar quantos containers forem necessários com a mesma configuração.
Você pode construir a imagem executando o comando docker build -t <image-name> . no mesmo diretório onde está o Dockerfile.
Depois de dockerizar a aplicação simples que vimos, você pode usar o docker run, criar containers e pará-los quando precisar. Já cobrimos alguns comandos comuns acima.
Agora, vamos evoluir do básico para o que o mercado espera.
Melhores práticas de mercado ao usar Docker
Entender o básico é suficiente para começar, mas no dia a dia profissional é essencial seguir as melhores práticas.
Manter o número de camadas baixo
Cada instrução no Dockerfile gera uma nova camada. Camadas demais deixam a imagem grande e lenta para transferir.
Dê uma olhada no exemplo abaixo:
# Use the official Python image as the build image
FROM python:3.9
# Install the dependencies
RUN pip install pandas
RUN pip install matplotlib
RUN pip install seaborn
# Copy neccesary files
COPY my_script.py .
COPY data/ .
# Run the script
CMD ["python","my_script.py"]
Qual é o problema aqui? O uso de vários comandos run e copy foi desnecessário. Veja como corrigir:
# Use the official Python image as the build image
FROM python:3.9
# Install the dependencies using requirements.txt
COPY my_script.py requirements.txt data/ .
RUN pip install --no-cache-dir -r requirements.txt
# Run the script
CMD ["python","my_script.py"]Embora isso fique claro num arquivo pequeno, você vai se surpreender como frequentemente escrevemos Dockerfiles maiores do que precisamos. Agrupar comandos com funções semelhantes ou que alteram os mesmos arquivos é um jeito fácil de reduzir camadas.
Usar imagens oficiais
Imagens oficiais são mantidas e suportadas pelo publicador. Em geral, são mais estáveis e seguras do que imagens não oficiais.
Na pressa de entregar algo, às vezes usamos imagens não oficiais sem avaliar. Sempre que possível, use imagens oficiais como base para suas próprias imagens.
Builds multiestágio para otimizar performance
Um build multiestágio no Docker permite usar múltiplas instruções FROM em um único Dockerfile.
Podemos usar uma imagem maior como “build image” para compilar/treinar a aplicação e depois copiar apenas os arquivos necessários para uma imagem menor de runtime. Ao não incluir arquivos desnecessários, reduzimos o tamanho da imagem final, melhorando a performance e aumentando a segurança.
Veja um exemplo, muito usado na prática:
# Use the official Python image as the build image
FROM python:3.9 AS build
# Set the working directory
WORKDIR /app
# Copy the requirements.txt file
COPY requirements.txt ./
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the application files
COPY . .
# Train the model
RUN python train.py
# Use the official Alpine Linux image as the runtime image
FROM alpine:3
# Set the working directory
WORKDIR /app
# Copy the model files from the build image
COPY --from=build /app/models /app/models
# Copy the requirements.txt file
COPY --from=build /app/requirements.txt /app
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Run the application
CMD ["python","predict.py"]Dissecando o exemplo: usamos a imagem oficial do Python como imagem de build e instalamos as dependências nesse estágio.
Depois de rodar o train.py, copiamos os arquivos de modelo gerados e o requirements.txt para uma imagem menor (Alpine Linux) de runtime, que usaremos para executar a aplicação. Ao usar build multiestágio e não incluir dependências de build e o interpretador Python na imagem final, reduzimos bastante o tamanho final.
Usar volumes para persistir dados
Os dados dentro de um container não ficam disponíveis após ele ser parado e removido, mas às vezes você precisa guardar os resultados dos experimentos para consulta futura. Também pode ser necessário compartilhar dados entre vários containers.
Com volumes, você garante que os dados persistam fora do container. Veja um exemplo:
# Use the official Python image as the base image
FROM python:3.9
# Set the working directory
WORKDIR /app
# Copy the requirements.txt file
COPY requirements.txt ./
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the rest of the application files
COPY . .
# Create a directory for storing data
RUN mkdir /app/data
# Define a volume for the data directory
VOLUME /app/data
# Run the application
CMD ["python","main.py"]Organização e versionamento de imagens Docker
Quando você começa a trabalhar com várias imagens Docker, tudo pode ficar bagunçado e surge a necessidade de organizar. Embora as práticas variem entre organizações, seguem algumas diretrizes comuns:
- Adote uma convenção de nomes consistente para cada imagem. Por exemplo, <registry>/<organization>/<image>:<version>. Isso ajuda a identificar imagens e versões no registry.
- Siga práticas de versionamento para permitir rollback quando necessário. Como vimos, a versão entra no nome e pode seguir o padrão versão maior>.<versão menor>.<patch>.
- Use tags significativas, como latest, staging, production, para organizar e gerenciar imagens. Assim você identifica rapidamente o que é de cada ambiente e estágio do pipeline de deploy.
É recomendável alinhar com a sua organização; toda a equipe deve seguir a mesma convenção.
Conclusão
Este artigo mostrou a importância de criar códigos e aplicações reprodutíveis com ferramentas como o Docker para cientistas de dados. Passamos pela relevância do Docker, instruções de instalação e comandos mais usados. Depois, vimos como dockerizar aplicações de machine learning com exemplos e as melhores práticas de mercado para usar Docker.
Para continuar aprendendo, faça nosso curso Introduction to Docker, que cobre muitos fundamentos. Se você atua na área, vale considerar buscar uma Docker certification.
Muitos cientistas de dados focam em habilidades centrais como estatística, matemática, machine learning, deep learning e programação, mas acabam deixando de lado as melhores práticas de engenharia de software esperadas no mercado.
Se você quer consolidar seus conhecimentos em ciência de dados, confira a trilha Data Scientist with Python, com aprendizado guiado por projetos. Ou, se precisa reforçar suas habilidades de engenharia de software, veja o curso software engineering for data scientists with Python, que aborda modularidade, documentação e testes automatizados.
