Uma atualização de uma biblioteca quebrou os deployments do Salesforce — e 179 instâncias voltaram à versão anterior
A 11 de novembro, a atualização de uma biblioteca runtime de suporte dentro de uma versão recente do Salesforce fez com que o código Apex não compilasse nem fosse implantado em 179 instâncias. O Salesforce travou a distribuição e passou duas horas a repor a versão anterior, instância a instância.

Foto: ThisIsEngineering / Pexels (licença Pexels).
O movimento mais honesto do software empresarial é o rollback: a admissão pública de que a versão nova é pior do que a anterior, e de que a maneira mais rápida de avançar é recuar. Na tarde de 11 de novembro, o Salesforce executou esse movimento à escala da frota. Uma versão que tinha acabado de chegar a um conjunto de instâncias quebrou o ato mais básico para que essas instâncias existem — compilar e implantar código Apex — e, ao longo das duas horas seguintes, o Salesforce travou a distribuição, reverteu 179 instâncias para a versão anterior e documentou toda a retirada na sua página de estado, atualização a atualização, até a última instância estar de volta.
O cenário importa. O Salesforce não é uma aplicação que uma empresa instala; é uma plataforma sobre a qual outras empresas constroem, em Apex, a linguagem de programação própria da plataforma. Os programadores dos seus clientes implantam código em instâncias do Salesforce como o fariam nos seus próprios servidores — exceto que os servidores, o runtime e o calendário de versões pertencem ao fornecedor. Quando uma versão do fornecedor quebra os deployments, os clientes não podem corrigi-la, fixar uma versão nem recusar a atualização. Só podem olhar para a página de estado. A 11 de novembro, a página de estado merecia ser olhada.
O que se quebrou, exatamente
O registo do incidente abre às 18:23 UTC com uma «disrupção funcional» em instâncias que tinham recebido recentemente uma versão nova. O sintoma, no relato do Salesforce, foi preciso: compilar ou implantar código Apex falhava de forma intermitente. Intermitente é a palavra operativa — a falha que passa uma vez e falha na seguinte, que sobrevive a uma nova tentativa e depois não, que convence três equipas distintas de que a culpa é do seu próprio código antes de alguém suspeitar da plataforma. E o raio de impacto chegou para lá dos programadores: em alguns casos, assinala o Salesforce, também falharam inícios de sessão e outros processos que dependem do mesmo código subjacente. O âmbito final da disrupção foi de 179 instâncias — o registo nomeia ARE2S, BRA2S, BRA6S e mais 176 —, cada uma delas lar das organizações de muitos clientes.
A causa, identificada à medida que a tarde avançava, foi quase dececionantemente pequena: não as funções de capa da versão, mas uma atualização de uma biblioteca runtime de suporte dentro dela — essa classe de componente que viaja como uma linha num registo de alterações que ninguém lê. As plataformas grandes raramente caem por componentes grandes. Caem pelos partilhados e invisíveis, a biblioteca sobre a qual cada função se apoia em silêncio.
Porque um Apex quebrado não é uma função quebrada
Vale a pena parar no que o Apex é, porque isso decide quem sente um incidente como este. O Apex não é uma API de complementos aparafusada ao lado do Salesforce; é a linguagem em que os clientes escrevem a lógica dos seus próprios negócios: a validação que protege os seus dados, a automação que encaminha os seus casos, as integrações que mantêm o Salesforce ao passo de tudo o resto que executam. Quando compilar e implantar esse código falha, o que congela não é uma função do Salesforce. É a conduta de alterações dos próprios clientes: as suas correções, as suas versões, os seus deployments de sexta-feira, tudo em fila atrás de um compilador que não controlam, a falhar de forma tão intermitente que cada equipa suspeita primeiro do seu próprio código. Uma falha intermitente de plataforma é um imposto sobre cada organização de engenharia que toca, pago em horas de depuração gastas a provar que a culpa não é sua. A nota do registo de que, em alguns casos, também falharam inícios de sessão e processos dependentes alarga ainda mais o ponto: o mesmo runtime que executa o código dos clientes também carrega partes do comportamento da própria plataforma, pelo que uma biblioteca dentro dele falha nas duas direções ao mesmo tempo — o produto do fornecedor e os produtos dos clientes, a partilhar uma só garganta.
A decisão: travar a distribuição, reverter a frota
Pela atualização das 18:55 UTC, o Salesforce tinha um detonante provável e tomou as duas decisões que definem um incidente bem gerido. Primeiro, travou a distribuição da versão: nenhuma instância nova receberia o código quebrado enquanto o diagnóstico continuasse. Segundo, escolheu reverter em vez de reparar: em vez de corrigir para a frente em 179 instâncias em produção, devolveria a frota afetada à versão anterior, priorizando as instâncias com impacto confirmado. Em paralelo, os engenheiros começaram a preparar a resposta de fundo: uma versão corretiva que retira por completo a mudança da biblioteca, para ser distribuída só quando estiver pronta. Correção para a frente para o futuro; reversão para o presente. A ordem dessas duas operações é todo o ofício.
A reversão avançou depois como avançam na realidade as operações de frota: de forma desigual. As atualizações do Salesforce durante a tarde reportam instâncias a recuperar por vagas, priorizadas por impacto confirmado, e — o detalhe que separa um registo a sério de um comunicado de imprensa — algumas instâncias que precisaram de uma segunda tentativa. Às 19:45 UTC, a recuperação já estava confirmada em pelo menos uma instância priorizada e o Salesforce avisava que alguns fluxos de início de sessão podiam continuar a falhar enquanto o trabalho prosseguia. Às 20:13, a reversão estava quase completa. Às 20:39 UTC, duas horas e dezasseis minutos depois da primeira entrada, o incidente encerrou: todas as instâncias afetadas de volta à versão anterior, o Apex a compilar e a implantar outra vez, e no registo a promessa de uma investigação completa e de ações preventivas.
O que custa uma reversão
Uma reversão a esta escala não é um toque de tecla. Uma instância é um lar partilhado: as organizações de muitos clientes vivem em cada uma, e a versão tem de se mover para todas ao mesmo tempo, numa ordem escolhida por impacto confirmado — o que significa, por construção, que a tarde de alguns clientes foi reparada antes da de outros. Tudo o que a versão nova tocou enquanto esteve viva tem de continuar válido sob a anterior; uma reversão é um problema de dados com roupa de deployment. E a história não termina às 20:39. A versão corretiva — a mesma versão, menos a mudança da biblioteca — ainda tem de ser distribuída pela frota uma segunda vez, pelo que cada cliente afetado viverá esta versão duas vezes: uma como incidente, outra como repetição. Esse é o preço honesto do desfazer, e continua a ser mais barato do que a alternativa que estava sobre a mesa nessa tarde, que era depurar uma biblioteca runtime para a frente, em produção, em 179 instâncias ao mesmo tempo.
No mesmo dia, no resto da federação
A disrupção do Apex não foi o único incidente do Salesforce nesse dia: foi o maior de cinco. A página de estado da empresa para 11 de novembro também regista um incidente do MuleSoft Runtime Fabric às 02:40 UTC, em que as aplicações não puderam enviar temporariamente registos nem métricas para o Anypoint Monitoring enquanto uma mudança estava ela própria a ser revertida, e um incidente do Heroku Private Spaces em Tóquio às 18:16 UTC — sete minutos antes de a entrada do Apex abrir — em que um fornecedor cloud externo impediu o arranque de dynos novos enquanto os que já corriam seguiam intactos. Entre os cinco incidentes, os rastreadores independentes que resumem a página contam 105 componentes em âmbito. Esse é o facto estrutural sobre o Salesforce em 2026: não é um produto, mas uma federação — CRM, integração, uma plataforma de desenvolvimento, impérios adquiridos, cada um com a sua própria infraestrutura — e a sua página de estado é o mapa das fronteiras da federação, desenhado em incidentes.
Há um instrumento defensivo que o modelo deixa nas mãos dos clientes, e o dia 11 de novembro mostra-o a funcionar em negativo. Um cliente não pode recusar uma versão do Salesforce, mas pode recusar-se a implantar as suas próprias alterações nas horas em que a frota do fornecedor está em plena distribuição. As equipas que encontraram o compilador quebrado nessa tarde foram aquelas cujos próprios deployments caíram dentro da janela; as organizações cujos congelamentos de alterações coincidiram com a distribuição viveram o mesmo incidente como espectadoras. Sincronizar as suas alterações contra o calendário do fornecedor é um mau substituto de controlar o calendário — mas, à vista deste registo, é a diferença entre um incidente de que se lê e um incidente que se depura.
Para os clientes, a lição prática é sobre um calendário que não controlam. No modelo SaaS, o calendário de versões do fornecedor é a sua janela de mudança: o código novo chega nos tempos do fornecedor, pela ordem do fornecedor, e a única alavanca que o cliente segura é a qualidade do «desfazer» do fornecedor. O dia 11 de novembro é o aspeto que um bom desfazer tem: uma distribuição travada, uma reversão priorizada, segundas tentativas admitidas em público e uma versão corretiva retida até retirar a mudança ofensiva em vez de camadas de correção por cima. A investigação que o Salesforce prometeu dirá como uma atualização de uma biblioteca runtime chegou a produção com este efeito, e o que agora se interpõe no seu caminho. Até lá, o registo da tarde fica como documentação: 179 instâncias avançaram para uma versão quebrada, e 179 instâncias voltaram.
𝐋𝐄𝐈𝐀 𝐀 𝐑𝐄𝐕𝐈𝐒𝐓𝐀 𝐂𝐎𝐌𝐏𝐋𝐄𝐓𝐀 𝐆𝐑𝐀𝐓𝐔𝐈𝐓𝐀 𝐄𝐌 thebuyerspulse.com/pt/
Fontes
- Salesforce Status (11 de nov. de 2026), o registo do incidente «Service Disruption – Core Service – (179 Instances)» (status.salesforce.com): o início às 18:23 UTC, as falhas intermitentes ao compilar e implantar Apex em instâncias que tinham acabado de receber uma versão, a biblioteca runtime de suporte identificada como detonante provável, a distribuição travada, a reversão priorizada com segundas tentativas onde foram precisas e a resolução às 20:39 UTC, com uma investigação completa prometida.
- UptimeRobot (11 de nov. de 2026), resumo diário construído a partir da própria página de estado do Salesforce: a reversão decorreu ao longo de cinco atualizações, e o Salesforce registou cinco incidentes separados nesse dia — entre eles o MuleSoft Runtime Fabric às 02:40 UTC e o Heroku Private Spaces em Tóquio às 18:16 UTC —, com 105 componentes em âmbito entre os cinco.
- Foto: ThisIsEngineering / Pexels — uma engenheira de software a programar diante de dois monitores num escritório moderno (licença Pexels).