Onde publico uma API em Python com FastAPI que fiz com IA?

O Dongee Live não executa Python, então você publica sua API FastAPI feita com IA no Dongee Cloud ou no Cloud On Demand, com root por SSH, Docker Compose, Nginx na frente e HTTPS com certbot.

Você pode publicar API FastAPI feita com IA em um servidor Dongee Cloud ou no Cloud On Demand. Lá você tem acesso root por SSH e pode usar Docker sem restrições. O Dongee Live, a hospedagem para apps feitos com IA, não executa Python (só sites estáticos e Node), então só serve se sua API for em Node.

Abaixo está a receita completa, do servidor vazio até a API com HTTPS.

Atualizado em 21 de novembro de 2026 · Equipe Dongee

Por que não posso publicar FastAPI no Dongee Live?

O Dongee Live foi pensado para apps feitos com ChatGPT, Lovable, Bolt, v0, Claude Code, Cursor ou VS Code. Ele aceita sites estáticos e Node 20, 22 e 24 (Express, Fastify, Koa, Hono, Next.js standalone, TanStack Start). Não aceita Python, Ruby, PHP nem Docker. Se a IA gerou para você um backend com FastAPI, você precisa de um servidor onde controla o ambiente: isso é o Dongee Cloud.

O Dongee Cloud é autogerenciado: você administra o servidor, mas conta com suporte humano 24/7 em português, com tradução em tempo real da plataforma, por chat e WhatsApp se algo não fizer sentido.

Qual opção da Dongee convém para cada API?

Tipo de APIOpção da DongeePreço de entradaQuem administra
FastAPI / Python, carga estávelDongee Cloud (Cloud 1 ou Cloud 2)17 USD/mês (Cloud 1) ou 34 USD/mês (Cloud 2)Você (root, Docker)
FastAPI / Python, recursos sob medida ou carga variávelCloud On DemandA partir de 17 USD/mêsVocê (root, Docker)
Node / Express, Fastify, HonoDongee Live0 USD (Live Free), 15 USD (Live Pro)A Dongee mantém o sistema, o servidor web e o HTTPS

Com o Cloud On Demand você escolhe os recursos um a um: 6 USD por vCPU, 3 USD por GB de RAM e 0,3 USD por GB de disco SSD, com mínimo de 17 USD/mês. Inclui backups automáticos e recuperação de desastres sem custo extra.

Como publico minha API FastAPI passo a passo?

  1. Crie o servidor. Para uma API pequena, o Cloud 1 (1 CPU, 1 GB de RAM, 25 GB SSD) basta. Se você vai ter banco de dados no mesmo servidor, melhor o Cloud 2 (1 CPU, 2 GB). Escolha a localização mais próxima dos seus usuários entre Atlanta, Miami, Nova York, Dallas, México, São Paulo, Santiago, Frankfurt, Madri, Londres e Amsterdã. A implantação leva menos de 3 minutos.
  2. Conecte-se por SSH. Se nunca fez isso, siga o guia para conectar-se por SSH ao seu servidor Cloud pelo Windows ou Mac.
  3. Instale o Docker e o Docker Compose. No Ubuntu:
sudo apt update
sudo apt install -y docker.io docker-compose-v2 nginx
sudo systemctl enable --now docker
  1. Suba o seu código com git clone a partir do GitHub ou com scp. Verifique se existe um requirements.txt com fastapi, uvicorn e gunicorn.
  2. Crie um Dockerfile mínimo:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["gunicorn", "main:app", "-k", "uvicorn.workers.UvicornWorker", "-w", "2", "-b", "0.0.0.0:8000"]

Para um teste rápido, uvicorn main:app --host 0.0.0.0 --port 8000 serve. Em produção, use vários workers, com uvicorn --workers 2 ou com gunicorn como acima. Uma regra prática é um worker por CPU, mais um.

  1. Defina o docker-compose.yml com a API e, se precisar, o banco de dados:
services:
  api:
    build: .
    env_file: .env
    ports:
      - "127.0.0.1:8000:8000"
    restart: unless-stopped
    depends_on:
      - db
  db:
    image: postgres:16
    env_file: .env
    environment:
      - PGDATA=/data/pgdata
    volumes:
      - dbdata:/data
    restart: unless-stopped
volumes:
  dbdata:

Repare no 127.0.0.1:8000:8000: a porta só é publicada no próprio servidor, não para a internet. O padrão é o mesmo do guia para instalar o n8n com Docker Compose em um servidor Cloud.

  1. Guarde as variáveis em um arquivo .env (chaves de API, DATABASE_URL, senhas) e adicione-o ao .gitignore para que nunca chegue ao repositório. Depois suba os contêineres:
docker compose up -d --build
docker compose logs -f api
  1. Coloque o Nginx como proxy reverso. Crie um arquivo chamado api.conf na pasta de sites do Nginx com este bloco:
server {
    listen 80;
    server_name api.seudominio.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;
    }
}

Valide e recarregue com sudo nginx -t && sudo systemctl reload nginx. Antes, aponte um registro A do seu domínio para o IP dedicado do servidor.

  1. Ative o HTTPS com o certbot:
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d api.seudominio.com.br

O certbot edita o bloco do Nginx e agenda a renovação automática do certificado.

  1. Crie um snapshot antes de cada atualização e escale quando crescer. Todos os planos Cloud trazem snapshots incrementais e backup de disco. Se algo der errado depois de um git pull e docker compose up -d --build, você volta atrás. Quando a API precisar de mais potência, você pode escalar CPU e RAM do seu servidor Cloud sem reiniciar nem migrar.

Quais erros são comuns ao publicar FastAPI feito com IA?

  • Fazer bind em 127.0.0.1 dentro do contêiner. Muitos exemplos gerados por IA usam --host 127.0.0.1. Dentro do Docker, isso deixa a API inacessível até para o Nginx. Dentro do contêiner use 0.0.0.0 e limite a exposição no ports do compose.
  • CORS aberto ou mal configurado. allow_origins=["*"] junto com credenciais é má ideia. Declare no CORSMiddleware apenas os domínios do seu frontend.
  • Porta 8000 aberta para a internet sem proxy. Se você publica "8000:8000", a API fica exposta sem HTTPS. Lembre-se de que o Docker pode ignorar as regras do firewall do sistema. Publique em 127.0.0.1 e deixe o Nginx ser a única porta de entrada.
  • Usar --reload em produção. É para desenvolvimento: consome recursos vigiando arquivos e não aceita vários workers.
  • Chaves no repositório. Se a IA escreveu a chave do seu banco de dados ou de um modelo direto no main.py, mova-a para o .env e troque a chave. Uma chave que chegou ao GitHub deve ser considerada vazada.
  • Não reiniciar após quedas. Sem restart: unless-stopped, uma falha ou um reinício do servidor deixa a API desligada.

Perguntas frequentes

Posso publicar FastAPI no Dongee Live se eu transformar em estático?

Não. Uma API precisa de um processo em execução, e o Live só executa sites estáticos e apps Node. Se o seu frontend é estático ou Node, você pode publicá-lo no Live e chamar a API FastAPI que roda no Dongee Cloud.

Quanto custa publicar uma API FastAPI na Dongee?

O Cloud 1 custa 17 USD/mês e o Cloud 2, 34 USD/mês. O Cloud On Demand começa em 17 USD/mês e é calculado por vCPU, RAM e disco. Você pode pagar em COP, USD, EUR, MXN, PEN, CLP ou BRL.

Preciso saber administrar servidores?

Um pouco, sim: o Dongee Cloud é autogerenciado e você instala e mantém o Docker, o Nginx e o sistema. Se travar, o suporte humano 24/7 ajuda você a revisar, e você também pode pedir migração assistida.

Posso usar Supabase ou outro banco de dados externo em vez de um local?

Sim. Remova o serviço db do compose e coloque a string de conexão externa no .env. Assim o servidor fica com menos carga e o Cloud 1 pode ser suficiente.

O que faço se minha API crescer e precisar de vários servidores?

Primeiro, escale CPU e RAM sem reiniciar. Se depois precisar de várias instâncias, você pode conectá-las pela rede privada sem custo e montar seu próprio balanceador com Nginx ou HAProxy. A Dongee não vende balanceador gerenciado.

Em resumo: se a sua API é FastAPI, ela vai no Dongee Cloud ou no Cloud On Demand, com Docker Compose, Nginx na frente e HTTPS com certbot. Se é Node, o Dongee Live poupa você de todo esse trabalho de servidor.

Comenta lo que quieras

Unete a la charla
Solo ingresa tu email