Il software open source Apache Kafka è tra le migliori soluzioni per il sal­va­tag­gio e l’ela­bo­ra­zio­ne di flussi di dati. La piat­ta­for­ma di mes­sag­gi­sti­ca e streaming, di­stri­bui­ta con la licenza Apache 2.0, convince gli utenti per la tol­le­ran­za agli errori, l’in­cre­di­bi­le sca­la­bi­li­tà e la velocità di lettura e scrittura. La base di queste ap­pli­ca­zio­ni che trattano grandi quantità di dati, nonché ca­rat­te­ri­sti­ca in­te­res­san­te, è il cluster, che permette di di­stri­bui­re e replicare i dati se­pa­ra­ta­men­te. Le diverse in­ter­fac­ce rendono possibile la co­mu­ni­ca­zio­ne con il cluster, mentre un semplice pro­to­col­lo TCP funge da base di intesa.

In questo tutorial di Kafka spie­ghia­mo i primi passi da compiere con questa ap­pli­ca­zio­ne scritta in Scala, a partire dall’in­stal­la­zio­ne di Kafka e di Apache ZooKeeper, il software ne­ces­sa­rio per il suo utilizzo.

Requisiti per l’utilizzo di Apache Kafka

Per un utilizzo ef­fi­cien­te dei cluster di Kafka è ne­ces­sa­rio lavorare con l’hardware adeguato. Il team di svi­lup­pa­to­ri consiglia l’utilizzo di pro­ces­so­ri Intel Xeon con Quad-Core e 24 Gigabyte di memoria RAM. L’elemento più im­por­tan­te è comunque avere una memoria suf­fi­cien­te per salvare in un buffer i messaggi letti e scritti da tutte le ap­pli­ca­zio­ni che hanno accesso attivo al cluster. Poiché uno dei vantaggi di Apache Kafka è proprio l’elevato flusso di dati, è di enorme im­por­tan­za scegliere dischi rigidi adeguati. La Apache Software Foun­da­tion consiglia unità hard-disk SATA (8 x 7200 UpM); per prevenire carenze di pre­sta­zio­ne si applica il principio “più dischi rigidi si hanno, meglio è”.

Anche per quel che riguarda il software bisogna ri­spet­ta­re alcune con­di­zio­ni per poter uti­liz­za­re Apache Kafka per la gestione di flussi di dati in entrata e in uscita. Per la scelta del sistema operativo, ad esempio, conviene pre­di­li­ge­re un sistema Unix come Solaris o una di­stri­bu­zio­ne Linux, visto che le piat­ta­for­me di Windows offrono un supporto limitato. Poiché Apache Kafka è scritto nel lin­guag­gio Scala compilato da Java è in­di­spen­sa­bi­le che sia in­stal­la­ta sul proprio sistema una versione più attuale possibile del Java SE De­ve­lo­p­ment Kits (JDK).

Lo stesso, tra le varie cose, contiene il run-time system di Java, in­di­spen­sa­bi­le per l’ese­cu­zio­ne delle ap­pli­ca­zio­ni Java. Un’altra com­po­nen­te ob­bli­ga­to­ria è il servizio Apache ZooKeeper, che permette la sin­cro­niz­za­zio­ne di processi ripartiti.

gZj16chk0Ss.jpg Per visualizzare questo video, sono necessari i cookie di terze parti. Puoi accedere e modificare le impostazioni dei cookie qui.

Tutorial di Apache Kafka: ecco come in­stal­la­re Kafka, ZooKeeper e Java

Nella parte pre­ce­den­te di questo tutorial di Kafka abbiamo spiegato le com­po­nen­ti software in­di­spen­sa­bi­li. Se non ancora presente sul vostro sistema, conviene partire dall’in­stal­la­zio­ne del run-time system di Java. Molte versioni ag­gior­na­te di di­stri­bu­zio­ni Linux, come Ubuntu, che in questo tutorial di Apache Kafka funge da sistema operativo di esempio (versione 17.10), con OpenJDK hanno già a di­spo­si­zio­ne un’im­ple­men­ta­zio­ne JDK gratuita nel re­po­si­to­ry ufficiale del pacchetto. Potrete in­stal­la­re fa­cil­men­te il kit di Java at­tra­ver­so quest’ultimo, inserendo nel terminale il seguente comando:

sudo apt-get install openjdk-8-jdk

Non appena conclusa l’in­stal­la­zio­ne di Java, potrete pro­se­gui­re con l’in­stal­la­zio­ne del servizio di sin­cro­niz­za­zio­ne dei processi Apache ZooKeeper. Anche per quest’ultimo, il re­po­si­to­ry di Ubuntu mette a di­spo­si­zio­ne un pacchetto pronto all’uso ese­gui­bi­le con l’in­ter­fac­cia a riga di comando che segue:

sudo apt-get install zookeeperd

Con un altro comando potrete infine ve­ri­fi­ca­re se il servizio ZooKeeper è attivo:

sudo systemctl status zookeeper

Se Apache ZooKeeper funziona, il risultato apparirà come segue:

Se il sistema di sin­cro­niz­za­zio­ne non funziona, potrete avviarlo in qualsiasi momento con questo comando:

sudo systemctl start zookeeper

Per far partire au­to­ma­ti­ca­men­te ZooKeeper all’avvio del sistema, potete inserire ancora una voce di autostart:

sudo systemctl enable zookeeper

Infine potrete creare un profilo utente di Kafka, in­di­spen­sa­bi­le per il suc­ces­si­vo utilizzo del server. Riaprite nuo­va­men­te il terminale e inserite il seguente comando:

sudo useradd kafka -m

Con l’ausilio del password manager passwd potrete ag­giun­ge­re una password abbinata all’utente, inserendo il seguente comando seguito dalla password de­si­de­ra­ta:

sudo passwd kafka

Nella prossima fase potrete assegnare all’utente “kafka” i diritti sudo:

sudo adduser kafka sudo

Potrete eseguire il log in qualsiasi momento uti­liz­zan­do il profilo utente appena creato:

su – kafka

A questo punto del tutorial è arrivato il momento di scaricare e in­stal­la­re Kafka. Svariate fonti af­fi­da­bi­li per­met­to­no di scaricare sia le vecchie versioni che le più recenti del software di streaming ed ela­bo­ra­zio­ne. Di prima mano ri­ce­ve­re­te di­ret­ta­men­te i dati di in­stal­la­zio­ne, ad esempio at­tra­ver­so questa cartella di download della Apache Software Foun­da­tion. È altamente con­si­glia­to lavorare con una versione ag­gior­na­ta di Kafka, per cui dovrete even­tual­men­te adattare il seguente comando di download prima dell’in­se­ri­men­to nel terminale:

wget http://www.apache.org/dist/kafka/2.1.0/kafka_2.12-2.1.0.tgz

Poiché i file scaricati sono in formato compresso, nella prossima fase dovrete prima estrarli:

sudo tar xvzf kafka_2.12-2.1.0.tgz --strip 1

Con l’aiuto del parametro “--strip 1” as­si­cu­ra­te­vi che i file estratti vengano salvati di­ret­ta­men­te nella cartella “~/kafka”. In caso contrario, sulla base della versione uti­liz­za­ta in questo tutorial di Kafka, Ubuntu sal­ve­reb­be tutti i dati nella cartella “~/kafka/kafka_2.12-2.1.0”. Prima però, con l'ausilio di mkdir, bisogna creare una cartella de­no­mi­na­ta “kafka” e averla cambiata (mediante “cd kafka”).

Kafka: tutorial per la con­fi­gu­ra­zio­ne del sistema di streaming e mes­sag­gi­sti­ca

Dopo aver in­stal­la­to Apache Kafka e sia il run-time system di Java che ZooKeeper, dovreste poter eseguire in ogni momento il servizio di Kafka. Ma prima dovrete ef­fet­tua­re ancora alcune piccole con­fi­gu­ra­zio­ni affinché il software sia impostato in maniera ottimale per i compiti suc­ces­si­vi.

Attivare l’eli­mi­na­zio­ne di topic

Kafka permette, non nell’in­stal­la­zio­ne standard però, di eliminare i topic, ossia le unità di sal­va­tag­gio e ca­te­go­riz­za­zio­ne di un cluster di Kafka. È possibile ef­fet­tua­re questa modifica fa­cil­men­te nel file di con­fi­gu­ra­zio­ne di Kafka server.pro­per­ties. Basta aprire questo file, che si trova nella cartella “config” con il seguente comando da terminale nell’editor di testo standard nano:

sudo nano ~/kafka/config/server.properties

Alla fine di questo file di con­fi­gu­ra­zio­ne inserite una nuova voce che permette l’eli­mi­na­zio­ne di topic di Kafka:

delete.topic.enable=true
Consiglio

Non di­men­ti­ca­te di salvare la nuova voce nel file di con­fi­gu­ra­zio­ne di Kafka, prima di chiudere l’editor nano!

Creare file .service per ZooKeeper e Kafka

Nella prossima fase di questo tutorial di Kafka, im­pa­re­re­te a creare file Unit per ZooKeeper e Kafka che per­met­to­no di eseguire azioni ordinarie come l’avvio, lo spe­gni­men­to e il riavvio di entrambi i servizi in maniera conforme su altri servizi Linux. Per questo è in­di­spen­sa­bi­le creare e impostare per entrambe le ap­pli­ca­zio­ni file .service per la suite di am­mi­ni­stra­zio­ne systemd.

Creare il file ZooKeeper cor­ri­spon­den­te per la suite di am­mi­ni­stra­zio­ne systemd di Ubuntu

Dopo potete creare il file per il servizio di sin­cro­niz­za­zio­ne di ZooKeeper, inserendo nel terminale il seguente comando:

sudo nano /etc/systemd/system/zookeeper.service

Così non viene soltanto creato il file, ma anche aperto subito nell’editor nano. Inserite le righe seguenti e salvate il file alla fine:

[Unit]
Requires=network.target remote-fs.target
After=network.target remote-fs.target
[Service]
Type=simple
User=kafka
ExecStart=/home/kafka/kafka/bin/zookeeper-server-start.sh /home/kafka/kafka/config/zookeeper.properties
ExecStop=/home/kafka/kafka/bin/zookeeper-server-stop.sh
Restart=on-abnormal
[Install]
WantedBy=multi-user.target

Per questo motivo systemd è nella posizione di com­pren­de­re che ZooKeeper può essere riavviato soltanto quando la rete e il file di sistema sono pronti, come definito nella sezione [Unit]. Nel [Service] viene spe­ci­fi­ca­to che la suite di am­mi­ni­stra­zio­ne deve uti­liz­za­re i file zookeeper-server-start.sh ozookeeper-server-stop.sh per l'avvio o l'arresto di ZooKeeper. Dopo viene definito un riavvio au­to­ma­ti­co per i casi di in­ter­ru­zio­ne in­vo­lon­ta­ria del servizio. La voce [Install] regola quando avviare il file, mentre “multi-user.target” rap­pre­sen­ta il valore standard per un sistema con più utenti (per es. un server).

Creare un file Kafka per la suite di am­mi­ni­stra­zio­ne systemd di Ubuntu

Create il file .service per Apache Kafka con il seguente comando da terminale:

sudo nano /etc/systemd/system/kafka.service

Infine ricopiate il seguente contenuto nel nuovo file, già aperto nell’editor nano:

[Unit]
Requires=zookeeper.service
After=zookeeper.service
[Service]
Type=simple
User=kafka
ExecStart=/bin/sh -c '/home/kafka/kafka/bin/kafka-server-start.sh /home/kafka/kafka/config/server.properties > /home/kafka/kafka/kafka.log 2>&1'
ExecStop=/home/kafka/kafka/bin/kafka-server-stop.sh
Restart=on-abnormal
[Install]
WantedBy=multi-user.target

Nel reparto [Unit] di questo file viene spe­ci­fi­ca­ta la di­pen­den­za dei servizi di Kafka da ZooKeeper. In questo modo viene as­si­cu­ra­to che il servizio di sin­cro­niz­za­zio­ne potrà avviarsi soltanto al momento del­l'e­se­cu­zio­ne del file kafka.service. Nel[Service] sono inseriti i file della Shell kafka-server-start.sh e kafka-server-stop.sh per l'avvio o l'arresto del server di Kafka. In questo file si trovano anche la voce del riavvio au­to­ma­ti­co dopo una pre­ce­den­te in­ter­ru­zio­ne della con­nes­sio­ne e del sistema multi-utente.

Kafka: primo avvio e creazione di una voce di avvio au­to­ma­ti­co

Dopo aver creato con successo le voci della suite di am­mi­ni­stra­zio­ne per Kafka e ZooKeeper, potrete avviare Kafka come segue:

sudo systemctl start kafka

Il programma systemd utilizza di base un pro­to­col­lo centrale, ossia un journal, in cui vengono scritte au­to­ma­ti­ca­men­te tutte le notifiche di log. In questo modo potrete ve­ri­fi­ca­re fa­cil­men­te se il server di Kafka è stato avviato come de­si­de­ra­to:

sudo journalctl -u kafka

L’output dovrebbe avere più o meno questo aspetto:

Se l’avvio manuale di Apache Kafka funziona, potete attivare infine ancora l’avvio au­to­ma­ti­co nel boot di sistema:

sudo systemctl enable kafka

Primi passi con Apache Kafka

Per testare Apache Kafka a questo punto del tutorial va elaborato un primo messaggio con l’aiuto della piat­ta­for­ma di mes­sag­gi­sti­ca. A tal fine avrete bisogno di un pro­dut­to­re e di un con­su­ma­to­re, ossia di un’istanza che permetta la scrittura e la pub­bli­ca­zio­ne di dati in topic e di un’istanza che permetta di leggere i dati di un topic. Create prima di tutto il topic, che in questo caso dovrà contenere il nome Tu­to­rial­To­pic. Poiché si tratta di un semplice topic di prova, dovrà contenere soltanto una singola par­ti­zio­ne e una singola replica.

> bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic TutorialTopic

Suc­ces­si­va­men­te dovrete creare un pro­dut­to­re che inserirà nel topic appena creato il primo messaggio di prova “Ciao mondo!”. Per questo scopo uti­liz­ze­re­te lo script di Shell kafka-console-producer.sh, che prevede il nome dell’host e la porta del server (nell’esempio: percorso standard di Kafka) e anche il nome del topic come argomento:

echo "ciao mondo!" | ~/kafka/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic TutorialTopic > /dev/null

Con l'aiuto dello script kafka-console-consumer.sh create infine un con­su­ma­to­re di Kafka, che rielabora e riporta i messaggi del Tu­to­rial­To­pic. Come argomenti sono richiesti il nome dell’host, la porta del server di Kafka e il nome del topic. Inoltre viene allegato l’argomento “--from-beginning”, affinché il messaggio “Ciao mondo!”, pub­bli­ca­to in questo caso ancora prima dell’avvio da parte del con­su­ma­to­re, possa essere anche elaborato da quest’ultimo:

> bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic TutorialTopic--from-beginning

Come con­se­guen­za, il terminale presenta il messaggio “ciao mondo!”, in cui lo script continua a fun­zio­na­re in attesa di altri messaggi, che verranno pub­bli­ca­ti nel topic di prova. Quindi at­tra­ver­so il pro­dut­to­re potrete occuparvi di altri dati in uscita in un’altra finestra del terminale, che dovreste vi­sua­liz­za­re anche nella finestra del terminale in cui viene eseguito lo script del con­su­ma­to­re.

Vai al menu prin­ci­pa­le