Tutorial Apache Kafka

In questa lezione vedremo come possiamo usare Apache Kafka e qual è il suo uso. Esamineremo a fondo varie terminologie coinvolte e inizieremo anche a lavorare con loro.

Apache Kafka

Per una definizione di alto livello, presentiamo una breve definizione per Apache Kafka:

Apache Kafka è un registro distribuito, tollerante ai guasti, in modo orizzontale.

Quelle erano alcune parole di alto livello su Apache Kafka. Comprendiamo i concetti in dettaglio qui.

• Distribuito: Kafka divide i dati che contiene in più server e ciascuno di questi server è in grado di gestire le richieste dai clienti per la condivisione dei dati che contiene
• Tollerante agli errori: Kafka non ha un singolo punto di fallimento. In un sistema SPOF, come un database MySQL, se il server che ospita il database diminuisce, l'applicazione viene avvitata. In un sistema che non ha uno spof ed è costituito da nodi multiuppla, anche se la maggior parte del sistema diminuisce, è sempre lo stesso per un utente finale.
• Scalabile orizzontalmente: Questo tipo di asciugatura si riferisce all'aggiunta di più macchine al cluster esistente. Ciò significa che Apache Kafka è in grado di accettare più nodi nel suo cluster e non fornire tempo di inattività per gli aggiornamenti richiesti al sistema. Guarda l'immagine qui sotto per comprendere il tipo di concetti di asciugatura:

Scailing verticale e orizzontale

• Commit log: Un registro di commit è una struttura di dati proprio come un elenco collegato. Aggiunge qualsiasi messaggio ci venga e mantiene sempre il loro ordine. I dati non possono essere eliminati da questo registro fino a quando non viene raggiunto un tempo specificato per tali dati.

Un argomento in Apache Kafka è proprio come una coda in cui vengono archiviati i messaggi. Questi messaggi sono archiviati per una quantità di tempo configurabile e il messaggio non viene eliminato fino a quando questo momento non viene raggiunto, anche se è stato consumato da tutti i consumatori noti.

Kafka è scalabile in quanto sono i consumatori che in realtà immagazzinano che quale messaggio è stato recuperato da loro dura come un valore di "offset". Diamo un'occhiata a una figura per capirlo meglio:

Argomento Partizione e offset del consumatore in Apache Kafka

Iniziare con Apache Kafka

Per iniziare a utilizzare Apache Kafka, deve essere installato sulla macchina. Per fare questo, leggi Installa Apache Kafka su Ubuntu.

Assicurati di avere un'installazione attiva Kafka se vuoi provare esempi che presentiamo più avanti nella lezione.

Come funziona?

Con Kafka, il Produttore Pubblica applicazioni messaggi che arriva a un kafka Nodo e non direttamente a un consumatore. Da questo nodo Kafka, i messaggi vengono consumati dal Consumatore applicazioni.

Produttore e consumatore Kafka

Poiché un singolo argomento può ottenere molti dati a un certo punto, per mantenere Kafka orizzontalmente scalabile, ogni argomento è diviso in partizioni e ogni partizione può vivere su qualsiasi macchina da nodo di un cluster. Cerchiamo di presentarlo:

Partizioni di argomento

Ancora una volta, il broker Kafka non tiene traccia di quale consumatore ha consumato quanti pacchetti di dati. È il responsabilità dei consumatori per tenere traccia dei dati che ha consumato.

Persistenza al disco

Kafka persiste che il messaggio registra dai produttori sul disco e non li tiene nella memoria. Una domanda che potrebbe sorgere è come questo renda le cose fattibili e veloci? Ci sono stati diversi motivi dietro questo che lo rendono un modo ottimale di gestire i record dei messaggi:

• Kafka segue un protocollo per raggruppare i record dei messaggi. I produttori producono messaggi che sono persistiti sul disco in blocchi di grandi dimensioni e i consumatori consumano anche questi record di messaggi in grandi pezzi lineari.
• Il motivo per cui il disco scrive è lineare è che questo rende le letture rapide a causa del tempo di lettura del disco lineare molto ridotto.
• Le operazioni del disco lineare sono ottimizzate da Sistemi operativi anche mediante tecniche di Write-Behind E Read-ahead.
• Il sistema operativo moderno usa anche il concetto di Pagecaching Ciò significa che memorizzano nella cache alcuni dati del disco nella RAM gratuita.
• Poiché Kafka persiste i dati in dati standard uniformi nell'intero flusso dal produttore fino al consumatore, utilizza il Ottimizzazione a copia zero processi.

Distribuzione e replica dei dati

Come abbiamo studiato sopra che un argomento è diviso in partizioni, ogni record del messaggio viene replicato su più nodi del cluster per mantenere l'ordine e i dati di ciascun record nel caso in cui uno dei nodi muoia.

Anche se una partizione viene replicata su più nodi, esiste ancora un leader della partizione nodo attraverso il quale le applicazioni leggono e scrivono i dati sull'argomento e il leader replica i dati su altri nodi, che sono definiti come seguaci di quella partizione.

Se i dati del record del messaggio sono altamente importanti per un'applicazione, la garanzia del record del messaggio sarà aumentata in uno dei nodi aumentando il fattore di replica del cluster.

Cos'è lo zookeeper?

Zookeeper è un negozio di valore chiave distribuito altamente tollerante ai guasti. Apache Kafka dipende pesantemente dallo zookeeper per archiviare meccanici di cluster come il battito cardiaco, distribuire aggiornamenti/configurazioni, ecc.).

Permette ai broker Kafka di iscriversi a se stessi e sapere ogni volta che si verifica un cambiamento relativo a un leader di partizione e distribuzione dei nodi.

Le applicazioni produttrici e consumatori comunicano direttamente con lo zookeeper Applicazione per sapere quale nodo è il leader della partizione per un argomento in modo che possano eseguire letture e scritture dal leader della partizione.

Streaming

Un processore di flusso è un componente principale in un cluster Kafka che prende un flusso continuo di dati di registrazione dei messaggi da argomenti di input, elabora questi dati e crea un flusso di dati per output che possono essere qualsiasi cosa, dalla spazzatura a un database.

È completamente possibile eseguire una semplice elaborazione direttamente utilizzando le API produttrici/consumatori, sebbene per elaborazioni complesse come la combinazione di flussi, Kafka fornisce una libreria API di flussi integrata, ma si prega di notare che questa API è pensata per essere utilizzata all'interno della nostra base di codice e non è T Run su un broker. Funziona in modo simile all'API del consumatore e ci aiuta a scalare il lavoro di elaborazione del flusso su più applicazioni.

Quando usare Apache Kafka?

Come abbiamo studiato nelle sezioni sopra, Apache Kafka può essere utilizzata per gestire un gran numero di record di messaggi che possono appartenere a un numero praticamente infinito di argomenti nei nostri sistemi.

Apache Kafka è un candidato ideale quando si tratta di utilizzare un servizio che può consentirci di seguire l'architettura basata su eventi nelle nostre applicazioni. Ciò è dovuto alle sue capacità di persistenza dei dati, all'architettura tollerante e altamente distribuita in cui le applicazioni critiche possono fare affidamento sulle sue prestazioni.

L'architettura scalabile e distribuita di Kafka rende molto semplice l'integrazione con i microservizi e consente a un'applicazione di disaccoppiarsi con molta logica aziendale.

Creazione di un nuovo argomento

Possiamo creare un argomento di prova Test sul server Apache Kafka con il seguente comando:

Crea un argomento

sudo kafka-topics.SH --Create-Zookeeper Localhost: 2181-Reflition-Factor 1
--Partizioni 1 -Test del topio

Ecco cosa torniamo con questo comando:

Crea nuovo argomento Kafka

Verrà creato un argomento di test che possiamo confermare con il comando menzionato:

Conferma della creazione di argomenti di Kafka

Scrivere messaggi su un argomento

Come abbiamo studiato in precedenza, una delle API presenti in Apache Kafka è il API produttore. Useremo questa API per creare un nuovo messaggio e pubblicare sull'argomento che abbiamo appena creato:

Scrivere un messaggio all'argomento

sudo kafka-tumole-produttore.SH-Locale-list-list: 9092-Test-topic

Vediamo l'output per questo comando:

Pubblica il messaggio all'argomento Kafka

Una volta che premiamo il tasto, vedremo un nuovo segno freccia (>) che significa che possiamo inout dati ora:

Digitando un messaggio

Basta digitare qualcosa e premere per avviare una nuova riga. Ho digitato 3 righe di testi:

Leggere i messaggi dall'argomento

Ora che abbiamo pubblicato un messaggio sull'argomento Kafka che abbiamo creato, questo messaggio sarà lì per un po 'di tempo configurabile. Possiamo leggerlo ora usando il API del consumatore:

Leggere i messaggi dall'argomento

sudo kafka-consumatore-consumatore.SH --Zookeeper Localhost: 2181 --
Test dell'argomento-From-Beginning

Ecco cosa torniamo con questo comando:

Comanda di leggere il messaggio da Kafka Topic

Saremo in grado di vedere i messaggi o le righe che abbiamo scritto usando l'API del produttore come mostrato di seguito:

Se scriviamo un altro nuovo messaggio usando l'API del produttore, verrà visualizzato immediatamente sul lato del consumatore:

Pubblica e consumo allo stesso tempo

Conclusione

In questa lezione, abbiamo esaminato come iniziamo a usare Apache Kafka che è un eccellente broker di messaggi e possiamo anche fungere da unità speciale di persistenza di dati di dati.