Como publicar seu site Python na internet

Por que não usar o servidor de desenvolvimento

Quando você roda flask run ou python app.py, o Flask usa um servidor simples feito para desenvolvimento. Ele não foi projetado para lidar com múltiplas requisições simultâneas, não é seguro e não é estável o suficiente para produção.

Para colocar seu site no ar, você precisa de um servidor WSGI como o Gunicorn.

Gunicorn: o servidor de produção

O Gunicorn (Green Unicorn) é um servidor HTTP WSGI para Python. Ele cria múltiplos processos (workers) para atender requisições em paralelo:

pip install gunicorn

Para rodar sua aplicação:

gunicorn app:app --bind 0.0.0.0:8000 --workers 4

O parâmetro --workers 4 cria 4 processos. A regra geral é usar 2 * num_cpus + 1 workers.

Variáveis de ambiente

Nunca coloque senhas, chaves secretas ou URIs de banco diretamente no código. Use variáveis de ambiente:

import os

app = Flask(__name__)
app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "chave-padrao-dev")

MONGO_URI = os.environ.get("MONGO_URI", "mongodb://localhost:27017/meu_banco")

Para facilitar o desenvolvimento local, use o python-dotenv:

pip install python-dotenv

Crie um arquivo .env na raiz do projeto:

SECRET_KEY=minha-chave-super-secreta-123
MONGO_URI=mongodb://usuario:senha@servidor:27017/banco?authSource=banco
DEBUG=false

E carregue no início da aplicação:

from dotenv import load_dotenv
load_dotenv()

O .env nunca deve ser commitado no git. Adicione-o ao .gitignore.

Criando o Dockerfile

O Dockerfile define como construir a imagem do seu aplicativo:

FROM python:3.12-slim

WORKDIR /app

# Copia e instala dependencias primeiro (melhor cache)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copia o codigo da aplicacao
COPY . .

# Porta que o Gunicorn vai usar
EXPOSE 8000

# Comando de inicializacao
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "4"]

O requirements.txt:

flask==3.1.0
pymongo==4.16.0
gunicorn==23.0.0
python-dotenv==1.1.0

Para construir e rodar:

docker build -t meu-site .
docker run -p 8000:8000 --env-file .env meu-site

Docker Compose com MongoDB

Para rodar o Flask junto com o MongoDB, use o docker-compose.yml:

services:
  web:
    build: .
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      - mongo
    restart: unless-stopped

  mongo:
    image: mongo:7
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: senha_segura
    restart: unless-stopped

volumes:
  mongo_data:

Com isso, um simples comando sobe tudo:

docker compose up -d

O depends_on garante que o MongoDB inicie antes do Flask. O volume mongo_data persiste os dados mesmo se o container for recriado.

Health check endpoint

É uma boa prática ter um endpoint que indica se a aplicação está funcionando:

@app.route("/health")
def health():
    try:
        mongo_client.admin.command("ping")
        return {"status": "ok", "database": "connected"}, 200
    except Exception:
        return {"status": "error", "database": "disconnected"}, 503

Ferramentas de monitoramento e orquestradores como Kubernetes usam esse endpoint para verificar a saúde da aplicação.

Nginx como reverse proxy

Em produção, é comum colocar o Nginx na frente do Gunicorn. O Nginx cuida de servir arquivos estáticos, SSL (HTTPS), compressão e balanceamento de carga:

# /etc/nginx/sites-available/meu-site
server {
    listen 80;
    server_name meusite.com.br;

    # Arquivos estaticos servidos diretamente pelo Nginx
    location /static/ {
        alias /app/static/;
        expires 7d;
    }

    # Demais requisicoes vao para o Gunicorn
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

O Nginx serve os arquivos estáticos muito mais rápido que o Python, liberando o Gunicorn para focar nas rotas dinâmicas.

Checklist final de deploy

Antes de colocar no ar, verifique cada item:

• DEBUG está desativado (False)
• SECRET_KEY é uma string longa e aleatória
• Credenciais do banco estão em variáveis de ambiente, não no código
• .env está no .gitignore
• Gunicorn está configurado com número adequado de workers
• Health check endpoint está funcionando
• Nginx está servindo arquivos estáticos
• HTTPS está configurado (use Let's Encrypt para certificados gratuitos)
• Logs estão sendo armazenados e monitorados

Conclusão

Com Docker, Gunicorn e Nginx, seu site Flask está pronto para produção. O Docker garante que o ambiente seja idêntico em qualquer servidor, o Gunicorn lida com múltiplas requisições e o Nginx otimiza a entrega de conteúdo. Essa é a mesma stack usada por milhares de aplicações Python em produção.