Microservice-orienterade designmönster har gjort våra applikationer mer skalbara än någonsin. RESTful API-servrar, frontend och till och med databaserna är nu skalbara. Horisontell skalning är att lägga till nya noder i ditt applikationskluster för att stödja ytterligare arbetsbelastning. Omvänt tillåter det också att minska resursförbrukningen när arbetsbelastningen minskar för att spara kostnader. Horisontellt skalbara system måste distribueras. Dessa system som kan överleva fel på flera virtuella datorer, behållare eller nätverkslänkar och fortfarande är online och friska för slutanvändaren.

När vi pratar om distribuerade system som ovan, stöter vi på problemet med analys och övervakning. Varje nod genererar mycket information om sin egen hälsa (CPU-användning, minne, etc.) och om applikationsstatus tillsammans med vad användarna försöker göra. Dessa uppgifter måste registreras i:

1. Samma ordning som de skapas i,
2. Separerad när det gäller brådskande (realtidsanalys eller batcher av data), och viktigast av allt,
3. Mekanismen som de samlas in måste i sig vara distribuerad och skalbar, annars sitter vi kvar med en enda felpunkt. Något som det distribuerade systemdesignen skulle undvika.

Varför använda Kafka?

Apache Kafka presenteras som en distribuerad streamingplattform. I Kafka lingo, Producenter generera kontinuerligt data (strömmar) och Konsumenter ansvarar för bearbetning, lagring och analys av den. Kafka Mäklare ansvarar för att data i ett distribuerat scenario kan nå från producenter till konsumenter utan inkonsekvens. En uppsättning Kafka-mäklare och en annan programvara som heter djurhållare utgör en typisk Kafka-distribution.

Dataströmmen från många producenter måste samlas, partitioneras och skickas till flera konsumenter, det är mycket blandning involverad. Att undvika inkonsekvens är inte en lätt uppgift. Det är därför vi behöver Kafka.

Scenarierna där Kafka kan användas är ganska olika. Allt från IOT-enheter till kluster av virtuella datorer till dina egna lokala metallservrar. Var som helst där många "saker" samtidigt vill ha din uppmärksamhet .. .Det är inte särskilt vetenskapligt? Kafka-arkitekturen är ett eget kaninhål och förtjänar en oberoende behandling. Låt oss först se en mycket ytlig nivå distribution av programvaran.

Använda Docker Compose

Oavsett vilket fantasifullt sätt du bestämmer dig för att använda Kafka, är en sak säker - du kommer inte att använda den som en enda instans. Det är inte tänkt att användas på det sättet, och även om din distribuerade app bara behöver en instans (mäklare) för tillfället kommer den så småningom att växa och du måste se till att Kafka kan hålla jämna steg.

Docker-compose är den perfekta partnern för denna typ av skalbarhet. Istället för att köra Kafka-mäklare på olika virtuella datorer containeriserar vi den och utnyttjar Docker Compose för att automatisera distribution och skalning. Docker-behållare är mycket skalbara på både enskilda Docker-värdar och över ett kluster om vi använder Docker Swarm eller Kubernetes. Så det är vettigt att utnyttja det för att göra Kafka skalbar.

Låt oss börja med en enda instans av mäklare. Skapa en katalog som heter apache-kafka och inuti den skapar du din docker-compose.yml.

$ mkdir apache-kafka
$ cd apache-kafka
$ vim docker-compose.yml

Följande innehåll kommer att läggas i din docker-compose.yml-fil:

version: '3'
tjänster:
djurhållare:
bild: wurstmeister / zooeeper
 
kafka:
bild: wurstmeister / kafka
hamnar:
- "9092: 9092"
miljö:
KAFKA_ADVERTISED_HOST_NAME: lokal värd
KAFKA_ZOOKEEPER_CONNECT: djurhållare: 2181

När du har sparat ovanstående innehåll i din komponeringsfil, från samma katalogkörning:

$ docker-compose up -d

Okej, så vad gjorde vi här?

Förstå Docker-Compose.yml

Compose startar två tjänster som anges i yml-filen. Låt oss titta på filen lite noggrant. Den första bilden är zooeeper som Kafka behöver för att hålla reda på olika mäklare, nätverkstopologin samt synkronisera annan information. Eftersom både zookeeper- och kafka-tjänster kommer att vara en del av samma bryggnätverk (detta skapas när vi kör docker-compose up) behöver vi inte exponera några portar. Kafka-mäklare kan prata med djurhållaren och det är all kommunikation som djurparken behöver.

Den andra tjänsten är kafka i sig och vi kör bara en enda instans av det, det vill säga en mäklare. Helst vill du använda flera mäklare för att utnyttja Kafkas distribuerade arkitektur. Tjänsten lyssnar på port 9092 som är mappad på samma portnummer på Docker Host och så kommunicerar tjänsten med omvärlden.

Den andra tjänsten har också ett par miljövariabler. För det första är KAFKA_ADVERTISED_HOST_NAME inställd på localhost. Det här är adressen Kafka kör och där producenter och konsumenter kan hitta den. Återigen bör detta vara inställt på localhost utan snarare till IP-adressen eller värdnamnet med detta kan servrarna nås i ditt nätverk. För det andra är värdnamnet och portnumret för din djurparktjänst. Eftersom vi namngav zookeeper-tjänsten ... ja, zookeeper är det som värdnamnet kommer att bli, inom docker bridge-nätverket som vi nämnde.

Kör ett enkelt meddelandeflöde

För att Kafka ska kunna börja arbeta måste vi skapa ett ämne inom det. Producentklienterna kan sedan publicera dataströmmar (meddelanden) till nämnda ämne och konsumenter kan läsa nämnda dataström om de prenumererar på just det ämnet.

För att göra detta måste vi starta en interaktiv terminal med Kafka-containern. Lista behållarna för att hämta kafka-behållarens namn. I det här fallet heter till exempel vår container apache-kafka_kafka_1

$ docker ps

Med kafka containerns namn kan vi nu släppa in i denna container.

$ docker exec -it apache-kafka_kafka_1 bash
bash-4.4 #

Öppna två olika terminaler för att använda en som konsument och en annan producent.

Producentsida

I en av anvisningarna (den du väljer att vara producent) anger du följande kommandon:

## Skapa ett nytt ämne med namnet test
bash-4.4 # kafka-ämnen.sh --create --zookeeper zookeeper: 2181 --replikationsfaktor 1
--partitioner 1 - ämnetest
 
## Att starta en producent som publicerar dataström från standardinmatning till kafka
bash-4.4 # kafka-konsol-producent.sh --broker-list localhost: 9092 - ämnesprov
>

Producenten är nu redo att ta in input från tangentbordet och publicera det.

Konsumentens sida

Gå vidare till den andra terminalen som är ansluten till din kafka-container. Följande kommando startar en konsument som matar testämnet:

$ kafka-konsol-konsument.sh --bootstrap-server localhost: 9092 --topiskt test

Tillbaka till producent

Du kan nu skriva meddelanden i den nya prompten och varje gång du trycker på retur skrivs den nya raden ut i konsumentprompten. Till exempel:

> Detta är ett meddelande.

Detta meddelande överförs till konsumenten via Kafka och du kan se det skrivas ut vid konsumentprompten.

Verkliga inställningar

Du har nu en grov bild av hur Kafka-installationen fungerar. För ditt eget användningsfall måste du ställa in ett värdnamn som inte är localhost, du behöver flera sådana mäklare för att vara en del av ditt kafka-kluster och slutligen måste du ställa in konsument- och producentklienter.

Här är några användbara länkar:

1. Confluents Python Client
2. Officiell dokumentation
3. En användbar lista med demos

Jag hoppas att du har kul att utforska Apache Kafka.