Home / Uncategorized / Como a OpenAI escalou o Habitat para 1 bilhão de usuários do ChatGPT: multi-tenancy, cache global e Cosmos DB

Como a OpenAI escalou o Habitat para 1 bilhão de usuários do ChatGPT: multi-tenancy, cache global e Cosmos DB

Em 23 de outubro de 2026, Jon Lee, Hrachya Hakobyan e Chaomin Yu publicaram no blog de engenharia da OpenAI a Part II de “Rapidly scaling online storage to serve over 1 billion ChatGPT users”, descrevendo como o Habitat, a plataforma de armazenamento online que fica entre todo produto da OpenAI e o banco, foi reorganizada em cima do Azure Cosmos DB. O resultado central: um modelo de multi-tenancy baseado em co-managed containers, com boa performance de leitura em escala global. A latência mediana de leitura global caiu de 120 ms para 10 ms.

Este artigo é sobre o mecanismo. O que exatamente é um co-managed container, por que a OpenAI tentou isolar workloads antes e voltou atrás, e como o cache Valkey com CDC mantém dados frescos em quase 40 regiões sem recorrer a TTL curto.

Como o Habitat se encaixa na pilha

Habitat não é um banco. É a plataforma de armazenamento online que fica entre cada produto da OpenAI e os stores subjacentes (Azure Cosmos DB, caches, blob storage), e cuida de roteamento, autorização, criptografia, caching, data residency, multi-tenancy e rate limiting. Em outras palavras, nenhum produto fala direto com o Cosmos DB. Todo mundo fala com o Habitat, e o Habitat decide o que fazer.

Essa escolha importa porque centraliza decisões que normalmente ficam espalhadas pelos times de produto: schema, replicação geográfica, quando usar cache, quando ir no banco. O modelo de dados é intencionalmente restrito: representa objetos e arestas, coloca cada objeto junto com suas arestas de saída para suportar particionamento, e exclui SQL arbitrário e traversals de grafo gerais. Essa restrição é o que permite particionar de forma previsível.

O preço dessa restrição aparece em consultas que atravessam múltiplos objetos: um objeto e suas arestas correspondentes ficam colocados juntos em uma partição no nível de armazenamento, mas nenhum esforço é feito para colocar objetos junto com os objetos remotos para os quais as arestas apontam, então qualquer hop entre objetos pode exigir buscar em duas contas do Cosmos DB diferentes em regiões diferentes. Em troca, cada partição individual escala de forma independente.

Como funciona a multi-tenancy em cima do Cosmos DB

Aqui está a decisão arquitetural mais interessante do post, e vale explicar devagar porque envolve três fases.

O que é um container no Cosmos DB

Habitat começou usando um container Cosmos DB default em cada conta. Um container agrupa dados e tem um orçamento de processamento atribuído. No vocabulário do Cosmos DB, esse orçamento se chama Request Unit por segundo (RU/s). Quando vários workloads dividem o mesmo container, dividem o mesmo orçamento. Compartilhar esse orçamento entre workloads, o que se chama multi-tenancy, expôs várias maneiras de usos aparentemente separados colidirem.

Pense numa régua de compras no supermercado. Enquanto o carrinho da frente só tem três itens, você passa rápido. No momento em que ele tem duzentos, todo mundo atrás espera, mesmo quem só queria pagar um pão. Uma feature de nicho que de repente começa a varrer dados pode travar o login. Essa é a dor que motivou a segunda fase. A analogia quebra num ponto: no supermercado você pode abrir outro caixa na hora, no banco você precisa reprovisionar antes.

Fase dois: containers separados, e o problema que veio junto

A resposta óbvia foi dar a cada workload o próprio container, com o próprio orçamento. Isolamento forte, blast radius pequeno. Mas apareceu um problema organizacional. Separar os containers do Azure Cosmos DB ajudou a limitar outages entre features, mas transferiu a previsão de capacidade para os times de produto, alguns dos quais tinham que escalar durante lançamentos.

E um problema técnico menos óbvio: um workload isolado perde o colchão de um pool de tráfego muito maior. A OpenAI ilustra a diferença com um caso de uso saltando de zero para 1 milhão de queries por segundo. Esse aumento mal mexeria na demanda total de um container compartilhado grande, enquanto representaria 1.000 vezes a carga baseline de um container dedicado usado só para testes internos. Em pool grande, pico individual se dilui. Em pool pequeno, pico individual quebra.

Fase três: co-managed containers

Esse peso organizacional empurrou o Habitat de volta para multi-tenancy por default, dessa vez com capacidade de movimentação de dados. A empresa trabalhou junto com a Azure em co-managed containers, em vez de continuar fazendo containers separados como resposta default para crescimento. Com essas mudanças, eles voltaram a usar um container compartilhado, o que simplificou significativamente a necessidade de planejamento de capacidade antecipado ou contínuo pelos times de produto, preservando isolamento entre workloads.

Os detalhes técnicos de como exatamente o Cosmos DB impõe fairness dentro de um container compartilhado para evitar que um workload coma o orçamento do outro não estão explicitados no post público. O que o post deixa claro é a propriedade desejada: compartilhar o pool para absorver pico, mas isolar o suficiente para que um vizinho barulhento não derrube ninguém. A “movimentação de dados” entra aí: quando um workload cresce demais para o container atual, dados podem ser realocados sem o time de produto precisar replanejar.

Como funciona o cache global com invalidação por CDC

A segunda metade da história é o cache. Com leituras passando de 90% das requisições, um cache lookaside distribuído evita viagens repetidas ao banco entre regiões. Servidores Valkey rodam perto do compute da aplicação.

A camada de cache lookaside distribuída foi integrada dentro do Habitat. Ela guarda uma cópia dos objetos e arestas acessados recentemente em servidores Valkey posicionados perto de onde as requisições do usuário são processadas. Lookaside significa que a aplicação pergunta primeiro ao cache; se não tem, vai no banco e popula o cache depois. É o padrão clássico.

O problema clássico também: como saber quando o dado em cache ficou obsoleto. TTLs curtos aumentam misses, TTLs longos arriscam dados velhos. A OpenAI resolveu isso com invalidação orientada por evento, não por tempo.

Eles adotaram uma abordagem mais avançada de invalidação, seguindo os passos de sistemas como o TAO da Meta. O cache integrado do Habitat usa change data capture (CDC) através do change feed do Azure Cosmos DB para propagar invalidações globalmente em segundos, atingindo altas taxas de hit e mantendo staleness baixo. Um serviço na infraestrutura consome esse change feed e executa invalidações nos caches locais quando o dado subjacente é atualizado.

O fluxo passo a passo:

  • Aplicação escreve objeto X no Cosmos DB via Habitat.
  • Cosmos DB registra a mudança no seu change feed (um log append-only de alterações).
  • Um serviço consumidor lê o change feed continuamente.
  • Esse serviço publica uma invalidação para os caches Valkey em cada região.
  • Próxima leitura em qualquer região acha miss, busca a versão nova e repopula o cache local.

O ganho é que TTL deixa de ser a estratégia principal de freshness. Você pode manter dados em cache por horas e ainda estar correto, porque a invalidação chega por push quando o banco muda.

O que isso significa na prática

Dois recados ficam para quem constrói sistema parecido, em qualquer escala.

Primeiro, a decisão entre isolar e compartilhar não é técnica, é organizacional. Isolar move o problema para quem toca o produto, e nem todo time de produto quer, ou sabe, planejar capacidade. Compartilhar devolve essa dor para a plataforma, que é onde ela costuma ficar melhor cuidada. A escolha depende de quem é melhor equipado para absorver a dor.

Segundo, invalidação por CDC muda o jogo quando você tem leitura dominante e dados que mudam de forma esparsa mas crítica. Habitat fornece uma interface comum de armazenamento online para ChatGPT, API, Codex e aplicações internas, centralizando autorização, roteamento de dados, criptografia, serialização, caching e gerenciamento de conexão. Uma única interação de usuário pode gerar múltiplas operações de armazenamento Habitat, então a taxa de requisições não deve ser interpretada como o número de prompts do ChatGPT por segundo. Em outras palavras, grande parte dessas requisições é leitura de perfil, configuração, histórico, coisas que mudam pouco por requisição mas precisam estar frescas quando mudam.

Trabalhando com agente de código todo dia, com arquivo de contexto em cada repositório, vejo um padrão análogo em escala muito menor: o arquivo existe para o agente herdar as decisões do projeto em vez de redescobrir mal a cada sessão. É cache também. E se eu atualizo uma decisão arquitetural, preciso invalidar o entendimento antigo do agente, não só esperar o TTL da sessão expirar. A mecânica é a mesma: push de invalidação ganha de pull por tempo quando correção importa.

Onde a arquitetura quebra

Nem tudo é ganho. Três limites reais:

Grafo é caro. Como já citado, hops entre objetos podem envolver contas Cosmos DB em regiões diferentes. Se seu caso de uso precisa de traversal profundo, Habitat não é a ferramenta certa, e por isso a OpenAI tem sistemas especializados ao lado: Valkey fornece caches regionais; CDC distribui mudanças; Kafka carrega eventos para consumidores downstream; Rockset pode fornecer views de query separadas para workloads complexos.

CDC tem latência. “Segundos” é bom, mas não é zero. Para a maior parte dos usos é irrelevante. Para operações sensíveis a consistência forte (saldo financeiro, autorização de ação crítica logo após mudança de permissão), você precisa de leitura direta no banco, não no cache, ou de um sinal explícito de invalidação síncrona.

Multi-tenancy compartilhada exige fairness confiável. Containers compartilhados juntam capacidade e reduzem o fardo de previsão dos times de produto, mas exigem controles de fairness fortes. Containers dedicados reduzem o raio de falha mas podem desperdiçar o headroom provisionado. Se seu banco não oferece controles de fairness bons dentro de container compartilhado, a volta para shared vira risco.

Nos sistemas que opero, no Mentezinha, com retrieval por criança em produção no Vertex AI, encaro a outra ponta do dilema: personalização por usuário via retrieval, não RAG genérico de documento. Sem isso, personalização é só tom de voz. Um índice por usuário multiplica custo de armazenamento e de manutenção, e cria a pergunta de quando esquecer. É o oposto do movimento da OpenAI aqui: eles compartilham para absorver pico; eu isolo para ter personalização real. A direção certa depende do que você está otimizando.

O que não dá para afirmar a partir deste material

Alguns pontos importantes ficam em aberto no que foi publicado:

  • O mecanismo exato de fairness interno aos co-managed containers não é detalhado. O post descreve o resultado (isolamento preservado com container compartilhado) mas não como o Cosmos DB impõe isso tecnicamente.
  • A OpenAI atribui o progresso a replicação geográfica seletiva, cache Valkey e migração da camada de serviço de Python para Rust, sem isolar a contribuição individual de cada mudança. Ou seja, o 12x é agregado, não é só o Cosmos DB nem só o cache.
  • O material fornecido não inclui medições ao vivo verificadas independentemente para a nova figura de read performance. Os números vêm da própria OpenAI.
  • O número de 12x se refere à latência p50 de leitura de armazenamento, não ao tempo de resposta end-to-end do ChatGPT. Importante não confundir: a janela de resposta que o usuário sente envolve inferência do modelo, que é a parte dominante.

Como testar isso você mesmo

Você não vai reproduzir Habitat em casa, e nem precisa. Mas dá para construir uma versão didática do padrão de cache lookaside com invalidação por CDC usando ferramentas gratuitas:

  • Suba um Postgres local com wal_level=logical ativado.
  • Suba um Redis ou Valkey local como cache.
  • Escreva uma aplicação simples que lê do cache primeiro e, em miss, lê do Postgres e popula.
  • Rode um consumidor de replicação lógica (por exemplo, usando wal2json ou Debezium) que escuta mudanças em uma tabela e, para cada UPDATE/DELETE, deleta a chave correspondente no cache.
  • Faça uma escrita direto no Postgres por fora da aplicação, e meça quanto tempo leva até a próxima leitura no cache refletir o novo valor.

Esse laboratório vale mais que ler sobre TAO ou Habitat. Você vai sentir onde o CDC atrasa, o que acontece quando o consumidor cai, e por que invalidar em vez de atualizar a chave é mais seguro quando a aplicação escreve em vários lugares. A arquitetura da OpenAI é a mesma ideia, só com muitos zeros a mais na vazão e um fornecedor cuidando do change feed por você.

Para quem quer ler o original, a Part II está publicada no blog da OpenAI em outubro de 2026, assinada por Jon Lee, Hrachya Hakobyan e Chaomin Yu.

Deixe um Comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *