Ինչպես կառուցել Scalable Data Architecture Apache Kafka-ի հետ

Պատկեր հեղինակի կողմից

Apache Kafka-ն հաղորդագրությունների փոխանցման բաշխված համակարգ է, որն աշխատում է հրատարակիչ-բաժանորդ մոդելի վրա: Այն մշակվել է Apache Software Foundation-ի կողմից և գրված է Java և Scala լեզուներով: Կաֆկան ստեղծվել է ավանդական հաղորդագրությունների փոխանցման համակարգերի բաշխման և մասշտաբայնության հետ կապված խնդիրը հաղթահարելու համար: Այն կարող է կառավարել և պահել մեծ ծավալի տվյալներ՝ նվազագույն ուշացումով և բարձր թողունակությամբ: Այս առավելությունների շնորհիվ այն կարող է հարմար լինել իրական ժամանակում տվյալների մշակման հավելվածներ և հոսքային ծառայություններ ստեղծելու համար: Այն ներկայումս բաց կոդով է և օգտագործվում է բազմաթիվ կազմակերպությունների կողմից, ինչպիսիք են Netflix-ը, Walmart-ը և Linkedin-ը:

Հաղորդագրությունների փոխանցման համակարգը ստիպում է մի քանի հավելվածներ ուղարկել կամ ստանալ տվյալներ միմյանցից՝ առանց անհանգստանալու տվյալների փոխանցման և փոխանակման մասին: Կետ առ կետ և Հրատարակիչ-բաժանորդ հաղորդագրությունների փոխանցման երկու տարածված համակարգեր են: Կետ առ կետ, ուղարկողը տվյալները մղում է հերթ, և ստացողը դուրս է գալիս դրանից, ինչպես ստանդարտ հերթերի համակարգ՝ հետևելով FIFO (առաջին մուտքը, առաջինը դուրս) սկզբունքին: Բացի այդ, տվյալները կջնջվեն կարդալուց հետո, և միաժամանակ թույլատրվում է միայն մեկ ընդունիչ: Ստացողի համար հաղորդագրությունը կարդալու ժամանակային կախվածություն չկա:

Ինչպես կառուցել Scalable Data Architecture Apache Kafka-ի հետ

Նկ.1 Կետ առ կետ հաղորդագրությունների համակարգ | Պատկեր հեղինակի կողմից

Հրատարակիչ-բաժանորդ մոդելում ուղարկողը կոչվում է հրատարակիչ, իսկ ստացողը` բաժանորդ: Այս դեպքում բազմաթիվ ուղարկողներ և ստացողներ կարող են միաժամանակ կարդալ կամ գրել տվյալներ: Բայց դրա մեջ ժամանակային կախվածություն կա։ Սպառողը պետք է սպառի հաղորդագրությունը որոշակի ժամանակից շուտ, քանի որ դրանից հետո այն ջնջվում է, նույնիսկ եթե այն չի կարդացվել: Կախված օգտագործողի կազմաձևից՝ այս ժամկետը կարող է լինել մեկ օր, մեկ շաբաթ կամ մեկ ամիս:

Նկ.2 Հրատարակիչ-բաժանորդների հաղորդագրությունների համակարգ | Պատկեր հեղինակի կողմից

Կաֆկայի ճարտարապետությունը բաղկացած է մի քանի հիմնական բաղադրիչներից.

Թեմա
Միջնորմ
Բրոքեր
Պրոդյուսեր
Սպառող
Կաֆկա-Կլաստեր
Կենդանաբանական այգու պահապան

Նկ.3 Կաֆկա ճարտարապետություն | Պատկերը՝ ibm-cloud-architecture-ի կողմից

Եկեք համառոտ հասկանանք յուրաքանչյուր բաղադրիչ:

Կաֆկան հաղորդագրությունները պահում է տարբեր ձևերով Թեմաներ. Թեման խումբ է, որը պարունակում է որոշակի կատեգորիայի հաղորդագրություններ: Այն նման է տվյալների բազայի աղյուսակին: Թեման կարելի է եզակիորեն նույնացնել իր անունով: Մենք չենք կարող նույն անունով երկու թեմա ստեղծել։

Թեմաները հետագայում դասակարգվում են Միջնորմներ. Այս բաժանմունքների յուրաքանչյուր գրառում կապված է եզակի նույնացուցիչի հետ, որը կոչվում է Օֆսեթորը նշանակում է գրառումի դիրքն այդ բաժանման մեջ։

Բացի սրանից, համակարգում կան Արտադրողներ և Սպառողներ: Արտադրողները գրում կամ հրապարակում են տվյալները թեմաներում՝ օգտագործելով Արտադրող API-ները: Այս արտադրողները կարող են գրել կամ թեմայի կամ բաժանման մակարդակներում:

Սպառողները կարդում կամ սպառում են թեմաների տվյալները՝ օգտագործելով Սպառողների API-ները: Նրանք կարող են նաև կարդալ տվյալները թեմայի կամ բաժանման մակարդակներում: Սպառողները, ովքեր կատարում են նմանատիպ առաջադրանքներ, կկազմեն խումբ, որը հայտնի է որպես Սպառողների խումբ.

Կան այլ համակարգեր, ինչպիսիք են Բրոքեր և Կենդանաբանական այգու պահապան, որոնք աշխատում են Kafka սերվերի ֆոնին: Բրոքերները այն ծրագրաշարն են, որը պահպանում և պահպանում է հրապարակված հաղորդագրությունների գրառումները: Այն նաև պատասխանատու է ճիշտ հաղորդագրությունը ճիշտ սպառողին հասցնելու համար՝ օգտագործելով օֆսեթները: Բրոքերների հավաքածուն, որոնք կոլեկտիվորեն հաղորդակցվում են միմյանց հետ, կարելի է անվանել Կաֆկայի կլաստերներ. Բրոքերները կարող են դինամիկ կերպով ավելացվել կամ հեռացվել Կաֆկա կլաստերից՝ առանց համակարգում որևէ ընդհատման: Իսկ Կաֆկա կլաստերի բրոքերներից մեկը կոչվում է a Վերահսկիչ. Այն կառավարում է վիճակները և կրկնօրինակները կլաստերի ներսում և կատարում վարչական առաջադրանքներ:

Մյուս կողմից, Zookeeper-ը պատասխանատու է Կաֆկա կլաստերի առողջական վիճակի պահպանման և այդ կլաստերի յուրաքանչյուր բրոքերի հետ համակարգելու համար: Այն պահպանում է յուրաքանչյուր կլաստերի մետատվյալները բանալի-արժեք զույգերի տեսքով:

Այս ձեռնարկը հիմնականում կենտրոնացած է Apache Kafka-ի գործնական իրականացման վրա: Եթե ցանկանում եք ավելին կարդալ նրա ճարտարապետության մասին, կարող եք կարդալ Upsolver-ի այս հոդվածը:

Հաշվի առեք տաքսիների ամրագրման ծառայության օգտագործման դեպքը, ինչպիսին Uber-ն է: Այս հավելվածն օգտագործում է Apache Kafka-ն՝ հաղորդագրություններ ուղարկելու և ստանալու համար տարբեր ծառայությունների միջոցով, ինչպիսիք են Գործարքները, Էլփոստերը, Վերլուծությունը և այլն:

Նկ.4 Տաքսի հավելվածի ճարտարապետություն | Պատկեր հեղինակի կողմից

Ճարտարապետությունը բաղկացած է մի քանի ծառայություններից. Այն Rides ծառայությունը հաճախորդից ստանում է ուղևորության հարցումը և գրում է ուղևորության մանրամասները Կաֆկա հաղորդագրությունների համակարգում:

Այնուհետև այս պատվերի մանրամասները կարդացվեցին Հ Transaction ծառայություն, որը հաստատում է պատվերի և վճարման կարգավիճակը: Այդ շրջագայությունը հաստատելուց հետո սա Transaction ծառայությունը կրկին գրում է հաստատված ուղևորությունը հաղորդագրությունների համակարգում՝ որոշ լրացուցիչ մանրամասներով: Եվ վերջապես, հաստատված երթևեկության մանրամասները կարդում են այլ ծառայություններ, ինչպիսիք են Էլփոստը կամ տվյալների վերլուծությունը, հաճախորդին հաստատման նամակ ուղարկելու և դրա վրա որոշակի վերլուծություն կատարելու համար:

Մենք կարող ենք իրական ժամանակում իրականացնել այս բոլոր գործընթացները՝ շատ բարձր թողունակությամբ և նվազագույն ուշացումով: Բացի այդ, Apache Kafka-ի հորիզոնական մասշտաբավորման հնարավորության շնորհիվ մենք կարող ենք այս հավելվածը մեծացնել միլիոնավոր օգտատերերի համար:

Այս բաժինը պարունակում է արագ ձեռնարկ՝ մեր հավելվածում կաֆկա հաղորդագրությունների համակարգը կիրառելու համար: Այն ներառում է kafka-ն ներբեռնելու, այն կարգավորելու և արտադրող-սպառող գործառույթներ ստեղծելու քայլերը:

Նշում: Այս ձեռնարկը հիմնված է python ծրագրավորման լեզվի վրա և օգտագործում է Windows մեքենա:

Apache Kafka Ներբեռնման քայլեր

1. Ներբեռնեք Apache Kafka-ի վերջին տարբերակը այդ հղումից: Kafka-ն հիմնված է JVM լեզուների վրա, ուստի Java 7 կամ ավելի նոր տարբերակը պետք է տեղադրվի ձեր համակարգում:

Ներբեռնված zip ֆայլը հանեք ձեր համակարգչի (C:) սկավառակից և վերանվանեք թղթապանակը որպես /apache-kafka.

Մայր գրացուցակը պարունակում է երկու ենթագրքեր, /bin և /configորը պարունակում է կենդանաբանական այգու պահապանի և kafka սերվերի գործարկվող և կազմաձևման ֆայլերը:

Կազմաձևման քայլեր

Նախ, մենք պետք է ստեղծենք տեղեկամատյանների տեղեկատուներ Kafka և Zookeeper սերվերների համար: Այս գրացուցակները կպահեն այս կլաստերների բոլոր մետատվյալները և թեմաների և բաժանմունքների հաղորդագրությունները:

Նշում: Լռելյայնորեն, այս տեղեկամատյանները ստեղծվում են ներսում /tmp գրացուցակ, անկայուն գրացուցակ, որը անհետանում է ներսում գտնվող բոլոր տվյալները, երբ համակարգը անջատվում կամ վերագործարկվում է: Մենք պետք է սահմանենք տեղեկամատյանների դիրեկտորիաների մշտական ուղին՝ այս խնդիրը լուծելու համար: Տեսնենք, թե ինչպես:

Նավարկեք դեպի apache-kafka >> config և բացիր server.properties ֆայլ։ Այստեղ դուք կարող եք կարգավորել kafka-ի բազմաթիվ հատկություններ, ինչպիսիք են տեղեկամատյանների գրացուցակների ուղիները, տեղեկամատյանների պահպանման ժամերը, միջնապատերի քանակը և այլն:

Ներսում server.properties ֆայլ, մենք պետք է փոխենք տեղեկամատյանների գրացուցակի ֆայլի ուղին ժամանակավորից /tmp տեղեկատու մշտական գրացուցակում: Մատյան գրացուցակը պարունակում է գեներացված կամ գրված տվյալները Կաֆկա սերվերում: Ուղին փոխելու համար թարմացրեք log.dirs փոփոխական ից /tmp/kafka-logs դեպի c:/apache-kafka/kafka-logs. Սա կդարձնի ձեր տեղեկամատյանները մշտապես պահվող:

log.dirs=c:/apache-kafka/kafka-logs

Zookeeper սերվերը պարունակում է նաև որոշ մատյան ֆայլեր՝ Kafka սերվերների մետատվյալները պահելու համար: Ճանապարհը փոխելու համար կրկնեք վերը նշված քայլը, այսինքն բացեք zookeeper.properties ֆայլ և փոխարինիր ուղին հետևյալ կերպ.

dataDir=c:/apache-kafka/zookeeper-logs

Այս zookeeper սերվերը կգործի որպես ռեսուրսների կառավարիչ մեր kafka սերվերի համար:

Գործարկեք Kafka և Zookeeper սերվերները

Zookeeper սերվերը գործարկելու համար բացեք նոր cmd հուշում ձեր ծնողական գրացուցակում և գործարկեք ստորև նշված հրամանը:

$ .\bin\windows\zookeeper-server-start.bat .\config\zookeeper.properties

Պատկեր հեղինակի կողմից

Պահպանեք կենդանաբանական այգու պահապանի օրինակը:

Kafka սերվերը գործարկելու համար բացեք առանձին cmd հուշում և գործարկեք ստորև նշված կոդը:

$ .\bin\windows\kafka-server-start.bat .\config\server.properties

Պահպանեք kafka և zookeeper սերվերները գործարկված, և հաջորդ բաժնում մենք կստեղծենք արտադրողի և սպառողի գործառույթներ, որոնք կկարդան և կգրեն տվյալները kafka սերվերում:

Արտադրողի և սպառողի գործառույթների ստեղծում

Արտադրողի և սպառողի գործառույթները ստեղծելու համար մենք կվերցնենք մեր էլեկտրոնային առևտրի հավելվածի օրինակը, որը մենք ավելի վաղ քննարկեցինք: «Պատվերներ» ծառայությունը կգործի որպես արտադրող, որը գրում է պատվերի մանրամասները kafka սերվերում, իսկ Email և Analytics ծառայությունը կգործի որպես սպառող, որը կարդում է այդ տվյալները սերվերից։ Գործարքների ծառայությունը կաշխատի որպես սպառող և արտադրող: Այն կարդում է պատվերի մանրամասները և նորից գրում դրանք գործարքի հաստատումից հետո:

Բայց նախ, մենք պետք է տեղադրենք Kafka python գրադարանը, որը պարունակում է ներկառուցված գործառույթներ Արտադրողի և սպառողների համար:

$ pip install kafka-python

Այժմ ստեղծեք նոր գրացուցակ անունով kafka-tutorial. Մենք կստեղծենք python ֆայլերը այդ գրացուցակի ներսում, որոնք պարունակում են անհրաժեշտ գործառույթները:

$ mkdir kafka-tutorial
$ cd .\kafka-tutorial\

Արտադրողի գործառույթը.

Այժմ ստեղծեք «rides.py» անունով python ֆայլ և տեղադրեք հետևյալ կոդը դրա մեջ:

rides.py

import kafka
import json
import time
import random

topicName = "ride_details"
producer = kafka.KafkaProducer(bootstrap_servers="localhost:9092")

for i in range(1, 10):
    ride = {
        "id": i,
        "customer_id": f"user_{i}",
        "location": f"Lat: {random.randint(-90, 90)}, Long: {random.randint(-90, 90)}",
    }
    producer.send(topicName, json.dumps(ride).encode("utf-8"))
    print(f"Ride Details Send Succesfully!")
    time.sleep(5)

Բացատրություն:

Նախ՝ ներմուծել ենք բոլոր անհրաժեշտ գրադարանները, այդ թվում՝ կաֆկան։ Այնուհետև սահմանվում է թեմայի անվանումը և տարբեր կետերի ցանկը: Հիշեք, որ թեման խումբ է, որը պարունակում է նմանատիպ տեսակի հաղորդագրություններ: Այս օրինակում այս թեման կպարունակի բոլոր պատվերները։

Այնուհետև մենք ստեղծում ենք KafkaProducer ֆունկցիայի օրինակ և միացնում այն kafka սերվերին, որն աշխատում է localhost:9092-ում: Եթե ձեր kafka սերվերն աշխատում է այլ հասցեով և նավահանգստով, ապա այնտեղ պետք է նշեք սերվերի IP-ն և պորտի համարը:

Դրանից հետո մենք կգեներացնենք որոշ պատվերներ JSON ձևաչափով և դրանք կգրենք kafka սերվերում սահմանված թեմայի անվան վրա։ Sleep ֆունկցիան օգտագործվում է հետագա պատվերների միջև բացը ստեղծելու համար:

Սպառողի գործառույթները.

transaction.py

import json
import kafka
import random

RIDE_DETAILS_KAFKA_TOPIC = "ride_details"
RIDES_CONFIRMED_KAFKA_TOPIC = "ride_confirmed"

consumer = kafka.KafkaConsumer(
    RIDE_DETAILS_KAFKA_TOPIC, bootstrap_servers="localhost:9092"
)
producer = kafka.KafkaProducer(bootstrap_servers="localhost:9092")

print("Listening Ride Details")
while True:
    for data in consumer:
        print("Loading Transaction..")
        message = json.loads(data.value.decode())
        customer_id = message["customer_id"]
        location = message["location"]
        confirmed_ride = {
            "customer_id": customer_id,
            "customer_email": f"{customer_id}@xyz.com",
            "location": location,
            "alloted_driver": f"driver_{customer_id}",
            "pickup_time": f"{random.randint(1, 20)}mins",
        }
        print(f"Transaction Completed..({customer_id})")
        producer.send(
            RIDES_CONFIRMED_KAFKA_TOPIC, json.dumps(confirmed_ride).encode("utf-8")
        )

Բացատրություն:

Այն transaction.py ֆայլը օգտագործվում է օգտատերերի կողմից կատարված անցումները հաստատելու և նրանց վարորդի և հավաքման գնահատված ժամանակ հատկացնելու համար: Այն կարդում է ուղևորության մանրամասները kafka սերվերից և այն կրկին գրում է kafka սերվերում՝ ուղևորությունը հաստատելուց հետո:

Այժմ ստեղծեք երկու python ֆայլեր անունով email.py և analytics.py, որոնք օգտագործվում են հաճախորդին էլ-նամակներ ուղարկելու համար իրենց ուղևորությունը հաստատելու և համապատասխանաբար որոշ վերլուծություններ կատարելու համար: Այս ֆայլերը ստեղծվել են միայն ցույց տալու համար, որ նույնիսկ մի քանի սպառողներ կարող են միաժամանակ կարդալ տվյալները Kafka սերվերից:

email.py

import kafka
import json

RIDES_CONFIRMED_KAFKA_TOPIC = "ride_confirmed"
consumer = kafka.KafkaConsumer(
    RIDES_CONFIRMED_KAFKA_TOPIC, bootstrap_servers="localhost:9092"
)

print("Listening Confirmed Rides!")
while True:
    for data in consumer:
        message = json.loads(data.value.decode())
        email = message["customer_email"]
        print(f"Email sent to {email}!")

analysis.py

import kafka
import json

RIDES_CONFIRMED_KAFKA_TOPIC = "ride_confirmed"
consumer = kafka.KafkaConsumer(
    RIDES_CONFIRMED_KAFKA_TOPIC, bootstrap_servers="localhost:9092"
)

print("Listening Confirmed Rides!")
while True:
    for data in consumer:
        message = json.loads(data.value.decode())
        id = message["customer_id"]
        driver_details = message["alloted_driver"]
        pickup_time = message["pickup_time"]
        print(f"Data sent to ML Model for analysis ({id})!")

Այժմ, մենք ավարտել ենք հավելվածը, հաջորդ բաժնում մենք կաշխատենք բոլոր ծառայությունները միաժամանակ և կստուգենք կատարողականը:

Փորձարկեք Դիմումը

Գործարկեք յուրաքանչյուր ֆայլ չորս առանձին հրամանների հուշումներից մեկ առ մեկ:

Պատկեր հեղինակի կողմից

Դուք կարող եք միաժամանակ ելք ստանալ բոլոր ֆայլերից, երբ ուղևորության մանրամասները դրվում են սերվեր: Կարող եք նաև բարձրացնել մշակման արագությունը՝ հեռացնելով հետաձգման գործառույթը rides.py ֆայլ։ «rides.py» ֆայլը տվյալները մղել է kafka սերվեր, իսկ մյուս երեք ֆայլերը միաժամանակ կարդում են այդ տվյալները kafka սերվերից և գործում են համապատասխանաբար:

Հուսով եմ, որ դուք ստանում եք հիմնական պատկերացում Apache Kafka-ի մասին և ինչպես իրականացնել այն:

Այս հոդվածում մենք իմացանք Apache Kafka-ի, նրա աշխատանքի և գործնական իրականացման մասին՝ օգտագործելով տաքսիների ամրագրման հավելվածի օգտագործման դեպքը: Կաֆկայի հետ մասշտաբային խողովակաշարի նախագծումը պահանջում է մանրակրկիտ պլանավորում և իրականացում: Դուք կարող եք ավելացնել բրոքերների և միջնապատերի քանակը՝ այս հավելվածներն ավելի լայնածավալ դարձնելու համար: Յուրաքանչյուր բաժին մշակվում է ինքնուրույն, որպեսզի բեռը բաշխվի նրանց միջև: Բացի այդ, դուք կարող եք օպտիմալացնել kafka-ի կոնֆիգուրացիան՝ սահմանելով քեշի չափը, բուֆերի չափը կամ թելերի քանակը:

GitHub հղում հոդվածում օգտագործված ամբողջական կոդի համար:

Շնորհակալություն այս հոդվածը կարդալու համար: Եթե ունեք մեկնաբանություններ կամ առաջարկություններ, խնդրում ենք ազատ զգալ կապվել ինձ հետ Linkedin-ում:

Արիական Գարգ բ.տեխ. Էլեկտրատեխնիկայի ուսանող, այժմ բակալավրիատի վերջին կուրսում: Նրա հետաքրքրությունը կայանում է Web Development-ի և Machine Learning ոլորտում: Նա հետապնդել է այս շահը և ցանկանում է ավելի շատ աշխատել այս ուղղություններով։

Source link