---
# System prepended metadata

title: 'Open Shift com Kafka Stream '

---

# Open Shift com Kafka Stream  
## Kafka em operação com o Open Shift estudo levantado com base na reunião de segunda-feira.

- Com a adoção massiva do Apache Kafka, as empresas estão procurando uma maneira de replicar dados em diferentes sites. O Kafka por si só tem seu próprio mecanismo interno de replicação e autocorreção, que é relevante apenas para o cluster local e não pode tolerar uma falha completa do site. A solução para isso é o recurso “Mirror Maker”, com esse recurso, seu cluster Kafka local pode ser replicado de forma assíncrona para um cluster Kafka externo/central diferente que está localizado em um local totalmente diferente para persistir seus pipelines de dados, registrar processos de coleta e coleta de métricas.

- O “**Mirror Maker**” conecta dois clusters, pois um deles é o cluster consumidor e o outro é o produtor. Os tópicos estão sendo replicados como uma entidade lógica com tudo o que possuem armazenado no cluster de destino, onde um aplicativo pode consumir os dados que estão sendo transferidos. O Mirror Maker pode ser escalonável horizontalmente, o que significa que pode ser ampliado quando for o gargalo.

 ## Análise detalhada do Red Hat AMQ Streams

![image](https://hackmd.io/_uploads/Sy24bd2uT.png)


### AMQ Streams possui vários operadores, o que ajuda a resolver os desafios de execução de AMQ Streams no mundo dos contêineres:

- Operador de cluster : implanta e gerencia clusters Kafka em contêineres corporativos.
- Operador de entidade : gerencia usuários e tópicos usando dois - suboperadores diferentes. O  Operador de Tópico  gerencia 
- tópicos Kafka em seu cluster Kafka, e o  Operador de Usuário  gerencia usuários Kafka em seu cluster Kafka.
-Kafka Connect : conecta sistemas externos ao cluster Kafka.
- Kafka Mirror Maker : replica dados entre clusters Kafka.



 ![image](https://hackmd.io/_uploads/HkP9Uz3up.png)
### Escalador Kafka
### O escalonador Kafka monitora o atraso do consumidor em tópicos do Kafka para dimensionar dinamicamente seus aplicativos de consumo. O atraso do consumidor refere-se especificamente à diferença entre a última mensagem produzida e a última mensagem processada pelo consumidor. Esse foco no atraso do consumidor permite um dimensionamento mais preciso com base na eficácia com que o aplicativo está processando os registros recebidos. Quando o atraso do consumidor excede um determinado limite, sinalizando que o aplicativo está atrasado no processamento das mensagens recebidas.
### O Operador aumenta o número de instâncias do aplicativo para lidar com o aumento da carga. À medida que o atraso diminui, indicando que as mensagens estão sendo processadas conforme o esperado, reduz o número de instâncias. Isso garante o processamento eficiente de mensagens Kafka, aumentando ou diminuindo os recursos com base na demanda em tempo real e mantendo o desempenho ideal do aplicativo.

 ![image](https://hackmd.io/_uploads/SkCCfO3Op.png)
 

###  Controlador: O Controlador observa continuamente os recursos ScaledObject configurados, orquestrando o escalonamento dinâmico de cargas de trabalho com base nos gatilhos e critérios de métricas definidos, garantindo a alocação ideal de recursos. Assim que o controlador detectar um recurso ScaledObject, ele obterá as informações do ScaledObject e criará um escalonador automático de pod horizontal para seu aplicativo.

#### ScaledObject especifica as métricas e os gatilhos a serem monitorados, permitindo que o controlador gerencie com eficiência o escalonamento das cargas de trabalho em resposta às flutuações métricas.

### Adaptador de métricas: O adaptador de métricas traduz métricas brutas, como o atraso do consumidor no nosso caso, em um formato compreensível pelo OpenShift, expondo essas métricas personalizadas ao HPA. O Metrics Server atua como uma interface entre o servidor API do OpenShift e métricas externas, fornecendo dados essenciais ao HPA Controller.

### Escalador: A função principal do escalador é conectar-se a um sistema externo e recuperar métricas ou dados que indiquem a carga ou demanda atual. Em nosso caso, o escalonador Kafka usa as credenciais do TriggerAuthentication para autenticar no cluster Kafka e recupera o atraso do consumidor para o tópico e grupo de consumidores especificados. Em seguida, ele envia as métricas de atraso do consumidor de volta ao adaptador de métricas.

:::warning
#### HPA: o escalonador automático de pod horizontal avalia as métricas que recebe do adaptador de métricas em relação aos critérios de escalabilidade definidos no ScaledObject. O HPA interage com a API OpenShift para aumentar/diminuir os pods durante a implantação. Na verdade, a contagem de réplicas da implantação aumenta caso o atraso esteja acima do limite. Caso o atraso do consumidor seja inferior ou igual ao limite definido no ScaledObject, as réplicas poderão ser reduzidas para minimizar o uso de recursos.

:::warning
 **A experiência do desenvolvedor foi uma prioridade quando projetamos e construímos o OpenShift Streams. Ele fornece uma experiência simplificada ao desenvolvedor para criar, implantar e dimensionar aplicativos em tempo real em ambientes de nuvem híbrida.**
:::

### Benefícios do Open Shift Streams para Apache Kafka

Atualmente em versão prévia de desenvolvimento, o OpenShift Streams for Apache Kafka fornece operações consistentes em microsserviços distribuídos, grandes volumes de transferência de dados e operações gerenciadas. Os administradores podem se concentrar em outras tarefas enquanto a Red Hat cuida da infraestrutura e os desenvolvedores podem autoprovisionar recursos do Kafka para proporcionar independência e eficiência.

**OpenShift Streams for Apache Kafka é totalmente gerenciado pelos Red Hat Site Reliability Engineers. Assim como acontece com os serviços e produtos gerenciados OpenShift, as operações diárias, como registro e atualizações, são tratadas proativamente nos bastidores.** 

- **OpenShift Streams for Apache Kafka não exija que uma organização use o OpenShift, ele se adapta perfeitamente à criação de aplicativos no OpenShift. A Red Hat fornece operadores de vinculação de serviços para que os desenvolvedores possam conectar cargas de trabalho do OpenShift a tópicos do Kafka com facilidade.**

- Os desenvolvedores têm o Kafka ao seu alcance para criar, descobrir e conectar-se a fluxos de dados em tempo real, onde quer que estejam implantados. Isso torna muito mais fácil para eles conectar microsserviços fracamente acoplados em execução no OpenShift, para fornecer experiências em tempo real aos usuários e para construir aplicativos de análise de dados. 
-
cloud.redhat.com 

## O Que é AMQ STREAMS

#### O AMQ Streams da Red Hat e o Kafka Streams são soluções diferentes, e a escolha entre eles depende das necessidades específicas do seu ambiente e dos requisitos do seu projeto. Ambos são voltados para processamento de streaming de dados em tempo real, mas têm algumas diferenças importantes:

- AMQ Streams (anteriormente conhecido como Red Hat AMQ for Apache Kafka): O AMQ Streams é uma oferta da Red Hat que fornece suporte e integração entre o Apache Kafka e a plataforma Red Hat AMQ (Advanced Message Queuing). Ele permite que você implante e gerencie clusters Apache Kafka em ambientes Red Hat OpenShift ou Kubernetes usando o projeto Strimzi, que mencionei anteriormente. O AMQ Streams é uma escolha sólida se você já estiver usando a plataforma Red Hat e desejar uma solução integrada e com suporte para streaming de dados.

:::spoiler
**Para a Integração entre os ambientes de Stream essa solução seria uma das melhores até agora, pelo que estou vendo como ambiente de resposta e integração, só estou analisando quais linguagem entrariam nesse contexto de solução, para tudo que li e executei em diferentes streams, comaparando o spark stream o kafka Stream, o Flink, Storm, Red Panda. Chego a uma rápida conclusão que é uma excelente escolha quando estamos falamos de integração se adequando bem para CCR.**
:::

### Deixando em detalhes meu spoiler sobre a arquitura, seguimos analisando o contexto do do estudo do Stream agora com Strimzi.

 
## Kafka Stream na Red Hat








## Apache Kafka da Red Hat com Mirror Maker

 
## Pré-requisitos
> **O Red Hat AMQ Streams, que aproveita *o projeto de código aberto Strimzi, fornece uma maneira de implantar o Apache Kafka no Kubernetes usando o padrão do operador*. A implantação do MirrorMaker 2 é suportada com a criação de um recurso customizado do tipo KafkaMirrorMaker2.**

 As permissões que precisam ser concedidas ao usuário Kafka dependerão da arquitetura MirrorMaker 2 que você decidir implementar. 
 
 


## O que é Strimzi:
**Strimzi** fornece  executa um cluster Apache Kafka no Kubernetes em várias configurações de implantação. Para produção, você pode adaptar o cluster às suas necessidades, usando recursos como reconhecimento de rack para espalhar corretores entre zonas de disponibilidade e taints e tolerâncias do Kubernetes para executar o Kafka em nós dedicados. Você pode expor o Kafka fora do Kubernetes usando NodePort, Load balancer, Ingress e OpenShift Routes.

:::danger
O gerenciamento nativo do Kube do Kafka não se limita ao corretor. Você também pode gerenciar tópicos e usuários do Kafka, Kafka MirrorMaker e Kafka Connect usando recursos personalizados. Isso significa que você pode usar seus processos e ferramentas familiares do Kubernetes para gerenciar aplicativos Kafka completos.
:::

## Observação : Kafka Streams na Red Hat e AMQ Streams, são baseados em Kafka e Strimzi1. A principal diferença entre eles é que o Kafka Streams é uma solução hospedada, enquanto o AMQ Streams é hospedado e gerenciado pelo cliente1.

O Kafka Streams é parte do Apache Kafka e é usado para construir aplicações e microsserviços de processamento de dados em tempo real2. Ele permite que você faça uma análise em tempo real, extraia informações, execute agregações complexas, detecte anomalias, etc2.

 AMQ Streams da Red Hat é uma distribuição do Apache Kafka que é otimizada para rodar em ambientes OpenShift e Kubernetes1. Ele é projetado para simplificar o processo de executar e gerenciar um serviço de Kafka em um ambiente de nuvem1.

## Projeto Strimizi

O Red Hat AMQ Streams é uma solução empresarial baseada no Apache Kafka, que facilita a troca de dados entre sistemas com alta eficiência e baixa latência. Ele está disponível como parte da oferta Red Hat AMQ em Red Hat Enterprise Linux e OpenShift Container Platform. Ao ser executado em contêineres, o AMQ Streams enfrenta desafios como atualização do Kafka, implantação inicial, gerenciamento do ZooKeeper, substituição de corretores, balanceamento de partições de tópicos e adição/desativação de corretores. Estes desafios são endereçados pelo padrão Operador do projeto Strimzi.

### Pode ser executado com Open Shift, EKS, minikube, 


## Comando de open Shift para instalação do Cluster

```cmd=
oc apply -f instalação/operador de cluster
```




### O Apache Kafka é uma plataforma de streaming de dados amplamente utilizada para a ingestão, processamento e análise de grandes volumes de dados em tempo real.
### O Strimzi fornece uma variedade de recursos e ferramentas para facilitar a integração do Apache Kafka com o Kubernetes. Aqui estão alguns dos principais aspectos e recursos do Strimzi:

Operação em Kubernetes: O Strimzi permite que você implante clusters Kafka em um ambiente Kubernetes, aproveitando os recursos de orquestração e escalabilidade fornecidos pelo Kubernetes.

Custom Resource Definitions (CRDs): O Strimzi usa Custom Resource Definitions (CRDs) para definir e configurar recursos relacionados ao Kafka,**como brokers, tópicos e usuários**. Isso simplifica a criação e gerenciamento de clusters Kafka no Kubernetes.

Suporte a TLS e autenticação: O Strimzi oferece suporte para configuração de TLS (Transport Layer Security) e autenticação, garantindo que a comunicação dentro do cluster Kafka seja segura e protegida.

Scaling automático:  **O Strimzi facilita o dimensionamento automático dos clusters Kafka com base na demanda, permitindo que você adicione ou remova brokers conforme necessário**.

- Monitoramento e métricas: O projeto inclui suporte para métricas e monitoramento de clusters Kafka usando ferramentas como Prometheus e Grafana. Isso ajuda a manter um olho nas métricas de desempenho e saúde do cluster Kafka.

- Integração com outros projetos Kubernetes: Strimzi pode ser integrado facilmente com outros projetos do ecossistema Kubernetes, como Operators, Helm Charts e outros, para uma experiência de gerenciamento mais coesa.

- Extensibilidade: O Strimzi é altamente extensível e pode ser personalizado de acordo com as necessidades específicas do seu ambiente.


**kafka-persistent.yml**
```java=
apiVersion: kafka.strimzi.io/v1beta1 tipo: 
metadados 
Kafka : 
  nome: 
especificação de cluster simples: 
  kafka: 
    versão: 2.3.0 
    réplicas: 5 
    ouvintes: 
      simples: {} 
      tls: {} 
    configuração: 
      offsets.topic.replication.factor : 5 
      transaction.state.log.replication.factor: 5 
      transaction.state.log.min.isr: 2 
      log.message.format.version: "2.3" 
    armazenamento: 
      tipo: jbod 
      volumes: 
      - id: 0 
        tipo: persistente- tamanho da declaração 
        : 5Gi 
        deleteClaim: falso 
  zookeeper: 
    réplicas: 3 
    armazenamento: 
      tipo: tamanho da declaração persistente 
      : 5Gi 
      deleteClaim: false 
  entidadeOperator: 
    topicOperator: {} 
    userOperator: {}


```

## Login do Kubernete

### Faça login no cluster OpenShift Container Platform (OCP), crie um aplicativo de amostra do produtor e envie algumas mensagens

```cmd= 
oc execute kafka-producer -ti --image=registry.redhat.io/amq7/amq-streams-kafka-23:1.3.0 --rm=true --restart=Nunca --bin/kafka-console-producer .sh --broker-list simple-cluster-kafka-bootstrap:9092 --topic redhat-demo-topics
```


## Abra outro terminal e crie um aplicativo de amostra do consumidor para ouvir as mensagens:

```java=
 oc execute kafka-consumer -ti --image=registry.redhat.io/amq7/amq-streams-kafka-23:1.3.0 --rm=true --restart=Nunca --bin/kafka-console-consumer .sh --bootstrap-server simple-cluster-kafka-bootstrap:9092 --topic redhat-demo-topics --from-beginning
```

## 
```cmd=
oc apply -f amq-kafka-cluster.yml
```



Quick start ou Iniciando um Projeto com Kubernetes e Strimzi
https://strimzi.io/


:::