Não quer configurar isso manualmente? Cole um link para esta página em uma sessão do Devin e peça para ele configurar tudo para você. Se você não tem certeza de quais serviços seu app Django depende ou de como o projeto é estruturado, use o [Ask Devin](https://app.devin.ai/search?utm_source=docs\&utm_medium=use-case-gallery) para investigar primeiro: ```txt Delimitar o escopo do projeto Django para conteinerização theme={null} De que serviços nosso app Django em src/ depende? 1. A quais bancos de dados e caches ele se conecta? 2. Ele usa Celery ou algum worker em segundo plano? 3. O que há em requirements.txt ou pyproject.toml? 4. Existem arquivos Docker ou configurações de deployment já existentes? 5. Como o app lida com arquivos estáticos e mídia? ``` Você também pode iniciar uma sessão do Devin diretamente a partir do Ask Devin, e tudo o que ele tiver aprendido será mantido como contexto. Aponte o Devin para o projeto Django que você quer conteinerizar e mencione qualquer requisito específico — preferências de imagem base, serviços dos quais o app depende ou restrições de tamanho da imagem. O Devin lê seu `requirements.txt` ou `pyproject.toml` para cuidar do restante. ```txt Dockerizar API Django com Postgres e Redis theme={null} Dockerize a API Django em src/. Ela usa PostgreSQL como banco de dados e Redis para cache e filas de tarefas do Celery. - Dockerfile multi-stage: instale as dependências em um estágio de build, copie apenas o venv para uma imagem de runtime python:3.12-slim enxuta - docker-compose.yml com Django (gunicorn), PostgreSQL 16 e Redis 7 - .dockerignore que exclui tests, docs, .git e __pycache__ - Executar como usuário não root - Health check em /api/health/ - Worker Celery como um serviço separado no compose ## Testes e verificação - Fazer o build da imagem e executar docker-compose up - Aguardar até que todos os serviços estejam saudáveis - Verificar se a API responde em localhost:8000/api/health/ - Executar a suíte de testes do Django dentro do contêiner - Se algo falhar — erros de build, variáveis de ambiente ausentes, problemas de conexão, testes falhando — depure e corrija. Continue iterando até que toda a stack suba sem erros e todos os testes passem. - Não abra um PR até que tudo funcione de ponta a ponta ``` Devin lê seu projeto Django e arquivos de dependência para entender o processo de build e, em seguida, cria a configuração do Docker: 1. **Lê arquivos de dependência** — Analisa `requirements.txt` ou `pyproject.toml`, identifica Django, psycopg2, redis, celery e gunicorn 2. **Escreve o Dockerfile** — Cria um build multiestágio que instala as dependências em um estágio de build e copia o ambiente virtual para uma imagem de runtime mínima `python:3.12-slim` ```dockerfile theme={null} # ---- Builder ---- FROM python:3.12-slim AS builder WORKDIR /app COPY requirements.txt . RUN python -m venv /opt/venv \ && /opt/venv/bin/pip install --no-cache-dir -r requirements.txt # ---- Runtime ---- FROM python:3.12-slim RUN groupadd -r django && useradd -r -g django django COPY --from=builder /opt/venv /opt/venv ENV PATH="/opt/venv/bin:$PATH" WORKDIR /app COPY src/ . RUN python manage.py collectstatic --noinput EXPOSE 8000 USER django CMD ["gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "3"] ``` 3. **Cria o docker-compose.yml** — Adiciona Django, PostgreSQL, Redis e um worker do Celery com verificações de integridade, volumes e uma rede compartilhada ```yaml theme={null} services: web: build: . ports: - "8000:8000" env_file: .env depends_on: db: condition: service_healthy redis: condition: service_healthy healthcheck: test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health/')"] interval: 10s retries: 3 db: image: postgres:16-alpine environment: POSTGRES_DB: app_db POSTGRES_USER: app_user POSTGRES_PASSWORD: app_pass volumes: - pgdata:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U app_user -d app_db"] interval: 5s retries: 5 redis: image: redis:7-alpine healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 5s retries: 5 celery: build: . command: celery -A config worker -l info env_file: .env depends_on: db: condition: service_healthy redis: condition: service_healthy volumes: pgdata: ``` 4. **Adiciona .dockerignore** — Exclui arquivos que não pertencem ao contexto de build (`__pycache__`, `.git`, `tests/`, `docs/`, `*.pyc`) 5. **Executa `docker compose up --build`** — Faz o build da imagem e inicia todos os serviços no terminal do Devin 6. **Verifica o aplicativo** — Executa um curl em `/api/health/` para confirmar que o Django inicia corretamente, conecta ao PostgreSQL e acessa o Redis Use comandos com barra durante a sessão para direcionar o fluxo de trabalho do Devin: * **`/plan`** — Peça ao Devin para descrever sua abordagem antes de escrever qualquer configuração Docker. Revise o plano e sugira alterações. * **`/test`** — Diga ao Devin para reconstruir e revalidar a stack de contêineres. Use isso após cada alteração para detectar problemas logo no início. * **`/review`** — Peça ao Devin para revisar seu próprio Dockerfile e a configuração do Docker Compose em busca de problemas de segurança, tamanho da imagem e melhores práticas antes de abrir o PR. Quando o Devin abrir o PR, revise os arquivos gerados. Algumas solicitações comuns: ```txt Otimizar tamanho da imagem theme={null} A imagem Docker tem 520 MB. Reduza o tamanho — garanta que não estamos copiando arquivos desnecessários, remova arquivos .pyc do venv e remova o pip da imagem final. ``` ```txt Adicionar hot-reload em desenvolvimento theme={null} Adicione um docker-compose.override.yml para desenvolvimento local que monte o diretório de código-fonte e execute o servidor de desenvolvimento do Django com auto-reload em vez de gunicorn. ``` ```txt Adicionar build Docker no CI theme={null} Crie um workflow do GitHub Actions que gere a imagem Docker em todo PR, execute pytest dentro do contêiner e faça push para o ECR ao fazer merge na main. Marque com o SHA do git. ``` Quando Devin abrir o PR, use o [Devin Review](https://app.devin.ai/review?utm_source=docs\&utm_medium=use-case-gallery) para revisar a configuração do Docker. O Devin Review pode identificar problemas de segurança (como execução como root, segredos expostos), ausência de boas práticas importantes (falta de `.dockerignore`, ausência de health checks) e inconsistências em relação à sua infraestrutura existente.

{title}