Atualizações do ebook grátis: Camel Passo a Passo

Recentemente eu fiz uma atualização no e-book sobre Apache Camel. Essa atualização vem com algumas alterações importantes:

  1. Eu converti o e-book para um website com visual moderno e bonito. Assim fica muito mais fácil de manter o conteúdo atualizado. O link para acessar o livro é: http://angusyoung.org/camel-passo-a-passo/. A partir de agora, não irei mais manter as versões em PDF ou e-pub.
  2. Atualizei o material para o #Apache #Camel 3.11.1 3.14.2. O exemplo com #Camel #Quarkus foi atualizado para a versão 2.2.0. Minha intenção é fazer pequenas revisões do livro a cada nova versão de suporte estendido (LTS – long-term support) do Apache Camel. A próxima versão LTS será a 3.17.
  3. Adicionei algumas informações sobre funcionalidades que não tinha mencionado anteriormente: Camel Main, links para APIs relevantes. Também melhorei as explicações sobre funcionalidades em diversas partes do texto, bem como corrigi alguns erros.
  4. E o mais importante de tudo, a partir de agora todo o texto do livro está disponível no GitHub. Desta forma, basta abrir um ticket ou um pull request no repositório do livro caso alguém encontre algum problema, queira oferecer alguma sugestão ou contribuir com algum material. O endereço do repositório é: https://github.com/integracao-passo-a-passo/ebook.

Inteligência artificial com Java: projetos

Agora que você resolveu os requisitos de hardware, definiu como servir o modelo e escolheu o modelo adequado, é hora de usar Java para interagir com os modelos.

Complexidade das aplicações inteligentes

Um dos desafios de criar aplicações inteligentes se deve ao fato de que os dados utilizados para treinar os modelos são desatualizados e treinar os modelos com dados novos é um processo caro, complicado e demorado. Mesmo projetos como InstructLab, que fornecem uma plataforma simplificada para adicionar informações e conhecimento em modelos, é incapaz de progredir na mesma velocidade com que as informações são atualizadas no mundo real.

Uma das formas de resolver esse problema é através de uma técnica chamada RAG (retrieval-augmented generation – RAG) que utiliza consultas em bases externas para garantir o acesso a dados recentes. O RAG costumeiramente utiliza sistemas de armazenamento com capacidade de busca vetorial pra fazer com que seja possível adicionar informações extras à entrada do usuário, fornecendo contexto para o mecanismo de inferência do modelo.

Em arquiteturas RAG relativamente complexas, é possível encontrar múltiplas bases de dados, em alguns casos, inclusive, com arquiteturas de dados que vão além dos tradicionais modelos relacionais e não relacionais (ex.: usando bancos de grafos para resolver certos tipos de associações de dados).

Primeiros passos

Para começar com o desenvolvimento de aplicações inteligentes com Java, o mínimo que você precisa é de um projeto que facilite o trabalho de interagir com os modelos usando as APIs através das quais eles estão disponíveis.

O principal e mais famoso projeto cobrindo essa necessidade é o LangChain4J. Esse projeto fornece uma plataforma para simplificada integrar LLMs em suas aplicações Java. Além de contar com uma vasta biblioteca de exemplos, também é possível encontrar inúmeras palestras sobre ele em diferentes eventos ao redor do mundo (inclusive no Brasil, e em Português).

Embora o LangChain4J facilite muito o trabalho de interagir com as LLMs, sempre é possível ir mais além. E é isso que a extensão do LangChain4J para o Quarkus nos mostra. Com um conhecimento relativamente básico de Quarkus (que você pode aprender em português nos canais do Marcos Paulo, RinaldoDev e Vinicius Ferraz). No momento me parece que ainda não existe nenhum tutorial em português mostrando sobre como usar as extensões do LangChain4J para Quarkus.

Desenvolvendo sistemas inteligentes mais complexos

Depois de cobrir o básico do desenvolvimento de aplicações inteligentes, você possivelmente vai querer desenvolver sistemas mais complexos, aplicando técnicas como RAG e buscas vetoriais.

Cada vez mais temos opções de bancos com suporte a busca vetorial. Algumas opções incluem:

O OpenSearch, o Postgres e o Apache Cassandra dispensam apresentação: são ferramentas tradicionais para armazenamento e gerenciamento de dados.

Os projetos Milvus e Qdrant são relativamente recentes e populares para busca vetorial. Em particular, o Qdrant tem uma API Java que é bastante fácil de usar e ao mesmo tempo é um banco de dados relativamente poderoso. Para casos muito mais complexos e customizados, vale manter o projeto JVector no radar, já que ele é uma engine de busca vetorial que pode ser embutida na sua própria aplicação, tornando desnecessário o uso de um banco externo.

Garantindo o frescor dos dados

Indo mais além no desenvolvimento desses sistemas, também é necessário implementar soluções para armazenar os dados nesses bancos.

Para sistemas/arquiteturas relativamente simples, onde a fonte dos dados não está distribuída em muitos lugares, talvez seja possível implementar soluções que usam as APIs próprias de cada banco. Possivelmente não é o caso para a grande maioria das aplicações da vida real, então nesse caso, vale considerar projetos como o Apache Camel, simplificar o trabalho de alimentar as bases de dados usadas para RAG quando as fontes desses dados estão distribuídas em muitos sistemas. Em alguns casos, onde os dados precisam ser tratados em grande volume antes da inclusão, ferramentas como o Apache Flink podem ser particularmente úteis.

Em todo caso, é importante lembrar que as escolhas adequadas dependem do seu caso de uso específico.

Outros

O campo de inteligência artificial em Java é bastante amplo e não precisa se limitar somente a chamadas de APIs remotas ou RAG. Portanto, além desses projetos citados, vale ficar de olho em alguns projetos explorando outras ideias, áreas de inteligência artificial e aprendizado de máquina no ecossistema Java:

Espero que isso ajude! Se tiver alguma dúvida adicional ou precisar de ajuda, não hesite em perguntar!

Inteligência artificial com Java: escolhendo o modelo adequado

Agora que você escolheu como servir seu modelo, é hora de escolher qual modelo servir. Isso pode parecer intimidante, mas não se preocupe! Aqui estão algumas dicas importantes para ajudá-lo a tomar uma decisão informada.

Verifique se o modelo é verdadeiramente aberto

 Embora muitas empresas usem o termo “Open Source” para descrever seus modelos, é importante verificar se eles são realmente abertos. O site IsItOpen pode ajudá-lo a verificar se o modelo tem restrições de uso que podem afetar seu uso comercial.

Escolha um modelo adequado para o seu caso de uso

 Cada modelo tem seus próprios casos de uso e performa melhor em diferentes tarefas. Use as informações no card do modelo no HuggingFace (uma plataforma para hospedagem e compartilhamento de modelos e conjuntos de dados) outros para conhecer os casos de uso de cada modelo.

Ajuste os parâmetros do modelo

 Mesmo se você escolher o modelo correto para seu caso de uso, pode ser necessário ajustar os parâmetros do modelo para que ele se comporte da maneira esperada. Isso pode incluir ajustes para tornar o modelo mais conservador ou mais criativo. Por exemplo, ao usar ferramentas como Ollama e LM Studio, você tem a opção de ajustar parâmetros como a “temperatura” do modelo, “top k” e “top p” e muitos outros que modificam a forma como o modelo vai se comportar em relação aos dados de entrada.

Modelos recomendados

Se você não sabe qual modelo escolher ou se sinta sobrecarregado com tantas escolhas, aqui estão alguns modelos que podem ser úteis:

Obviamente, você também pode fazer uso de modelos proprietários e não abertos, como o Llama 3. Nesse caso, entretanto, é recomendável verificar licença e as restrições de uso.

Além disso, você também tem a possibilidade de usar modelos servidos por empresas especializadas e/ou através de APIs específicas. Alguns exemplos: ChatGPT, Gemini, Claude 3.5 Sonnet. Nesse caso, vale considerar o custo, restrições de uso e a disponibilidade de ferramentas compatíveis com as APIs utilizadas.

Um importante detalhe sobre o InstructLab

Se você decidir usar o InstructLab para servir seu modelo, é importante notar que você precisará de modelos ajustados para esse projeto.

O InstructLab fornece no momento duas famílias de modelos abertos que você pode usar:

  • Granite base: de uso geral, baseado no IBM Granite 7B base.
  • Merlinite: um derivado do Mistral 7B, de uso geral, preparado para LAB.

O InstructLAB também conta com funcionalidades para converter, quantizar e empacotar os modelos no formato GGUF (eu nunca cheguei a testar essas funcionalidades, mas vale a pena tentar caso você queira usar algum modelo específico diferente dos distribuídos pelo projeto).

Consulte a documentação do projeto para saber mais sobre como escolher e preparar os modelos corretos.

Parâmetros, formatos, quantização e outros detalhes relevantes

Ao navegar pelo HuggingFace você vai encontrar diferentes tipos de arquivos, em diferentes formatos e tudo mais. Para seus primeiros passos em IA com Java, os detalhes específicos de cada um deles não são muito relevantes nesse momento. De modo geral, você precisa levar em consideração os seguintes detalhes:

Parâmetros

Você encontra muitos artigos descrevendo o que são parâmetros em LLMs. Eu gosto muito desse post que descreve os parâmetros como botões e alavancas que podem ser manipulas para ajustar o entendimento e comportamento de geração do modelo.

No HuggingFace você encontra modelos de diferentes tamanhos, sendo bastante comum encontrar:

  • 7b: 7 bilhões de parâmetros.
  • 8b: 8 bilhões de parâmetros.
  • 13b: 13 bilhões de parâmetros.

Via de regra, quanto maior a quantidade de parâmetros, maior a quantidade de memória (de vídeo – vRAM – ou, em sua falta, de sistema – RAM) necessária para carregar o modelo. Existem inúmeros artigos detalhando como estimar a memória necessária para carregar os modelos. A grosso modo, se você tem um hardware com os requisitos mínimos que eu descrevi no primeiro artigo, você deve ser capaz de usar um modelo com algo em torno de 8b parâmetros – com quantização de 4 bits – sem maiores problemas.

Dica: uma das funcionalidades legais do LM Studio e que não existe em outros aplicativos é que ele mostra quais modelos você pode ser capaz de carregar na memória da sua máquina.

Quantização

Quantização é uma técnica para reduzir a memória necessária para carregar os modelos. Isso é feito através da redução da precisão dos “pesos” usados pelo modelo. Você geralmente encontra as informações sobre quantização no card do modelo ou através de tags ou nome dos arquivos.

As tags normalmente tem o formato de nome Qx_f_t onde “x” representa o número de bits da quantização, “f” representa o formato e t representa o mix de tipos de quantização utilizados. Exemplos de tags/nomes comumente utilizados para se referir a modelos quantizados: Q4_K_M (4 bits de quantização), Q5_K_M (5 bits de quantização), Q5_K_S (5 bits de quantização), etc. O formato de quantização e o mix, nesse momento, não são relevantes.

Formatos

Você geralmente encontra os modelos distribuídos em diferentes formatos:

  • Safetensors: um formato simples para armazenamento de tensors.
  • GGML (GPT-Generated Model Language): uma biblioteca de tensors que facilita o uso em diferentes formatos
  • GGUF (GPT-Generated Unified Format): outra biblioteca de tensors, um pouco mais moderna, que busca corrigir algumas da deficiências do formato GGML.

Via de regra, prefira o GGUF: bem suportado em boa parte das ferramentas usadas para desenvolvimento de aplicações inteligentes (Ollama, InstructLab, LM Studio, etc).

Conclusão

Escolher o modelo adequado é um passo importante na implementação do seu sistema inteligente em Java. Lembre-se de verificar se o modelo é verdadeiramente aberto, escolher um modelo adequado para o seu caso de uso e ajustar os parâmetros do modelo. Além disso, há muitos recursos disponíveis on-line que podem ajudá-lo a encontrar o modelo certo para você!

Opções para acessar ou servir um modelo

Você escolheu servir seu próprio modelo de inteligência artificial! Agora, você precisa escolher como deseja servir esse modelo.

A maneira mais comum de acessar um modelo é através de API. Até o presente momento, acessar os LLMs nativamente usando a JVM não é algo muito comum, embora existam projetos como o ONNXRuntime trabalhando nesse problema. De modo geral, a maneira mais fácil de ter acesso aos modelos é através de APIs (rodando localmente ou um servidor) ou através de serviços especializados.

Serviços especializados

Os serviços especializados são, talvez, a forma mais fácil de começar a criar aplicações inteligentes, já que eles fornecem tudo pronto sem a necessidade de configurar um serviço, buscar modelos, etc. Eles também são uma opção interessante caso você não tenha acesso a hardware relativamente recente capaz de servidor os modelos.

Muitas empresas fornecem, através de assinaturas ou pacotes pré-pagos, a possibilidade de acessar os modelos através de APIs próprias.

Local ou servidor

Caso você prefira servir os modelos você mesmo, seja localmente na sua máquina, seja remotamente na cloud, você tem muitas opções para servir um modelo (SLM/LLM). Desde soluções mais escaláveis até opções voltadas para uso local ou restrito.

Ollama: uma ferramenta de código aberto

Uma das opções interessantes é o Ollama, uma ferramenta que facilita o trabalho de servir, importar e customizar diferentes modelos. Trabalhando com código aberto, o Ollama torna acessível o uso de diferentes modelos para testes e experimentações. Além disso, a API do Ollama é compatível com a da OpenAI (usada no ChatGPT), o que facilita a integração.

Uma das funcionalidades legais do Ollama é a facilidade de importar modelos diferentes e aplicar parâmetros customizados para ajustar o comportamento dos modelos.

De todas as ferramentas que eu uso para servir modelos, o Ollama é a que eu uso com mais frequência, por fornecer suporte a aceleração via GPU no MacOS e pela possibilidade de ajustar parâmetros dos modelos.

InstructLab: um projeto inovador

Outra opção é o InstructLab, um projeto que permite contribuir conhecimentos e habilidades para LLMs (do inglês large language models – grandes modelos de linguagem). O InstructLab aplica uma técnica inovadora chamada LAB (Large-scale Alignment for chatBots) que facilita a alinhamento dos modelos durante a fase de ajuste de instrução. Além disso, o InstructLab permite servir os modelos usando uma API compatível com a da OpenAI.

O InstructLab é particularmente interessante se você deseja criar aplicações inteligentes que dependem de modelos especializados ou com conhecimento específico, já que o InstructLab facilita bastante o trabalho de adicionar conhecimento nos modelos.

Podman AI Lab

O AI Lab do Podman provê uma maneira de acessar as LLMs através de containers de uma maneira bastante simples e prática. É a forma mais prática e limpa de acessar os modelos sem poluir muito o seu sistema. Se você usa MacOS, talvez não seja a melhor opção, já que não parece fornecer aceleração via GPU, tornando a inferência consideravelmente mais lenta.

Outras opções

Além do Ollama e do InstructLab, existem outras ferramentas que podem ser usadas para servir um modelo localmente. Algumas delas incluem:

  • LM Studio: uma ferramenta proprietária que oferece soluções customizadas. É particularmente legal por ser um aplicativo desktop, tornando muito fácil baixar e testar modelos. Também conta com uma API compatível com a da OpenAI.
  • vLLM e Kserve: ferramentas para soluções customizadas em maior escala.

Conclusão

Essas são apenas algumas das opções interessantes para servir seu próprio modelo localmente (tem muito mais). No próximo post eu vou falar um pouco sobre como escolher um modelo e algumas das opções disponíveis.

Inteligência artificial com Java: primeiros passos

Quer começar a trabalhar com inteligência artificial (IA) utilizando Java, mas não sabe por onde começar? Nesse post, vou te guiar através dos primeiros passos para começar a explorar o mundo da IA. Embora o foco seja, especificamente, em mostrar como desenvolvedores Java podem começar a criar aplicações inteligentes, grande parte das dicas e detalhes explicados nos artigos se aplicam a outras linguagens.

Infraestrutura: escolha sua opção

Antes de começar a trabalhar com IA em Java, é necessário resolver o problema da infraestrutura. Você tem três opções:

1. Rodar tudo localmente: Esse método requer um computador bem equipado para lidar com os recursos intensivos necessários para treinar e executar modelos de IA.

2. Servir você mesmo na cloud: Essa opção permite que você execute seu modelo de IA em uma plataforma de nuvem, como o ChatGPT ou outro serviço semelhante.

3. Assinar um serviço: Esse método é ideal para aqueles que não desejam lidar com a infraestrutura e podem usar serviços prontos para começar a trabalhar com IA. Ideal se você não tem um computador com os requisitos mínimos para trabalhar com IA.

Hardware: requisitos mínimos

Para rodar tudo localmente, você precisará de um computador razoavelmente bom. Aqui estão algumas sugestões:

  • MacBook: um MacBook com processador M1, M2 ou M3 (preferencialmente dos modelos Pro ou superior) com pelo menos 16Gb de memória RAM (idealmente 32Gb).
  • Linux: uma máquina com processador x86 relativamente recente, uma GPU moderna da AMD (idealmente algo da série RX 7000) ou Nvidia (da série 30xx ou superior) e pelo menos 16Gb de memória RAM.

Servindo o modelo na Cloud

Vários provedores de cloud fornecem opções de máquinas virtuais com os recursos necessários para servir modelos. Embora os custos dessas máquinas virtuais sejam bem maiores do que os das máquinas usadas para servir páginas ou rodar cargas de computação, eles não são necessariamente proibitivos para testes esporádicos.

Conclusão

Começar a trabalhar com inteligência artificial com Java pode parecer intimidante, mas seguindo os passos apresentados nesse post, você estará pronto para começar a explorar o mundo da IA em breve. Lembre-se de que a escolha da infraestrutura e do modelo é crucial para um começo bem-sucedido.

Nos próximo post irei falar um pouco sobre como ter acesso ao modelo. Posteriormente, cobrirei a escolha do modelo e projetos importantes para começar em IA com Java.

Espero que isso ajude! Se tiver alguma dúvida ou precisar de mais informações, sinta-se à vontade para perguntar.

Automatize a investigação de bugs com git bisect

Muitas vezes bugs acabam sendo introduzidos inadvertidamente em um projeto mesmo após passarem pelos testes unitários, eventualmente sendo descobertos somente após a execução de testes de integração, performance ou e2e na CI.

Nem sempre é fácil encontrar qual foi o commit causador do problema, dependendo do volume de alterações do projeto, práticas internas de engenharia de software e do número de desenvolvedores trabalhando no código.

Felizmente o git tem uma ferramenta bastante prática para automatizar o processo de encontrar o commit problemático: git bisect.

O git bisect é uma funcionalidade do git que usa um algoritmo de busca binária para “navegar” pelo histórico de commits do projeto e encontrar qual o commit problemático (não sabe o que é busca binária? Aprenda aqui).

Para isso o git bisect precisa de duas informações: um commit “ruim” (o hash do commit onde o problema ocorre) e um commit “bom” (o hash do commit onde o problema não ocorre). Tendo essas informações em mãos você pode rodar: git bisect start "ruim" "bom" e ele vai fazer o checkout dos commits para você.

Aí, basta você executar os comandos para compilar e testar a aplicação (por exemplo: “mvn clean verify“). Se o teste passar, você deve marcar o commit como bom (git bisect good). Caso ele falhe, você deve marcar o commit como ruim (git bisect bad). Após rodar um desses dois comandos para marcar o commit como bom ou ruim, ele vai prosseguir para o próximo commit no histórico.

Você deve repetir o processo até que ele termine de navegar pela lista de commits e lhe mostre qual foi o primeiro commit problemático que introduziu o problema.

Mas peraí, eu falei que o lance era automatizar a investigação de bugs, e esse processo parece muito manual né? É aí que entra o git bisect run. Essa funcionalidade permite que você forneça um script que teste o projeto. O script tem um requisito básico: o script deve retornar 0 para marcar um commit como bom, e um valor entre 1 e 127 para marcar um commit como ruim.

Por exemplo, suponha que você precise usar o docker-compose para subir a infra de testes, então rodar o build e os testes, e depois de executado encerrar a execução dessa infraestrutura. Para isso, você usaria um script parecido com esse aqui.

E, então, basta rodar o script usando o seguinte comando: git bisect run meu-script-de-testes.sh.

cf63ab12cbe3cfa598fcb83e6447c3c39718b3a4 is the first bad commit
commit cf63ab12cbe3cfa598fcb83e6447c3c39718b3a4
Author: Otavio R. Piske some-email@domain.com
Date: Wed Jun 28 09:05:14 2022 +0300

Added support for whatever in module foo.

Dependendo de quão grande é seu projeto, esse processo pode demorar um pouco. Então, agora basta sair para tomar um café, ler as notícias do dia ou fazer uma thread legal no Twitter, enquanto o git bisect procura o commit problemático para você.

Camel, Camel K e Kamelets no Tchelinux

Recentemente eu tive a honra de participar do super evento Tchelinux (um evento online com mais de 40 horas de conteúdo gratuito) . Na palestra que eu preparei para este evento eu falarei um pouquinho sobre os desafios de integração de sistemas na era da computação em nuvem. Nessa palestra eu apresento o Apache Camel, Camel K, Camel JBang e Kamelets.

Confira a palestra para aprender um sobre como tudo isso se relaciona e como essas tecnologias podem acelerar a maneira como você desenvolve integrações. A palestra vai ao ar nessa quarta-feira, dia 18 de novembro.

Conhecendo o JBang

O JBang é uma aplicação que permite executar códigos em Java sem a necessidade de compilar diretamente o código e/ou criar projetos usando Maven ou Gradle. Simplificando, o JBang traz para o Java a agilidade dos scripts em Shell ou Python com o poder e a flexibilidade do Java.

O JBang pode ser instalado facilmente usando o SDKman!:

sdk install jbang

Uma vez instalado, você pode gerar um projeto a partir de um template padrão:

jbang init -t cli hello.java

Como resultado desse comando, ele irá criar um arquivo hello.java com um conteúdo parecido com o seguinte:

///usr/bin/env jbang "$0" "$@" ; exit $?
//DEPS info.picocli:picocli:4.5.0

import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Parameters;

import java.util.concurrent.Callable;

@Command(name = "hello", mixinStandardHelpOptions = true, version = "hello 0.1",
        description = "hello made with jbang")
class hello implements Callable<Integer> {

    @Parameters(index = "0", description = "The greeting to print", defaultValue = "World!")
    private String greeting;

    public static void main(String... args) {
        int exitCode = new CommandLine(new hello()).execute(args);
        System.exit(exitCode);
    }

    @Override
    public Integer call() throws Exception { // your business logic goes here...
        System.out.println("Hello " + greeting);
        return 0;
    }
}

Algumas particularidades interessantes do arquivo acima:

//DEPS org.grupo:dependencia:${dependencia.versao}

O JBang permite gerenciar dependências de diversas maneiras, a mais comum sendo através desse tipo de linha de configuração (modeline) precedida por //DEPS.

As dependências são referenciadas através da nomenclatura GAV (grupo, artefato, versão) no formato: G:A:V. Além disso é possível tanto usar BOM POMs para facilitar o gerenciamento de versões quanto trocar a versões fixas no código por propriedades que podem ser passadas por linha de comando:

//DEPS org.grupo:dependencia:${dependencia.versao}

Tornando possível executar o projeto usando algo semelhante ao seguinte:

jbang -Ddependencia.versao=2.0.1

Outra particularidade muito interessante do JBang é o uso do projeto PicoCLI para o gerenciamento das opções de linha de comando, o que permite tornar o script bastante flexível de maneira bastante elegante e direta.

Para executar esse arquivo você pode rodar:

./hello.java

ou

jbang run hello.java

Ao executar qualquer um dos comandos acima, temos o resultado esperado que é a impressão da famosa mensagem “Hello World”. E claro, também podemos brincar com a PicoCLI para mudar parte da mensagem:

jbang run hello.java --gretting Mundo!
Hello Mundo!

Obviamente essa é só uma introdução bastante simples sobre o JBang. A capacidade de utilizar as inúmeras bibliotecas reutilizáveis que temos disponíveis em Java, torna o projeto bastante interessante para desenvolvedores com a necessidade de automatizar tarefas e que, talvez, não se sintam confortáveis com Shell Scripts. Além disso pode ser uma plataforma extremamente interessante para desenvolvedores iniciantes, pois remove a necessidade de gerenciar os projetos com Maven ou Gradle.

Projetos interessantes pra acompanhar no universo Kafka

Recentemente um amigo me perguntou sobre alguns projetos interessantes no universo Kafka. E eu separei 3 projetos que eu acompanho, 1 dos quais eu contribuo, e que acho interessantes. É uma lista bem pessoal e nem de longe representa toda a riqueza do universo Kafka.

O Strimzi é um projeto que facilita o trabalho de rodar o Kafka em Kubernetes (k8s) e suas distribuições (OpenShift, GKS, k3s, etc). O Kafka é relativamente complicado para gerenciar e botar em produção, e ainda mais complicado de rodar dentro de Kubernetes. Esse projeto abstrai a maior parte da complexidade de manter um cluster Kafka rodando nesse tipo de ambiente.

O Camel Kafka Connector (disclaimer: eu contribuo com esse projeto) é um runtime do Apache Camel que envelopa todos os mais de 300 componentes do Camel e permite roda-los como conectores dentro de uma instância do Kafka Connect. O Kafka Connect é um componente do Kafka pra rodar programas que movem dados pra dentro ou pra fora do Kafka. Na maior parte das vezes você consegue fazer integrações pra dentro ou fora do Kafka sem precisar escrever uma linha de código sequer.

O Debezium é um projeto pra Change Data Capture (CDC) e que permite capturar as alterações que ocorrem e um banco de dados e publicá-las no Kafka. O Debezium usa a API do Kafka Connect para rodar seus “source connectors”.

Criando um switch KVM por software

Nessa postagem mostrarei como fazer um KVM-switch para Linux usando apenas software e um pouco de hardware compatível.

Para começar você precisa dos seguintes dispositivos:

E dos seguintes softwares instalados: ddcutil e Solaar. A instalação deles no Fedora é bastante simples, já que eles estão nos repositórios oficiais do projeto:

sudo dnf install -y solaar ddcutil

Mouse e Teclado

É bem provável que você já tenha o Solaar instalado se você tem o teclado e o mouse da Logitech. De qualquer maneira, a documentação do projeto fornece os passos iniciais para configurar o Solaar, caso seja necessário.

Você pode inspecionar a configuração dos dispositivos usando o comando solaar show. Pessoalmente acho mais simples verificar na GUI do Solaar, já que ela também mostra quais os valores aceitáveis para o comando que usaremos adiante. A informação relevante para nós é a mostrada em “Change Host“. Ela mostra os nomes dos hosts com os quais seu dispositivo está pareado.

Usando as informações mostradas na UI, podemos usar a linha de comando para trocar o host ativo:

solaar config "MX Keys" change-host 1:mercury

Note que o nome do host tem que ser igual ao mostrado na UI e em alguns casos pode ser que somente o número do ID seja mostrado.

Repita o mesmo para o mouse, tomando cuidado de garantir que o ID utilizado é o ID do dispositivo, pois é possível que os eles sejam diferentes entre o mouse e o teclado (ex.: o host 1 do teclado é o host 2 do mouse, etc):

solaar config "MX Master 3" change-host 1:mercury

Monitor

Para controlar o monitor, usamos o programa ddcutil, que serve para interagir com o software do monitor através do conjunto de protocolos DDC-CI. Nesse link aqui, que serviu de referência pra implementar o controle do monitor, você encontra algumas dicas legais sobre o ddcutil.

O primeiro passo é detectar o monitor e ver quais as funcionalidades estão disponíveis:

sudo ddcutil detect

Em algumas distribuições pode ser necessário carregar o módulo i2c-dev. O Fedora já costuma fazer isso por padrão, então nenhum passo a mais é necessário. Se estiver usando outra distro, consulte a documentação.

Se executado com sucesso, o comando vai mostrar uma saída semelhante a esta aqui:

Display 1
I2C bus: /dev/i2c-2
EDID synopsis:
Mfg id: GSM
Model: LG Ultra HD
Serial number:
Manufacture year: 2017
EDID version: 1.3
VCP version: 2.1

Se você estiver usando um laptop, o comando também vai mostrar a informação do monitor embutido. Esse monitor embutido não é relevante para o KVM-switch virtual, portanto podemos ignorar as mensagens de erro referentes a ele.

A informação relevante mostrada pelo comando acima é o I2C bus. Mais especificamente, o número do bus (2, no caso de /dev/i2c-2). Tendo a informação do bus, podemos usa-la para descobrir as funcionalidades do monitor. Para o KVM-switch estamos interessados na funcionalidade “Input Source“. Podemos usar o seguinte comando para descobrir o ID da feature e os valores aceitáveis para configura-la.

sudo ddcutil capabilities --bus=2 | grep -A 5 "Input Source"

Feature: 60 (Input Source)
Values:
11: HDMI-1
12: HDMI-2
0f: DisplayPort-1
10: DisplayPort-2

Isso nos mostra que para mudar o dispositivo de entrada do monitor, podemos usar a feature ID 60 usando os valores (em hexadecimal) 0x11, 0x12, 0x0f e 0x10. Para testar, nesse caso:

sudo ddcutil --bus=2 setvcp 60 0x0f &

Executando esse comando já é possível trocar a entrada do monitor usando apenas a linha de comando.

Finalizando e Integrando no Gnome

Tendo em mãos os comandos para mudar o mouse, teclado e monitor. Podemos colocar tudo isso num script:

sudo ddcutil --bus=2 setvcp 60 0x0f &
solaar config "MX Keys" change-host 2
solaar config "MX Master 3" change-host 2

Repita o processo para outros hosts do seu KVM-switch virtual (ex.: micro 1, micro 2, etc). Não esqueça de dar permissão de execução nos scripts.

Por fim, podemos criar atalhos de teclado no Gnome para que execute esses scripts.

Como funciona?

No meu caso eu configurei os atalhos Ctrl+F2 para alternar para o laptop do trabalho e Ctrl+F3 para alternar para o laptop pessoal.

Obs.:

  • Imagino que funciona com qualquer teclado Logitech com suporte a múltiplos dispositivos (tipo o K810), mas eu não testei.
  • Assim como o teclado, acredito que deve funcionar com outros mouses com suporte a múltiplos dispositivos, tipo o Logitech M720 Triathlon.
  • É possível usar o ddcutil sem sudo e o artigo de referência mostra como fazer isso, porém fiz isso aqui.

Ebook grátis: Camel Passo a Passo

Em 2014 eu escrevi um mini e-book sobre integração de sistemas com Apache Camel. Naquela época o Apache Camel encontrava-se por volta da sua versão 2.10.x. Desde então, graças a velocidade de inovação da comunidade Open Source, inúmeras mudanças e melhorias foram feitas no Apache Camel (que hoje está em sua versão 3.6 ou 3.4.4 na versão LTS). Além disso, ao longo dos anos o projeto Camel foi adicionando números subprojetos novos, como o Camel Quarkus, o Camel Kafka Connector e o Camel K.

Para atualizar o livro para as versões atuais do Camel e cobrir um pouco sobre os novos subprojetos eu resolvi fazer uma extensa atualização na edição passada. Essa nova atualização também conta com algumas atualizações de cenários de integração, dando maior enfoque nos projetos de integração da Apache como o Apache Kafka e o Apache Artemis (futura nova geração do Apache ActiveMQ).

Hoje eu resolvi liberar uma versão preliminar do ebook que, ressalto, está disponível completamente de graça e sem custo algum. Essa é uma versão preliminar que cobre, no momento, detalhes básicos sobre integração de sistemas com Camel e uma introdução sobre o Camel Quarkus (para integrações subatômicas e supersônicas com Java). O livro vêm com alguns exemplos comentados que dão uma noção básica do funcionamento e servem de acompanhamento para os trechos de código do ebook.

Como o livro ainda é uma versão preliminar, é bastante possível que contenha alguns erros e pequenas inconsistências. Neste caso, eu agradeceria comentários e correções que pudessem ajudar a melhorar o conteúdo do livro através do meu email pessoal (angusyoung@gmail.com).

Os livros estão disponíveis em formato PDF e epub em formato amigável para leitura em tablets (como o iPad) e podem ser baixados nos seguintes links:

Obs.: alguns leitores de epub podem exibir a formatação de código levemente diferente do esperado, mas sem implicar em qualquer perda de conteúdo.