On this page
Uma avaliação profissional de integração Boomi revela problemas que uma equipe interna competente não enxerga de dentro das próprias ferramentas: conexões apontadas para um único nó em vez de um endpoint com balanceamento de carga, configurações de protocolo silenciosamente alteradas em relação ao padrão, filas travadas que se passam por quedas do broker e nenhuma observabilidade compartilhada entre as camadas da integração. Nada disso aparece como um erro óbvio. Aparece como um travamento intermitente que ninguém consegue reproduzir quando quer.
O Boomi é uma plataforma de integração como serviço (iPaaS) corporativa: o runtime AtomSphere do Dell Boomi cuida dos conectores, do gerenciamento de APIs e do mapeamento de dados por trás dos fluxos de integração de uma organização, rodando em instâncias Atom ou molecule gerenciadas por essa plataforma AtomSphere. Nos processos de integração em tempo real (em oposição aos de batch), esse runtime normalmente fica sobre uma camada de mensageria — neste projeto, o RabbitMQ —, e é ali que vários dos achados abaixo realmente estão.
Os achados a seguir vêm de uma avaliação Boomi real da AceMQ, feita em várias sessões para uma integradora de sistemas federais que estava migrando o seu esforço de transformação digital de jobs agendados legados para processos de integração em tempo real. Os detalhes são descritos de forma genérica; o cliente e as pessoas envolvidas não são identificados.
Por que levar o Boomi do batch para o tempo real coloca o RabbitMQ no caminho crítico?
O projeto começou com uma migração em andamento: o cliente estava saindo de um ambiente legado de batch agendado em .NET e avançando para processos de integração Boomi em tempo real, com o RabbitMQ como a peça que tornava o tempo real possível. Essa mudança altera o que significa “funcionar”. Um job batch que disparava às 3h e terminava em algum momento antes das 8h podia levar quinze minutos ou duas horas, e ninguém se importava. Um gateway em tempo real, que um listener do Boomi consome de uma fila, precisa absorver uma rajada de 1.000 registros sem timeout: não existe janela noturna para absorver o backlog.
A arquitetura refletia essa ambição: um molecule de três nós em teste e produção, um Atom de um nó só em desenvolvimento e cerca de 35 listeners RabbitMQ espalhados pelo ambiente, fazendo publish/subscribe, disparo assíncrono de documentos e processamento batch de longa duração lado a lado. É muita área de superfície para um problema no nível da conexão ou do protocolo se esconder, e é exatamente essa área que uma avaliação de integração Boomi foi feita para percorrer.
Por que os listeners do Boomi ficam verdes enquanto nada é processado?
Esse foi o sintoma recorrente que deu início ao projeto: todos os listeners do Boomi apareciam saudáveis na própria tela de status, enquanto as filas do RabbitMQ por trás deles ficavam paradas. Nada falhava de forma ruidosa. Nada gerava alerta. Simplesmente parava.
A causa raiz é a diferença entre o que o “status do listener” realmente mede e o que a equipe supõe que ele mede. O status do listener no Boomi reflete o estado da implantação — se o componente do listener iniciou e continua rodando —, e não a conectividade ativa com o broker. Se um nó do RabbitMQ com o qual o listener conversava caiu, foi reiniciado ou recebeu patches e foi reiniciado, e o channel por baixo do listener morreu por causa disso, o listener pode continuar verde indefinidamente. O RabbitMQ é tolerante a falhas e, em muitas topologias, acaba recuperando a conexão, mas “acaba” não é um SLA de tempo real, e um painel de listeners que nunca fica vermelho não dá à equipe nenhum motivo para olhar.
Por que a conexão do Boomi com o RabbitMQ precisa de um VIP no F5 em vez do IP direto de um nó?
A correção para o travamento dos listeners remontava à forma como a conexão do Boomi com o RabbitMQ estava configurada. A avaliação seguiu a sequência padrão de diagnóstico — a conexão passa por um load balancer, existe um VIP na frente de um pool, esse pool realmente distribui entre todos os nós do cluster em vez de ficar preso a um — e descobriu que a conexão do cliente com o RabbitMQ passava por um F5, mas não estava configurada como deveria: não era um pool com balanceamento de carga de verdade, não havia proteção contra roteamento sticky para um único nó e os health checks baseados em CPU eram o sinal errado para medir a disponibilidade do broker.
A configuração corrigida aponta essa conexão para o registro DNS do VIP no F5 que fica à frente de todos os nós do cluster, configurado como um pool com balanceamento de carga de verdade e sem sticky bit. Essa única mudança faz três coisas de uma vez: o RabbitMQ consegue rotear e distribuir a carga entre os nós que estiverem de fato saudáveis, um nó que cai para receber patches deixa de ser uma queda da integração e abre-se caminho para operações como um upgrade blue/green do RabbitMQ, trocando os pools de conexão por trás do F5 sem tocar em nenhum componente do Boomi.
Quanto custa de fato um frame_max reduzido para uma integração Boomi?
Escondido na environment extension do Boomi para a conexão com o RabbitMQ havia um override explícito: frame_max definido em 16 KB. Ninguém do lado do cliente sabia dizer por quê; a resposta era alguma variação de “sempre foi assim, desde o primeiro dia”. O RabbitMQ negocia por padrão um tamanho máximo de frame AMQP 0-9-1 de 131.072 bytes (128 KiB). Reduzi-lo para 16 KB não deixa nada mais seguro; só multiplica a quantidade de frames em que o RabbitMQ precisa dividir cada mensagem. Um payload de 16 MB que levaria algo em torno de 96 frames no tamanho padrão passou a levar cerca de 8.000 frames com a configuração de 16 KB: overhead de protocolo puro em cada mensagem grande que a integração enviava, sem nenhum benefício correspondente.
A correção foi remover o override por completo e deixar o componente de conexão negociar o padrão da plataforma, em vez de fixar um número no código, para que futuras mudanças na configuração do RabbitMQ se propaguem automaticamente, em vez de brigar em silêncio com um valor desatualizado que ninguém lembra de ter definido.
Esse é o tipo de achado que nunca aparece como incidente. Ele simplesmente cobra um imposto silencioso de cada mensagem grande que a integração envia, indefinidamente, até que alguém com motivo para questionar um padrão de cinco anos vá investigar.
Como uma fila de logger do EBS travada derruba uma execução Boomi em produção?
O achado mais grave foi um travamento em produção rastreado até uma única fila interna de logs: um exchange de logger do EBS que os processos do Boomi usavam para gravar registros de log estruturados em JSON em uma tabela de logs compartilhada. Durante o incidente, essa fila mostrava duas mensagens travadas e 42 sendo rejeitadas, com a contagem de mensagens sem acknowledgement no broker passando bem de 100 e continuando a crescer, em vez de se estabilizar.
O diagnóstico importou mais do que a correção. Uma contagem crescente de mensagens sem acknowledgement, com mensagens ainda “ready” em outros pontos da topologia, não é um problema do broker: o RabbitMQ estava fazendo exatamente o que deveria, guardando mensagens que tinham sido entregues a um consumidor, mas nunca confirmadas, para o caso de ele precisar reentregá-las. A falha real estava antes: um consumidor tinha aceitado um trabalho e simplesmente nunca o terminou, muito provavelmente por uma instabilidade de rede, uma chamada SQL bloqueada ou um timeout downstream que deixou um documento em trânsito sem que nada jamais voltasse para confirmá-lo. Quando consumidores suficientes ficaram nesse estado, os slots de execução saturaram, as mensagens em prefetch ficaram sem acknowledgement e todo o caminho de logs ficou represado atrás deles.
A recuperação foi fechar à força, de forma seletiva, as conexões do RabbitMQ travadas por trás dos consumidores congelados, o que leva o Boomi a se reconectar e a restabelecer channels limpos, em vez de esperar indefinidamente por conexões que nunca iam voltar. A contagem de mensagens sem acknowledgement caiu de forma constante em seguida, da casa dos 120 para a dos 100 e, por fim, para um dígito, à medida que o backlog se esvaziava. Nada disso exigiu mexer na durabilidade das mensagens nem fazer purge de uma fila; exigiu identificar corretamente que o broker estava saudável e a camada de aplicação, não.
Por que o prefetch e o single active consumer importam para os consumidores concorrentes do Boomi?
O molecule do Boomi roda uma cópia própria de cada listener em cada nó, cada uma com a sua configuração de concorrência. Neste ambiente, uma concorrência de 2 por cópia de listener em um molecule de três nós resultava em cerca de 10 consumidores concorrentes puxando da mesma fila do RabbitMQ. Para cargas em que a ordem das mensagens não importa, esse é um padrão de throughput razoável. Para cargas que exigem processamento sequencial, 10 consumidores concorrentes são um risco de correção esperando o padrão de tráfego errado para aparecer.
A própria orientação do RabbitMQ coloca o prefetch ideal na faixa de 100 a 300 para filas sensíveis a throughput e aponta especificamente que um prefetch de 1 prejudica muito o desempenho, porque serializa tudo e gasta a maior parte do tempo em idas e voltas. Em vez de trocar throughput por ordenação reduzindo o prefetch para 1, a recomendação foi implementar o single active consumer (x-single-active-consumer) nas filas que realmente precisavam de tratamento sequencial. Ele mantém exatamente um consumidor ativo por fila de cada vez e faz failover automático se esse consumidor cair: garantia de ordem sem a penalidade das idas e voltas. O cliente concordou em fazer um piloto em um ambiente inferior antes de levá-lo para produção.
Que lacuna de observabilidade fica sem dashboards compartilhados de Prometheus e Grafana?
No início do projeto, o cliente quase não tinha observabilidade compartilhada entre o Boomi e o RabbitMQ. Em desenvolvimento havia um agente Java do Prometheus coletando algumas métricas do Boomi, mas esses dados eram ingeridos e descartados imediatamente: nada era persistido em lugar nenhum, então não havia histórico para consultar quando algo se comportava mal. Não havia rotulagem específica para o Boomi no Grafana, nem um OpenTelemetry collector extraindo dados diretamente do runtime do Boomi. Produção e teste, os ambientes que realmente importavam, não tinham nada.
Ao longo das sessões seguintes, os engenheiros da AceMQ montaram um JMX exporter do lado do Boomi/molecule e o integraram aos dashboards de Prometheus e Grafana que já estavam sendo criados para o RabbitMQ, colocando os dois em uma pasta de dashboards compartilhada para que as métricas do Boomi e do RabbitMQ pudessem ser lidas lado a lado, e não em duas ferramentas separadas. Isso incluiu a exportação de métricas por pod, para identificar como outlier um nó do molecule sobrecarregado ou travado, além de detectores baseados em limites para exatamente os modos de falha que esta avaliação já tinha encontrado manualmente: threads bloqueadas, estados de deadlock e pods travados que nunca voltavam.
Isso fecha a lacuna real por trás de todos os outros achados deste texto. Um listener travado, uma fila de logger travada e um frame_max reduzido parecem idênticos vistos de fora quando o Boomi e o RabbitMQ são monitorados como dois sistemas sem relação: algo está lento, ou algo parou, e ninguém consegue dizer de que lado começou. É a observabilidade lado a lado que transforma isso em um diagnóstico de cinco minutos, em vez de uma sala de crise de várias horas.
Esse é o padrão por trás da maioria das avaliações de integração Boomi: a plataforma funciona bem no papel, e o risco real está na camada de conexão, nas configurações de protocolo e na lacuna de monitoramento entre dois sistemas que ninguém observa em conjunto. Acertar nisso se paga em eficiência operacional, e não só em uptime: menos pipelines de dados travados, fluxos que não precisam de babá e análises em que você pode confiar de verdade para otimizar a próxima rodada de ajustes. É também por isso que este conteúdo não existe em nenhum outro lugar: ele vem dos próprios projetos de integração com RabbitMQ da AceMQ, e não da documentação de fornecedores. Se a sua camada de integração e o backbone de mensageria por trás dela nunca foram avaliados em conjunto, fale com a AceMQ sobre uma avaliação de integração Boomi.
Perguntas frequentes
O que uma avaliação de integração Boomi realmente verifica?
Ela verifica aquilo que uma equipe de integração em plena operação não percebe de dentro: se as conexões do Boomi com os sistemas downstream (incluindo a camada de mensageria) passam por balanceamento de carga ou apontam para um único nó, se as configurações no nível do protocolo correspondem aos padrões da plataforma, se mensagens travadas ou sem acknowledgement estão se acumulando atrás de um listener, se o prefetch e a concorrência dos consumidores estão ajustados para a carga de trabalho e se o Boomi e a sua camada de integração são monitorados em conjunto ou como dois sistemas desconectados.
Por que os listeners do Boomi aparecem saudáveis enquanto nada está sendo processado?
O status do listener no Boomi reflete o estado da implantação, e não a conectividade ativa com o broker. Se um channel cai do lado do RabbitMQ depois que o listener foi implantado com sucesso, o listener pode continuar verde enquanto a conexão por baixo dele já não existe e as mensagens param de andar.
Qual é o frame_max padrão do RabbitMQ e por que um valor baixo prejudica as integrações Boomi?
O RabbitMQ negocia por padrão um frame_max de 131.072 bytes (128 KiB). Forçar um valor menor não acrescenta margem de segurança; só multiplica a quantidade de frames necessários para entregar cada mensagem. Um payload de 16 MB que leva cerca de 96 frames no valor padrão passa a levar algo em torno de 8.000 frames com um override de 16 KB, acrescentando overhead puro a cada mensagem grande que o Boomi envia pela conexão.
Como recuperar uma fila do RabbitMQ travada atrás do Boomi?
Primeiro, confirme que é um travamento do lado do consumidor, e não um problema do broker: uma contagem crescente de mensagens sem acknowledgement, sem nada sendo rejeitado de fato, geralmente significa que um consumidor pegou um trabalho e nunca o terminou, muitas vezes por um timeout downstream ou uma chamada travada. Forçar a reconexão fechando as conexões travadas libera as mensagens fantasmas em trânsito e deixa o backlog ser drenado, sem mexer na durabilidade das mensagens.
O Boomi deve se conectar ao RabbitMQ por um load balancer ou pelo IP direto de um nó?
Por um VIP com balanceamento de carga. Apontar o Boomi para o IP direto de um nó do RabbitMQ significa que a falha desse nó derruba a integração junto. Colocar à frente do cluster um VIP no F5 (ou equivalente) permite que o RabbitMQ roteie e distribua a carga entre os nós que estiverem de fato de pé e torna possíveis operações como um upgrade blue/green do RabbitMQ sem reconfigurar o Boomi.
Qual é a diferença entre ajustar o prefetch e usar single active consumer nos listeners do Boomi?
O prefetch controla quantas entregas sem acknowledgement um consumidor pode manter ao mesmo tempo; a própria orientação do RabbitMQ coloca o throughput ideal na faixa de 100 a 300, e um prefetch de 1 serializa tudo e prejudica o throughput. O single active consumer (x-single-active-consumer) resolve outro problema, o processamento ordenado, mantendo exatamente um consumidor ativo por fila e fazendo failover automático, sem cair no ritmo arrastado de um prefetch de 1.
O Boomi é uma ferramenta de ETL?
Não principalmente. O Boomi é uma plataforma de integração como serviço (iPaaS) que inclui recursos de mapeamento e transformação de dados, mas o seu papel central é conectar aplicações, APIs e fontes de dados por meio do runtime Atom/molecule, o que o aproxima mais de uma plataforma de integração e gestão de dados do que de uma ferramenta de ETL dedicada.
Talk to an engineer
Need a hand with Boomi?
Senior engineers who run it in production. Get a quote or a free consultation, no sales pitch.
Guias, comparativos e pesquisas


