Líderes de arquitetura precisam de integrações que acompanhem o ritmo do negócio sem comprometer governança, observabilidade e segurança. Este artigo apresenta um experimento prático que combina Apache Camel JBang, o editor visual Kaoto e um cluster Kubernetes para entregar um fluxo completo: modelagem visual, geração de YAML, build da imagem, publicação em registry, deploy automatizado e validação do serviço de destino. A proposta é ir além da teoria e explorar o funcionamento do Apache Camel a partir da execução de uma integração que simula um caso comum do mundo real.
O Apache Camel permanece como uma das principais referências para implementação de Enterprise Integration Patterns (EIPs), abstraindo protocolos de transporte e permitindo foco nas regras de negócio. Com o JBang e o plugin Kubernetes, o Camel passa a oferecer uma experiência de linha de comando praticamente plug-and-play para desenvolver e implantar integrações diretamente em um cluster. O Kaoto complementa essa abordagem como uma camada low-code/no-code integrada ao VS Code, acelerando a modelagem sem abrir mão da aderência aos artefatos nativos do Camel.
Para o exercício, foi definido um cenário hipotético: empresas que operam em múltiplas moedas precisam atualizar diariamente seus sistemas com novas taxas de câmbio, atrasos ou inconsistências impactam diretamente o faturamento. A solução automatiza a leitura das cotações USD/EUR/BRL em uma API pública e publica os dados em um serviço de faturamento via HTTPS.
O que vamos usar?
| Componente | Função |
|---|---|
| Camel JBang | Apache Camel “plug-and-play” para desenvolvimento rápido |
| Docker Desktop com Kubernetes habilitado | Cluster local para build e deploy |
| Kaoto | Modelagem visual das rotas Camel dentro do VSCode |
Caso de uso
Consulta diária de USD/EUR/BRL e envio para o sistema de faturamento.
Origem da informação
API pública: https://economia.awesomeapi.com.br/last/USD-BRL,EUR-BRL,BTC-BRL
Este endpoint contém uma API de Cotações em tempo real com mais de 150 moedas.
Mais informações aqui: https://docs.awesomeapi.com.br/api-de-moedas
Destino da informação
API pública: https://echo.free.beeceptor.com
Usaremos o Beeceptor (HTTP echo server) para representar o endpoint do sistema financeiro que recebe as informações. O Beeceptor é uma API pública de eco que devolve exatamente o conteúdo da requisição HTTP, facilitando depuração, validação de payloads e demonstrações ao vivo.
Mais informações aqui: https://beeceptor.com/resources/http-echo/
Arquitetura da integração
flowchart LR
A["API Cotações"]
B["Apache Camel<br/>(pod)"]
C["API Sistema Financeiro<br/>(echo)"]
B -- "Polling diário<br/>request GET /last" --> A
A -- "response" --> B
B -- "Transformação do payload<br/>Filtra informações relevantes<br/>Mapeia JSON" --> C
C -- "Status HTTP 201<br/>Validação de resposta" --> BDo ponto de vista de arquitetura, esta rota exemplifica um pipeline enxuto: coleta de dados externos, normalização e entrega confiável a um outro sistema, tudo com observabilidade nativa de logs e fácil portabilidade para outros ambientes Kubernetes.
O fluxo de desenvolvimento será:
flowchart LR
A["Camel JBang"]
B["Jib<br/>(build da imagem)"]
C["Container Registry"]
D["Kubernetes<br/>(pull da imagem)"]
A --> B
B --> C
C --> DInstalando o Camel JBang e o Camel Kubernetes plugin
Vamos utilizar o Camel JBang com o plugin Camel Kubernetes plugin.
O Camel JBang é uma forma simples, leve e moderna de desenvolver, executar e testar integrações Apache Camel diretamente pela linha de comando, sem precisar criar um projeto Maven/Gradle completo.
Estou usando macOS e farei a instalação com o brew. Outros métodos de instalação considerando outras plataformas podem ser encontrados na documentação oficial em https://www.jbang.dev/documentation/jbang/latest/installation.html.
$ brew install jbang
Verifique se o JBang está funcionando.
$ jbang version
Instale o Camel CLI.
$ jbang app install camel@apache/camel
Instale o Camel Kubernetes plugin.
$ camel plugin add kubernetes
Verifique se o plugin do Kubernetes está listado como um plugin instalado.
$ camel plugin get
Você deverá receber um resultado semelhante a:
DESCRIPTION
Run Camel applications on Kubernetes
Habilitando o Cluster Kubernetes no Docker Desktop
Vou usar o Kubernetes embutido do Docker Desktop, que já entrega um cluster certificado, simples de habilitar na máquina local. Basta ativá-lo como mostra a figura.
O Camel JBang com o plugin Kubernetes precisa de um container registry para publicar a imagem e criar recursos no Kubernetes (Pod/Deployment) apontando para essa imagem.
Preparando o Container Registry
Vou usar o próprio Docker para subir um Docker Registry localmente sem autenticação para simplificar o processo. Em um terminal utilize o seguinte comando:
$ docker run --rm -p 5001:5000 -v ./data:/var/lib/registry --name local-registry registry
Instalando e configurando o Kaoto
O Kaoto é uma extensão do VS Code que utiliza o Camel CLI via JBang para rodar e empacotar integrações localmente.
Instalar o Kaoto no VSCode é bem simples: pesquise pelo nome e instale.
Depois de instalado é necessário fazer algumas configurações para realizar o deploy no cluster Kubernetes.
Precisamos ajustar/adicionar os argumentos:
- –cluster-type=kubernetes (Tipo de cluster alvo. Configurações especiais podem ser aplicadas para Kind ou Minikube)
- –image-registry=localhost:5001 (Registro de imagens onde a imagem da aplicação será armazenada)
Criando a Primeira Integração com Camel
Vamos validar o setup com uma integração simples que faz HTTP GET em https://official-joke-api.appspot.com/random_joke e registra a resposta no log a cada 10s, garantindo que está tudo funcionando corretamente. A Joke API retorna a cada requisição uma piada aleatória, vamos ver essa resposta no log da integração.
Acesse pelo ícone na barra lateral e clique no botão “Camel File”.
Escolha a opção “Camel Route”.
Escolha a opção “YAML” para o formato do DSL, que se refere à linguagem estruturada que define como as rotas de integração, componentes e padrões são configurados e conectados.
Você precisará selecionar um diretório onde os arquivos de integrações/rotas serão salvos.
E deverá escolher um nome para a sua integração, nesse exemplo irei utilizar o nome get-joke-route.
Uma integração básica é criada e exibida no editor do Kaoto.
Essa integração é muito parecida com o que pretendemos fazer para validar nosso setup.
Vamos precisar adicionar o bloco Https, remover o bloco Set Body e ajustar alguns parâmetros de cada bloco.
- Clique em cima da caixa da rota (no meu caso, o título da rota está “route-4176”); abrirá uma caixa de diálogo. Nela selecione a seção “All” e preencha o campo id com “get-joke-route”. Esse será o identificador da nossa rota.
- Coloque o mouse em cima da seta entre os blocos timer e setBody e clique no botão de (+), pesquise por https e adicione o bloco. Clique no bloco e preencha o campo “Http Uri” com “official-joke-api.appspot.com/random_joke“.
- Clique no bloco setBody e depois na lixeira para remover o bloco.
- Clique no bloco log e preencha o campo “Message” com “Piada recebida: ${body}”.
Ao terminar nossa integração ficará assim:
O conteúdo da integração formato YAML está logo abaixo.
camel/http-get-joke.yaml
- route:
id: get-joke-route
from:
uri: timer
parameters:
period: 10s
timerName: trigger
steps:
- to:
id: to-2619
uri: https
parameters:
httpUri: official-joke-api.appspot.com/random_joke
- log:
message: "Piada recebida: ${body}"
Para testar a integração vamos selecionar a rota no painel de integrações e clicar no botão “Run”. A Kaoto vai empacotar a rota do Apache Camel e executá-la localmente usando o Camel JBang.
Enquanto a integração estiver sendo executada você verá a saída do log no terminal do VS Code como mostra a figura abaixo:
Para parar a integração utilize o botão “Stop” no painel Deployments.
Agora vamos testar o Deploy no Cluster Kubernetes. Para isso, utilize o botão “Deploy” no painel de integrações.
Ao finalizar o Deploy a integração estará rodando no Cluster Kubernetes. O JBang monta automaticamente uma aplicação baseada em Quarkus.
O Quarkus foi criado justamente pensando em microservices cloud-native. Ou seja, estamos fazendo deploy de um microserviço Quarkus que contém uma rota Camel.
Uma consideração importante aqui, na configuração do Kaoto, mantive o argumento –dev na sessão “Kubernetes Run Arguments”.
O –dev mantém o processo rodando, coloca um watcher de arquivos para rebuild/redeploy automático e imprime continuamente os logs no console (fica mostrando os logs no seu terminal).
Para encerrar o processo você precisa utilizar o Ctrl+C no Terminal do VS Code para sair do dev mode; ao encerrar, ele remove o deployment do cluster no shutdown.
Se você quiser liberar o terminal e continuar a partir daqui olhando os logs do pod diretamente no cluster Kubernetes basta remover o argumento –dev.
Não vou me aprofundar nos comandos para gestão do cluster, mas você pode ver o status do pod da integração implantada com o comando kubectl get pods, como mostra o print abaixo.
Criando a Segunda Integração – um exemplo mais próximo de algo que seja de fato útil
Agora vamos fazer a integração que vai atuar no nosso caso de uso que é uma integração que de consulta diária de USD/EUR/BRL e envio para o sistema de faturamento (Aqui representando pela API Echo).
Vamos criar a nova integração utilizando o botão “New File” do painel de integrações.
Siga os mesmos passos da integração anterior, utilizando o padrão YAML.
Não irei colocar o print de cada etapa da nova integração aqui, apenas o print final, a descrição e o YAML gerado.
Essa integração é executada uma vez por dia, a rota consulta USD/BRL e USD/EUR, extrai a cotação, monta um JSON padronizado com data e taxas, e faz POST desse JSON para um outro endpoint, registrando status e resposta.
São basicamente 10 blocos com as seguintes funções:
- timer: Disparo por timer (a cada 24h).
- log: Loga: “Consultando taxas de câmbio…”.
- https: Chama uma API externa de câmbio (GET).
- unmarshal: Converte JSON recebido na requisição anterior em objeto.
- log: Loga o payload recebido no formato “Payload recebido: ${body}”. Útil para debug/auditoria.
- setBody: Monta um payload padronizado para enviar para outro endpoint.
- log: Loga o payload que vai enviar. Mais uma vez útil para debug/auditoria.
- setHeaders: Define headers para POST JSON
- https: Envia para o “sistema financeiro” (POST). No caso desse exemplo a API de echo.
- log: Loga o status HTTP e a resposta. O endpoint (Beeceptor echo) só devolve o que recebeu, para testes.
Segue abaixo como ficou o arquivo da integração, você pode copiar ele e verificar como cada componente foi configurado no Kaoto.
camel/exchange-route.camel.yaml
- route:
id: exchange-route
from:
uri: timer
parameters:
period: 24h
timerName: exchangeRates
steps:
- log:
id: log-1505
message: Consultando taxas de câmbio...
- to:
id: to-2174
uri: https
parameters:
httpUri: economia.awesomeapi.com.br/last/USD-BRL,USD-EUR
- unmarshal:
id: unmarshal-4441
json: {}
- log:
id: log-1916
message: "Payload recebido: ${body}"
- setBody:
id: setBody-1587
simple:
expression: |-
{
"base": "USD",
"date": "${date:now:yyyy-MM-dd}",
"rates": {
"BRL": ${body['USDBRL']['bid']},
"EUR": ${body['USDEUR']['bid']}
}
}
- log:
message: "Enviando para o sistema financeiro: ${body}"
- setHeaders:
id: setHeaders-8380
headers:
- constant:
expression: POST
name: CamelHttpMethod
- constant:
expression: application/json
name: Content-Type
- to:
id: to-4099
uri: https
parameters:
httpUri: echo.free.beeceptor.com
- log:
id: log-2578
message: "Status recebido do sistema financeiro:
${header[CamelHttpResponseCode]} - ${body}"
Tudo funcionou bem, Segue abaixo o print com parte do log da execução.
Conclusão
Este experimento demonstra que a combinação entre Apache Camel, Kaoto, JBang e Kubernetes reduz significativamente a distância entre modelagem e operação. A modelagem visual gera um artefato declarativo padronizado, o build e o deploy automatizados eliminam etapas manuais e o microserviço nasce já integrado ao ambiente de execução, com logs compreensíveis, status do pod e comportamento previsível desde o primeiro run. Na prática, isso significa menor lead time, maior rastreabilidade e menos fricção no ciclo de vida das integrações.
O empacotamento sobre Quarkus reforça essa abordagem ao entregar um runtime otimizado para cloud: inicialização rápida, baixo consumo de memória, health checks e métricas prontas para observabilidade. Dessa forma, requisitos tradicionalmente tratados apenas após a implantação como operação, monitoramento e confiabilidade passam a fazer parte do desenho da solução desde o início, alinhando desenvolvimento e SRE dentro dos princípios cloud-native.
Embora o exemplo apresentado seja simples (atualização diária de taxas de câmbio) ele percorre toda a cadeia real de uma integração corporativa: coleta externa, transformação de dados, publicação em outro sistema e validação da resposta. O objetivo não foi a complexidade do cenário, mas testar se o stack open source consegue cobrir todas as etapas necessárias para produção com consistência arquitetural.
Mais do que uma ferramenta de integração, o Camel passa a atuar como um padrão operacional para serviços de integração: declarativos, versionáveis, observáveis e compatíveis com pipelines GitOps. Nesse contexto, a produtividade obtida rivaliza plataformas proprietárias enquanto mantém transparência tecnológica, portabilidade e independência de fornecedor.
Assim, o principal aprendizado não é apenas que “é possível integrar usando open source”, mas que é possível fazê-lo mantendo governança, padronização e práticas modernas de engenharia. O cenário de câmbio foi apenas um ponto de partida, o mesmo modelo pode escalar para dezenas ou centenas de integrações com previsibilidade operacional e custo controlado, tornando a abordagem uma alternativa viável para ambientes corporativos de maior porte e criticidade.