Containerizando modelos de aprendizado de máquina com Docker
Dockerfile em várias etapas, imagens-base CUDA, artefato do modelo com COPY e endpoints de integridade.
Containerizando modelos de aprendizado de máquina com Docker é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
Por que conteinerizar modelos de aprendizado de máquina
Os modelos de aprendizado de máquina dependem de uma versão específica do Python, de bibliotecas do sistema e de versões fixadas dos pacotes. O Docker empacota tudo isso em uma única imagem imutável, para que o modelo seja executado de forma idêntica em um notebook, em um executor de integração contínua e em um cluster de produção.
Para o aprendizado de máquina, o maior problema é a deriva das dependências: um modelo treinado com numpy 1.24 pode apresentar comportamento incorreto silenciosamente em numpy 2.0. Um contêiner congela essas versões.
A imagem inicial de estágio único
Uma primeira tentativa instala tudo em um único estágio. Ela funciona, mas inclui ferramentas de compilação (compiladores, caches e cabeçalhos de desenvolvimento) na imagem final, tornando-a grande e aumentando a superfície de ataque.
FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "serve.py"]Compilações em vários estágios: a ideia
Uma compilação em vários estágios usa um estágio para compilar e instalar as dependências (o estágio de compilação) e depois copia apenas os artefatos finalizados para um estágio final limpo. As ferramentas exclusivas de compilação nunca chegam à produção.
- Estágio de compilação: imagem-base completa, executa
pip install - Estágio final: imagem-base enxuta, copia os pacotes instalados
Estágio de compilação: instalação com pip
O estágio de compilação instala os pacotes em um prefixo conhecido, para que seja fácil copiá-los. Usar --user coloca-os em /root/.local, um único diretório que podemos copiar posteriormente.
FROM python:3.11 AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txtEstágio final enxuto
O estágio final começa com python:3.11-slim e copia os pacotes instalados do estágio de compilação. A imagem enxuta não inclui cadeias de ferramentas de compilação, reduzindo o tamanho da imagem em centenas de megabytes.
FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
ENV PATH=/root/.local/bin:$PATH
COPY . .Copiando os pesos do modelo
Os pesos de modelos grandes devem ser copiados em sua própria camada para que o Docker possa armazená-los em cache. Se apenas seu código mudar, a camada de pesos será reutilizada e as reconstruções serão rápidas.
COPY model/ /app/model/
COPY src/ /app/src/EXPOSE a porta de serviço
Os servidores de inferência (FastAPI, Triton, TorchServe) escutam em uma porta. EXPOSE 8000 documenta que o contêiner oferece o serviço na porta 8000. Isso não publica a porta por si só; ainda é necessário mapeá-la com -p 8000:8000 em tempo de execução.
EXPOSE 8000
CMD ["uvicorn", "src.serve:app", "--host", "0.0.0.0", "--port", "8000"]Fundamentos de HEALTHCHECK
Os orquestradores precisam saber se o servidor do modelo está ativo. Uma instrução HEALTHCHECK executa um comando em intervalos regulares; uma saída diferente de zero marca o contêiner como não íntegro, para que ele possa ser reiniciado ou removido do balanceador de carga.
HEALTHCHECK com curl
Um padrão comum acessa um endpoint leve /health. curl -f falha (com saída diferente de zero) em qualquer erro HTTP, exatamente o que HEALTHCHECK espera.
HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \
CMD curl -f http://localhost:8000/health || exit 1Um endpoint mínimo de verificação de integridade
Seu aplicativo de serviço deve disponibilizar um endpoint rápido que confirme que o modelo foi carregado, sem executar uma inferência completa.
from fastapi import FastAPI
app = FastAPI()
model = None # loaded at startup
@app.get("/health")
def health():
return {"status": "ok", "model_loaded": model is not None}O Dockerfile completo
Reunindo tudo: um estágio de compilação instala as dependências; um estágio final enxuto copia essas dependências e o modelo, expõe a porta 8000 e declara uma verificação de integridade.
FROM python:3.11 AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt
FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
ENV PATH=/root/.local/bin:$PATH
COPY model/ /app/model/
COPY src/ /app/src/
EXPOSE 8000
HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
CMD curl -f http://localhost:8000/health || exit 1
CMD ["uvicorn", "src.serve:app", "--host", "0.0.0.0", "--port", "8000"]Verificação rápida
Teste sua compreensão sobre compilações em vários estágios.
Recapitulação
Você aprendeu a colocar um modelo de aprendizado de máquina em um contêiner usando um Dockerfile pronto para produção:
- Compilação em vários estágios: o estágio de compilação instala as dependências, e o estágio final enxuto as copia
- EXPOSE 8000 documenta a porta de serviço
- HEALTHCHECK CMD curl permite que os orquestradores detectem contêineres inativos
- Copie os pesos como uma camada própria armazenável em cache
Em seguida, você fará o deploy de um modelo em contêiner para um serviço de nuvem gerenciado.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 53
- Aulas
- 225
Perguntas Frequentes
A aula “Containerizando modelos de aprendizado de máquina com Docker” é grátis?
Sim — o texto completo de “Containerizando modelos de aprendizado de máquina com Docker” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “Containerizando modelos de aprendizado de máquina com Docker”?
Dockerfile em várias etapas, imagens-base CUDA, artefato do modelo com COPY e endpoints de integridade. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Containerizando modelos de aprendizado de máquina com Docker”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Containerizando modelos de aprendizado de máquina com Docker
- Implantação na nuvem: AWS SageMaker
- Disponibilização de alto desempenho com o Triton Inference Server
- Escalonamento e escalonamento automático de endpoints de modelos