No dia 2 de julho de 2026, numa única hora, quase mil bots rodando Chrome abriram o CourseShelf, cada um numa página de curso, e o site ficou uns 90 minutos fora do ar. O servidor caiu por falta de memória mais de 6 vezes, até o Fly parar de reiniciar a máquina sozinho.

O pior é que eu tinha um limite de conexões no proxy justamente pra isso. Só que era um limite de 1.000 conexões numa máquina de 1 GB.

tudo pegando fogo

E quando eu dobrei a memória e o servidor parou de cair, o site continuou fora, por causa de uma configuração que eu nunca tinha olhado. O banco de dados, nessa hora, estava parado.

Eu conto aqui o que quebrou, na ordem, como fui descobrindo e o que mudei. Se você coloca app no ar, uma hora um flood desses chega aí também.

https://www.youtube.com/watch?v=MM0vvNjm8EY

Não eram pessoas

O CourseShelf é um site pequeno, com tráfego perto de zero num dia normal. Quando abri o Plausible, que é o analytics que eu uso, o gráfico saía de perto de zero direto pro pico. Na hora do pico foram 961 visitantes únicos, e no dia uns 2 mil.

Dava pra ver que não eram pessoas:

  • quase todos vinham de Direct, sem nenhum site de origem;
  • 100% Chrome;
  • espalhados por países como Vietnã, Colômbia, Malásia, Indonésia e Equador;
  • 91% de bounce e 1,14 página por visita: abriam uma página e iam embora;
  • as páginas eram todas de cursos, espalhadas pelo catálogo inteiro.

O que deixou esses bots caros foi um detalhe: eles executavam JavaScript. Um bot simples pede o HTML e vai embora. Esses eram Chrome de verdade, tudo indica que sem interface, renderizando a página inteira. Por isso o Plausible, que roda por JavaScript, chegou a contar eles.

O CourseShelf é feito em Phoenix LiveView, e nele cada visita acontece em dois passos. Primeiro o servidor responde com o HTML pronto. Depois o JavaScript da página abre uma conexão que fica aberta, e o servidor monta a página de novo, num processo que continua vivo na memória enquanto a conexão existir. Os dois passos fazem consultas no banco. Cada bot custava duas rodadas de consulta e um processo ocupando memória, multiplicado por centenas ao mesmo tempo. Eram uns 50 requests por segundo, o que parece pouco, mas cada um deles custava tudo isso.

Eu já tinha um filtro de bot no CourseShelf, que olhava o user agent. Esses mandavam o user agent de um Chrome comum e passaram direto, e o contador de visualizações dos cursos ficou inflado naquele período. User agent é o cliente quem diz, e qualquer um escreve o que quiser ali.

Quem eram? Eu não sei. Pode ter sido um ataque de propósito ou um scraper que alguém soltou sem cuidado. Um crawler de empresa de IA coletando dados pra treinar modelo teria esse mesmo perfil, com navegador de verdade, vindo de todo lugar e passando pelo catálogo inteiro. Pra uma máquina de 1 GB, dava no mesmo.

Primeiro problema: a memória

O CourseShelf roda numa única máquina no Fly com 1 GB de memória. Na frente dela fica o proxy do Fly, e nele dá pra configurar um limite de conexões simultâneas. Quando passa do hard limit, o proxy devolve 503 e nem manda a requisição pra sua máquina. O meu estava em 1.000.

Cada conexão de LiveView custa alguns megas, então 1.000 nunca ia caber em 1 GB. Na prática eu não tinha limite nenhum. Eu percebi porque tentei abrir o CourseShelf, o websocket demorava demais pra conectar e às vezes a página nem renderizava.

O que aconteceu foi isto. Às 10h15 da manhã, no horário de Brasília, o flood começou, e as centenas de LiveViews montando ao mesmo tempo foram empilhando processos e conexões na memória. Uns 2 minutos depois de cada boot, a máquina chegava no teto de 961 MB e o kernel matava tudo. Foram mais de 6 vezes, entre 10h30 e 11h25, até o Fly parar de reiniciar. O tempo todo o site ficou fora.

Três sinais apontaram pra memória:

  1. fly machine status, que mostra o histórico da máquina: lá estava oom_killed igual a true, de novo e de novo.
  2. fly logs: tirando as linhas do proxy, não tinha nenhuma linha do app. O app morria antes de conseguir escrever um log.
  3. fly ssh console e o /proc/pressure/memory, em que o kernel conta quanto tempo os processos ficam parados esperando memória. Deu 40% do tempo com tudo parado, e a pressão de IO estava em 67%. No gráfico de CPU do Fly, quase tudo era iowait. A máquina não estava atendendo requisição, estava trocando memória com o disco.

A conta que eu devia ter feito antes é simples: quanto cada conexão custa de memória vezes o hard limit tem que caber na RAM da máquina. O limite do proxy é o que protege a memória. Sem ele, quem decide quantas conexões entram é quem manda o tráfego.

ih, não

Segundo problema: o pool de conexões

Pra segurar a situação, eu dobrei a memória com fly scale memory 2048, que aplica na hora. A máquina parou de morrer. Só que o site não voltou: as páginas de curso continuavam dando erro 500.

Fui olhar o Honeybadger, que é onde chegam os erros do app. Era a mesma mensagem milhares de vezes: Connection not available and request was dropped from queue, aparecendo em vários tipos de erro, com 1.500 num e 1.100 em outro.

Essa mensagem vem do pool de conexões com o banco. O pool funciona como uma fila: o app abre um número fixo de conexões, e cada consulta pega uma emprestada, usa e devolve. Se todas estão ocupadas, a consulta espera, e se esperar demais é descartada. No Ecto, a biblioteca de banco do Elixir, o padrão são 10 conexões.

Dava pra achar que o banco não aguentou. Mas eu olhei o /proc/pressure na máquina do Postgres, que estava com uns 3% de CPU e 0 de pressão de memória. O banco estava parado. Quem estava sem conexão era o app, com as 10 dele. Pool esgotado com banco ocioso quer dizer que o problema é o tamanho do pool, e escalar o Postgres não ia ajudar em nada.

10 não bastava porque cada visita de bot fazia a renderização inicial e depois o live mount, e em cada um deles os preloads, que carregam os dados relacionados, rodavam em paralelo, cada um segurando uma conexão. Eram centenas de visitas disputando 10 conexões. Subi o pool pra 40, que ainda é bem menos do que o Postgres aceita.

Meu erro no meio: o cache

Quando o pool estourava, meu cache não tratava a falha direito. Num caso, o erro vazava como um erro da biblioteca de cache, uns 2.600 avisos. No outro, ele voltava como se fosse o valor guardado, e o código que usava explodia com um CaseClauseError, uns 800.

Hoje, se o banco não responde, o cache levanta um UnavailableError, que vira 503, e a falha não fica guardada. Assim a primeira requisição depois que o banco volta já recalcula. Banco indisponível é 503, não 500.

Com a memória, o pool e o limite do proxy ajustados, o site voltou às 11h45, uns 90 minutos depois do começo.

O que ficou no fly.toml

A correção de 2 de julho foram três mudanças:

AntesDepois do incidente
Memória1 GB2 GB
Limite do proxy (soft/hard)1.000 / 1.000200 / 400
Pool de conexões1040

Só que isso não é o que está no ar hoje. Em 27 de outubro eu voltei pra 1 GB e baixei os limites do proxy, porque a conta do Fly estava alta: em 30 dias a memória nunca passou de 760 MB, com no máximo 8 conexões ao mesmo tempo. Eu pagava por uma folga que só um flood ia usar. O trecho atual de courseshelf-v2/fly.toml:

[env]
  POOL_SIZE = '40'

[http_service.concurrency]
  type = 'connections'
  hard_limit = 100
  soft_limit = 50

[[vm]]
  size = 'shared-cpu-4x'
  memory = '1024mb'
  cpu_kind = 'shared'

E repara como o limite de 100 resolve o erro do começo: 100 conexões vezes alguns megas cabem em 1 GB, e 1.000 não cabiam. A aposta é que, se vier outro flood, a máquina responde 503 pra quem passar de 100 e continua de pé. Durante o flood o site fica ruim pra quem tenta entrar, e eu aceito isso em vez de pagar todo mês por uma máquina maior.

O que ainda falta

O Fly não tem WAF, aquele firewall que reconhece padrão de bot antes da requisição chegar no app. Então hoje a minha proteção é aguentar o tranco e devolver 503, e o 503 não separa bot de visitante: durante o flood, todo mundo recebe.

Um limite por IP, que era o próximo passo que eu tinha anotado, ajudaria pouco contra esse flood específico, com quase mil visitantes abrindo uma página cada. A solução de verdade pra esse tipo de ataque seria colocar outro serviço na frente da aplicação, tipo a Cloudflare, que dá proteção contra bot antes da requisição chegar no meu servidor. Eu só não fiz isso ainda porque não queria adicionar mais uma infraestrutura pra cuidar.

O que eu levei disso

  • Calcule o limite do proxy pela memória da máquina.
  • Olhe o banco antes de culpar ele: pool esgotado com Postgres ocioso é problema do pool.
  • Não conte com o user agent pra reconhecer bot.

E você, já teve um app derrubado por bot ou por algum scraper? O que você fez pra se proteger? O site não tem seção de comentários, mas eu respondo no vídeo: quero saber o que funciona pra quem tem mais tráfego do que eu.

Vídeo no YouTube: Mil bots derrubaram meu SaaS

Conheça meu trabalho: https://bergholz.com.br/

Obrigado por ler até aqui.

The end