Apache Kafka Tutorial
Apache Kafka
For en definisjon på høyt nivå, la oss presentere en kort definisjon for Apache Kafka:
Apache Kafka er en distribuert, feiltolerant, horisontalt skalalbar, forpliktelseslogg.
Det var noen ord på høyt nivå om Apache Kafka. La oss forstå konseptene i detalj her.
- Distribuert: Kafka deler dataene den inneholder i flere servere, og hver av disse serverne er i stand til å håndtere forespørsler fra klienter for andelen av data den inneholder
- Feiltolerant: Kafka har ikke et eneste feilpunkt. I et SPOF -system, som en MySQL -database, hvis serveren som er vert for databasen går ned, er applikasjonen skrudd. I et system som ikke har en SPOF og består av multiuple -noder, selv om det meste av systemet går ned, er det fortsatt det samme for en sluttbruker.
- Horisontalt skalerbar: Denne typen scailing refererer til å legge til flere maskiner til eksisterende klynge. Dette betyr at Apache Kafka er i stand til å akseptere flere noder i klyngen og gi ingen nedetid for nødvendige oppgraderinger til systemet. Se på bildet nedenfor for å forstå hvilken type scailing -konsepter:
- Forplikt logg: En forpliktelseslogg er en datastruktur akkurat som en koblet liste. Den legger til hvilke meldinger som kommer til det og opprettholder alltid deres bestilling. Data kan ikke slettes fra denne loggen før en spesifisert tid er nådd for disse dataene.
Vertikal og horisontal scailing
Et tema i Apache Kafka er akkurat som en kø der meldinger er lagret. Disse meldingene lagres for en konfigurerbar mengde tid og meldingen blir ikke slettet før denne tiden er oppnådd, selv om det har blitt konsumert av alle kjente forbrukere.
Kafka er skalerbar, da det er forbrukerne som faktisk lagrer at hvilken melding ble hentet av dem sist som en 'offset' verdi. La oss se på en figur for å forstå dette bedre:
Emnehus og forbrukerforskyvning i Apache Kafka
Komme i gang med Apache Kafka
For å begynne å bruke Apache Kafka, må den installeres på maskinen. For å gjøre dette, les install Apache Kafka på Ubuntu.
Forsikre deg om at du har en aktiv Kafka -installasjon hvis du vil prøve eksempler vi presenterer senere i leksjonen.
Hvordan virker det?
Med Kafka, den Produsent applikasjoner publiserer meldinger som ankommer en kafka Node og ikke direkte til en forbruker. Fra denne Kafka -noden forbrukes meldinger av Forbruker applikasjoner.
Kafka -produsent og forbruker
Ettersom et enkelt emne kan få mye data på en gang, for å holde Kafka horisontalt skalerbart, er hvert emne delt inn i partisjoner og hver partisjon kan leve på hvilken som helst nodemaskin i en klynge. La oss prøve å presentere det:
Emnepartisjoner
Igjen holder ikke Kafka -megleren oversikt over hvilken forbruker som har konsumert hvor mange pakker med data. Det er den forbrukernes ansvar for å følge med på data det har konsumert.
Utholdenhet til disk
Kafka vedvarer meldingsregistrene den får fra produsenter på disken og holder dem ikke i minnet. Et spørsmål som kan oppstå er hvordan dette gjør ting mulig og raskt? Det var flere grunner bak dette som gjør det til en optimal måte å håndtere meldingsregistrene på:
- Kafka følger en protokoll for å gruppere meldingspostene. Produsenter produserer meldinger som også er vedvarende til disk i store biter og forbrukere forbruker disse meldingspostene i store lineære biter.
- Årsaken til at disken skriver er lineær, er at dette gjør leser raskt på grunn av svært redusert lineær disklesid.
- Lineære diskoperasjoner er optimalisert av Operativsystemer også ved å bruke teknikker av skrive-bak og LES-ALID.
- Moderne OS bruker også begrepet Pagecaching Noe som betyr at de cache noen diskdata i gratis tilgjengelig RAM.
- Ettersom Kafka vedvarer data i en enhetlig standarddata i hele strømmen fra produsent til forbruker, bruker den Null-kopioptimalisering prosess.
Datadistribusjon og replikering
Som vi studerte ovenfor at et emne er delt inn i partisjoner, blir hver meldingspost replikert på flere noder av klyngen for å opprettholde rekkefølgen og dataene til hver post i tilfelle en av noden dør.
Selv om en partisjon er replikert på flere noder, er det fortsatt en Partisjonsleder Node som applikasjoner leser og skriver data om emnet og lederen gjentar data om andre noder, som kalles som følgere av den partisjonen.
Hvis meldingsregistreringsdataene er svært viktig for en applikasjon, kan garantien for at meldingsoppføringen skal være trygg i en av nodene økes ved å øke Replikasjonsfaktor av klyngen.
Hva er dyrepasser?
ZooKeeper er en svært feiltolerant, distribuert nøkkelverdi-butikk. Apache Kafka avhenger sterkt av dyrepasser for å lagre klyngemekanikk som hjerterytmen, distribuere oppdateringer/konfigurasjoner osv.).
Det lar Kafka -meglerne abonnere på seg selv og vite når noen endring angående en partisjonsleder og nodedistribusjon har skjedd.
Produsent- og forbrukersøknader kommuniserer direkte med dyrepasser Søknad om å vite hvilken node som er partisjonslederen for et emne, slik at de kan utføre leser og skriver fra partisjonslederen.
Streaming
En strømprosessor er en hovedkomponent i en Kafka -klynge som tar en kontinuerlig strøm av meldingsregistreringsdata fra inndatamemner, behandler disse dataene og oppretter en strøm av data til å sende inn emner som kan være hva som helst, fra søppel til en database.
Det er fullt mulig å utføre enkel prosessering direkte ved hjelp av produsenten/forbruker -API -ene, men for kompleks prosessering som å kombinere strømmer, gir Kafka et integrerte Streams API -bibliotek, men vær oppmerksom på at dette API er ment å brukes i vår egen kodebase og det gjør det ikke ' T løp på en megler. Det fungerer som Consumer API og hjelper oss med å skalere ut strømbehandlingsarbeidet over flere applikasjoner.
Når skal du bruke Apache Kafka?
Som vi studerte i ovennevnte seksjoner, kan Apache Kafka brukes til å håndtere et stort antall meldingsposter som kan tilhøre et tilnærmet uendelig antall emner i systemene våre.
Apache Kafka er en ideell kandidat når det gjelder bruk av en tjeneste som kan tillate oss å følge hendelsesdrevet arkitektur i våre applikasjoner. Dette skyldes den.
Den skalerbare og distribuerte arkitekturen til Kafka gjør integrasjon med mikroservices veldig enkelt og muliggjør en applikasjon for å koble fra seg med mye forretningslogikk.
Opprette et nytt emne
Vi kan lage et testemne testing På Apache Kafka -server med følgende kommando:
Creatinig et tema
Sudo Kafka-emner.SH-Create-Zookeeper LocalHost: 2181-Replication-Factor 1
--Partisjoner 1 -tema testing
Dette er hva vi kommer tilbake med denne kommandoen:
Lag nytt Kafka -emne
Det vil bli opprettet et testemne som vi kan bekrefte med den nevnte kommandoen:
Kafka Emneopprettingsbekreftelse
Skrive meldinger om et emne
Som vi studerte tidligere, er en av APIene som er til stede i Apache Kafka Produsent API. Vi vil bruke denne API -en til å lage en ny melding og publisere til emnet vi nettopp opprettet:
Skrive melding til emnet
sudo kafka-console-produsent.SH-BROKER-LIST LocalHost: 9092-tema testing
La oss se utdataene for denne kommandoen:
Publiser melding til Kafka -emnet
Når vi trykker på tasten, vil vi se et nytt Arrow (>) -tegn som betyr at vi kan få data om data nå:
Skrive en melding
Bare skriv inn noe og trykk for å starte en ny linje. Jeg skrev inn 3 linjer med tekster:
Lesemeldinger fra emnet
Nå som vi har publisert en melding om Kafka -emnet vi opprettet, vil denne meldingen være der for litt konfigurerbar tid. Vi kan lese den nå ved hjelp av Forbruker API:
Lesemeldinger fra emnet
Sudo Kafka-Console-Consumer.SH --zookeeper Localhost: 2181 --
Emnetesting-fra-Beginning
Dette er hva vi kommer tilbake med denne kommandoen:
Kommando for å lese melding fra Kafka -emnet
Vi vil kunne se meldingene eller linjene vi har skrevet ved hjelp av produsent API som vist nedenfor:
Hvis vi skriver en ny melding ved hjelp av Produsent API, vises den også øyeblikkelig på forbrukersiden:
Publisere og forbruk samtidig
Konklusjon
I denne leksjonen så vi på hvordan vi begynner å bruke Apache Kafka, som også er en utmerket meldingsmegler og kan fungere som en spesiell datautholdenhetsenhet.