---
title: "Deploy de Aplicacao Python — 2026 | Python Brasil"
url: "https://python.dev.br/blog/deploy-aplicacao-python/"
markdown_url: "https://python.dev.br/blog/deploy-aplicacao-python.MD"
description: "Guia completo de deploy para aplicacoes Python. Aprenda a publicar em Heroku, Railway e VPS com exemplos praticos e configuracoes prontas."
date: "2026-03-01"
author: "Equipe Python Brasil"
---

# Deploy de Aplicacao Python — 2026 | Python Brasil

Guia completo de deploy para aplicacoes Python. Aprenda a publicar em Heroku, Railway e VPS com exemplos praticos e configuracoes prontas.


Desenvolver uma aplicacao e apenas metade do caminho. O deploy, ou seja, colocar a aplicacao em producao para que usuarios reais possam acessa-la, e uma etapa que muitos desenvolvedores acham desafiadora. Neste guia, a gente vai explorar tres opcoes populares para deploy de aplicacoes Python: Heroku, Railway e VPS, com configuracoes prontas para usar.

## Preparando a Aplicacao para Deploy

Antes de qualquer deploy, sua aplicacao precisa estar pronta para producao:

```python
# app.py - Aplicacao FastAPI de exemplo
from fastapi import FastAPI
import os

app = FastAPI(title="Minha API")

@app.get("/")
def index():
    return {"mensagem": "API em producao!", "versao": "1.0.0"}

@app.get("/saude")
def healthcheck():
    return {"status": "ok"}

if __name__ == "__main__":
    import uvicorn
    porta = int(os.environ.get("PORT", 8000))
    uvicorn.run(app, host="0.0.0.0", port=porta)
```

Arquivos essenciais:

```
meu-projeto/
    app.py
    requirements.txt
    Procfile
    runtime.txt
    .env.example
    .gitignore
```

O `requirements.txt`:

```
fastapi==0.109.0
uvicorn[standard]==0.27.0
gunicorn==21.2.0
python-dotenv==1.0.0
```

O `.gitignore`:

```
__pycache__/
*.pyc
.env
venv/
.venv/
*.db
```

## Deploy no Heroku

Heroku e uma das plataformas mais tradicionais para deploy de aplicacoes Python.

### Configuracao

Crie o `Procfile` (sem extensao):

```
web: gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app
```

O `runtime.txt`:

```
python-3.12.1
```

### Passo a Passo

```bash
# Instalar Heroku CLI
# https://devcenter.heroku.com/articles/heroku-cli

# Login
heroku login

# Criar aplicacao
heroku create minha-api-python

# Configurar variaveis de ambiente
heroku config:set SECRET_KEY=minha-chave-secreta
heroku config:set DATABASE_URL=postgresql://...
heroku config:set ENVIRONMENT=production

# Deploy via Git
git add .
git commit -m "Deploy inicial"
git push heroku main

# Verificar logs
heroku logs --tail

# Escalar dynos
heroku ps:scale web=1
```

### Banco de Dados no Heroku

```bash
# Adicionar PostgreSQL
heroku addons:create heroku-postgresql:essential-0

# Verificar URL do banco
heroku config:get DATABASE_URL

# Rodar migrations
heroku run python manage.py migrate
```

## Deploy no Railway

Railway e uma alternativa moderna ao Heroku, com deploy automatico via GitHub:

### Configuracao

Crie o arquivo `railway.toml`:

```toml
[build]
builder = "nixpacks"

[deploy]
startCommand = "gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app --bind 0.0.0.0:$PORT"
healthcheckPath = "/saude"
healthcheckTimeout = 30
restartPolicyType = "on_failure"
restartPolicyMaxRetries = 3
```

Ou use um `Procfile`:

```
web: gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app --bind 0.0.0.0:$PORT
```

### Passo a Passo

```bash
# Instalar Railway CLI
npm install -g @railway/cli

# Login
railway login

# Inicializar projeto
railway init

# Adicionar PostgreSQL
railway add --plugin postgresql

# Configurar variaveis
railway variables set SECRET_KEY=minha-chave
railway variables set ENVIRONMENT=production

# Deploy
railway up

# Ver logs
railway logs
```

Railway detecta automaticamente o Python pelo `requirements.txt` e configura o ambiente. A integracao com GitHub permite deploys automaticos a cada push.

### Configuracao com Docker no Railway

```dockerfile
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD gunicorn -w 4 -k uvicorn.workers.UvicornWorker app:app --bind 0.0.0.0:$PORT
```

## Deploy em VPS (Servidor Virtual)

Para controle total, uma VPS (Digital Ocean, AWS EC2, Hetzner) e a melhor opcao:

### Configuracao do Servidor

```bash
# Conectar ao servidor
ssh usuario@ip-do-servidor

# Atualizar sistema
sudo apt update && sudo apt upgrade -y

# Instalar dependencias
sudo apt install -y python3-pip python3-venv nginx certbot python3-certbot-nginx

# Criar usuario para a aplicacao
sudo useradd -m -s /bin/bash appuser
sudo su - appuser

# Clonar projeto
git clone https://github.com/usuario/meu-projeto.git
cd meu-projeto

# Criar ambiente virtual
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

### Systemd Service

Crie o servico para manter a aplicacao rodando:

```ini
# /etc/systemd/system/minha-app.service
[Unit]
Description=Minha Aplicacao Python
After=network.target

[Service]
User=appuser
Group=appuser
WorkingDirectory=/home/appuser/meu-projeto
Environment="PATH=/home/appuser/meu-projeto/venv/bin"
EnvironmentFile=/home/appuser/meu-projeto/.env
ExecStart=/home/appuser/meu-projeto/venv/bin/gunicorn \
    -w 4 \
    -k uvicorn.workers.UvicornWorker \
    --bind 127.0.0.1:8000 \
    app:app
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
```

Ativar o servico:

```bash
sudo systemctl daemon-reload
sudo systemctl enable minha-app
sudo systemctl start minha-app
sudo systemctl status minha-app
```

### Nginx como Reverse Proxy

```nginx
# /etc/nginx/sites-available/minha-app
server {
    listen 80;
    server_name meudominio.com.br;

    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;
    }

    location /static/ {
        alias /home/appuser/meu-projeto/static/;
    }
}
```

Ativar e configurar SSL:

```bash
# Ativar site
sudo ln -s /etc/nginx/sites-available/minha-app /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

# Certificado SSL com Let's Encrypt
sudo certbot --nginx -d meudominio.com.br
```

### Script de Deploy Automatizado

```python
#!/usr/bin/env python3
"""Script de deploy para VPS."""

import subprocess
import sys

def executar(comando):
    """Executa comando e verifica resultado."""
    print(f"Executando: {comando}")
    resultado = subprocess.run(comando, shell=True)
    if resultado.returncode != 0:
        print(f"Erro no comando: {comando}")
        sys.exit(1)

def deploy():
    """Realiza deploy completo."""
    print("Iniciando deploy...")

    executar("git pull origin main")
    executar("source venv/bin/activate && pip install -r requirements.txt")
    executar("python manage.py migrate")  # Se usar banco de dados
    executar("sudo systemctl restart minha-app")

    print("Deploy concluido com sucesso!")

if __name__ == "__main__":
    deploy()
```

## Comparacao das Plataformas

| Aspecto | Heroku | Railway | VPS |
|---------|--------|---------|-----|
| Facilidade | Alta | Alta | Media |
| Controle | Baixo | Medio | Total |
| Custo | A partir de $5/mes | A partir de $5/mes | A partir de $4/mes |
| SSL | Automatico | Automatico | Manual (Let's Encrypt) |
| Escalar | Facil | Facil | Manual |
| CI/CD | Git push | GitHub integration | Manual ou GitHub Actions |

## Checklist de Deploy

Antes de publicar, verifique estes itens:

- Variaveis de ambiente configuradas (sem segredos no codigo)
- Debug desativado em producao
- HTTPS habilitado
- Logs configurados adequadamente
- Healthcheck endpoint funcionando
- Banco de dados com backup automatico
- Monitoramento de erros configurado (Sentry)
- Rate limiting ativo nas APIs
- CORS configurado corretamente

## Boas Praticas

Ao fazer deploy de aplicacoes Python, siga estas recomendacoes:

- Use gunicorn com workers uvicorn para aplicacoes ASGI em producao
- Configure variaveis de ambiente para cada ambiente (dev, staging, prod)
- Implemente CI/CD com GitHub Actions para deploys automaticos
- Monitore a aplicacao com ferramentas como Sentry e Prometheus
- Faca backups regulares do banco de dados
- Use health checks para reinicio automatico em caso de falha

## Conclusao

Cada plataforma de deploy tem seus pontos fortes. Heroku e Railway sao ideais para comecar rapido sem se preocupar com infraestrutura. Uma VPS oferece controle total e pode ser mais economica para projetos maiores. Independente da escolha, o importante e seguir boas praticas de seguranca, monitoramento e automacao. Comece com a opcao mais simples e migre quando necessario.

> **Deploy simplificado**: uma vantagem de linguagens compiladas como <a href="https://golang.com.br/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'golang.com.br' })">Go</a> e que o deploy se resume a copiar um unico binario estatico para o servidor, sem dependencias ou ambientes virtuais. Se voce trabalha com microsservicos onde simplicidade de deploy e prioridade, vale conhecer essa abordagem.