Laboratório em bancada

Laboratório: Deploy de uma aplicação Django com PostgreSQL usando Docker

Você terá uma aplicação Django rodando em ambiente isolado com banco PostgreSQL, acessível via navegador local. Tempo estimado: 120 minutos.

Ligado ao treinamento Desenvolvimento web com Python e Django

Duração estimada: 120 min
Passos: 13
Validações: 5

Objetivo

Demonstrar o ciclo completo de desenvolvimento e operação de uma aplicação Django: criação do projeto, modelagem, migração, autenticação básica, API simples, testes, configuração de banco PostgreSQL, empacotamento e execução com Docker. O laboratório cobre desde o setup até o acesso via browser e API REST.

Topologia

Uma máquina local (192.168.56.10) executa dois containers: um com Django (porta 8000), outro com PostgreSQL (porta 5432). O usuário interage via navegador e terminal. Django se conecta ao PostgreSQL pela rede Docker bridge.

Usuário
  |
  | HTTP (8000)
  v
[Django Container]---(5432)---[PostgreSQL Container]
      | Docker bridge network
      |
    Máquina local (192.168.56.10)

Equipamentos e software

Item	Requisito, licença ou versão
PC ou VM	1 vCPU, 2GB RAM, 10GB disco, acesso à internet, sistema Linux ou Windows 10+
Python	PSF · 3.11
Django	BSD · 4.2
PostgreSQL	PostgreSQL · 15
Docker	Apache-2.0 · a versão estável atual

Roteiro

Preparar diretório de trabalho
Crie um diretório para o projeto. Isso organiza os arquivos e facilita o versionamento.
```
mkdir ~/django_lab && cd ~/django_lab
```
O que você deve ver: Diretório criado e terminal posicionado nele.

Criar Dockerfile para Django

Defina um ambiente isolado para o Django. Isso garante portabilidade e reprodutibilidade.

cat > Dockerfile <<'EOF'
FROM python:3.11-slim
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
WORKDIR /app
COPY requirements.txt .
RUN pip install --upgrade pip && pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "labsite.wsgi:application", "--bind", "0.0.0.0:8000"]
EOF

O que você deve ver: Arquivo Dockerfile criado no diretório.

Criar arquivo requirements.txt
Liste as dependências do projeto. Isso permite o build automatizado do container.
```
echo -e 'Django==4.2
psycopg2-binary==2.9.6
djangorestframework==3.14.0
gunicorn==20.1.0' > requirements.txt
```
O que você deve ver: Arquivo requirements.txt com dependências salvas.

Criar docker-compose.yml

Orquestre os containers Django e PostgreSQL. Isso simplifica o gerenciamento dos serviços.

cat > docker-compose.yml <<'EOF'
version: '3.9'
services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: labdb
      POSTGRES_USER: labuser
      POSTGRES_PASSWORD: labpass
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"
  web:
    build: .
    command: gunicorn labsite.wsgi:application --bind 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    depends_on:
      - db
    environment:
      - DJANGO_SUPERUSER_USERNAME=admin
      - DJANGO_SUPERUSER_PASSWORD=adminpass
      - DJANGO_SUPERUSER_EMAIL=admin@example.com
volumes:
  pgdata:
EOF

O que você deve ver: Arquivo docker-compose.yml criado com serviços web e db definidos.

Criar projeto Django
Inicialize o projeto Django no diretório. Isso estrutura a aplicação.
```
docker run --rm -v $PWD:/app -w /app python:3.11-slim bash -c "pip install Django==4.2 && django-admin startproject labsite ."
```
O que você deve ver: Diretório labsite e manage.py criados.

Configurar conexão com PostgreSQL

Edite settings.py para usar PostgreSQL, pois é mais robusto que SQLite em produção.

sed -i "/'ENGINE':/c\        'ENGINE': 'django.db.backends.postgresql',\n        'NAME': 'labdb',\n        'USER': 'labuser',\n        'PASSWORD': 'labpass',\n        'HOST': 'db',\n        'PORT': '5432'," labsite/settings.py

O que você deve ver: Arquivo settings.py configurado para PostgreSQL.

Criar app Django para cadastro de tarefas
Um app permite modularizar funcionalidades. Aqui, será uma lista simples de tarefas.
```
docker-compose run --rm web python manage.py startapp tasks
```
O que você deve ver: Diretório tasks criado com arquivos padrão.

Definir modelo Task

Modelos representam dados persistidos. Crie um modelo Task em tasks/models.py.

echo -e 'from django.db import models\nclass Task(models.Model):\n    title = models.CharField(max_length=100)\n    completed = models.BooleanField(default=False)\n    def __str__(self):\n        return self.title' > tasks/models.py

O que você deve ver: Arquivo models.py com classe Task.

Registrar app e rodar migrações

Inclua 'tasks' em INSTALLED_APPS e aplique migrações para criar tabelas no banco.

sed -i "/INSTALLED_APPS = \\[/a \\    'tasks'," labsite/settings.py && docker-compose run --rm web python manage.py makemigrations tasks && docker-compose run --rm web python manage.py migrate

O que você deve ver: Migrações aplicadas, tabelas criadas no PostgreSQL.

Criar superusuário Django
Permite acessar o admin e gerenciar tarefas pela interface web.
```
docker-compose run --rm web python manage.py createsuperuser --noinput --username admin --email admin@example.com
```
O que você deve ver: Superusuário criado (verifique variáveis de ambiente para senha).

Criar view e URL para API de tarefas

Implemente uma API REST básica usando Django REST Framework.

echo -e 'from rest_framework import serializers, viewsets\nfrom .models import Task\nclass TaskSerializer(serializers.ModelSerializer):\n    class Meta:\n        model = Task\n        fields = ["id", "title", "completed"]\nclass TaskViewSet(viewsets.ModelViewSet):\n    queryset = Task.objects.all()\n    serializer_class = TaskSerializer' > tasks/api.py

sed -i "/urlpatterns = /a \\    path('api/tasks/', include('tasks.urls'))," labsite/urls.py

echo -e 'from django.urls import path, include\nfrom rest_framework.routers import DefaultRouter\nfrom .api import TaskViewSet\nrouter = DefaultRouter()\nrouter.register(r"", TaskViewSet)\nurlpatterns = [\n    path("", include(router.urls)),\n]' > tasks/urls.py

O que você deve ver: API disponível em /api/tasks/.

Build e start dos containers
Suba os serviços Django e PostgreSQL juntos. Isso simula um ambiente real.
```
docker-compose up --build -d
```
O que você deve ver: Containers web e db rodando em background.
Acessar Django Admin e API
Valide o funcionamento via browser (admin) e curl (API).
O que você deve ver: Admin em http://localhost:8000/admin/ e API em http://localhost:8000/api/tasks/.

Como saber que funcionou

Teste	Comando	Critério
Acessar Django Admin	`xdg-open http://localhost:8000/admin/`	Tela de login do admin aparece; login com admin/adminpass funciona.
Criar tarefa pelo admin		Nova tarefa aparece na lista de tarefas do admin.
Acessar API de tarefas	`curl http://localhost:8000/api/tasks/`	Resposta JSON com lista de tarefas.
Criar tarefa via API	`curl -X POST -H "Content-Type: application/json" -d '{"title": "Estudar Django", "completed": false}' http://localhost:8000/api/tasks/`	Resposta JSON com tarefa criada.
Verificar containers	`docker-compose ps`	Status dos containers como 'Up'.

Troubleshooting

Sintoma	Causa provável	Correção
Erro de conexão ao banco	Configuração incorreta de HOST, USER ou PASSWORD em settings.py	Revise settings.py e docker-compose.yml; reinicie os containers.
Admin não acessível em localhost:8000	Porta não exposta ou container web não está rodando	Verifique docker-compose ps e logs; ajuste docker-compose.yml se necessário.
Falha ao rodar migrações	Banco não inicializado ou dependência não instalada	Aguarde o container db iniciar; verifique logs do serviço db.
API retorna erro 404	URLs não incluídas corretamente em labsite/urls.py	Confirme inclusão de 'api/tasks/' e importações corretas.