Ориентираните към микросервиз модели на дизайна са направили нашите приложения по-мащабируеми от всякога. RESTful API сървъри, интерфейс и дори базите данни вече са хоризонтално мащабируеми. Хоризонталното мащабиране е актът на добавяне на нови възли към вашия клъстер на приложения, за да поддържа допълнително натоварване. Обратно, той също така позволява намаляване на потреблението на ресурси, когато работното натоварване намалява, за да се спестят разходи. Хоризонтално мащабируемите системи трябва да бъдат разпределени. Тези системи могат да оцелеят при отказ на множество виртуални машини, контейнери или мрежови връзки и да останат онлайн и здрави за крайния потребител.

Когато говорим за разпределени системи, както по-горе, ние се сблъскваме с проблема с анализирането и наблюдението. Всеки възел генерира много информация за собственото си здраве (използване на процесора, памет и т.н.) и за състоянието на приложението заедно с това, което потребителите се опитват да направят. Тези подробности трябва да бъдат записани в:

1. Същият ред, в който са създадени,
2. Разделени по отношение на неотложността (анализи в реално време или партиди данни) и най-важното,
3. Механизмът, с който те се събират, трябва сам да бъде разпределен и мащабируем, в противен случай ни остава една точка на отказ. Нещо, което дизайнът на разпределената система трябваше да избягва.

Защо да използвате Кафка?

Apache Kafka се предлага като разпределена платформа за поточно предаване. В Кафка жаргон, Производители непрекъснато генериране на данни (потоци) и Потребители са отговорни за обработката, съхранението и анализа му. Кафка Брокери са отговорни за гарантиране, че в разпределен сценарий данните могат да достигнат от производители до потребители без никаква несъответствие. Набор от брокери на Kafka и още един софтуер, наречен зоопарк представляват типично разгръщане на Кафка.

Потокът от данни от много производители трябва да бъде обобщен, разделен и изпратен до множество потребители, има много разбъркване. Избягването на непоследователност не е лесна задача. Ето защо се нуждаем от Кафка.

Сценариите, при които Kafka може да се използва, са доста разнообразни. Всичко от устройства IOT до клъстер на виртуални машини до вашите собствени локални сървъри без голи метали. Навсякъде, където много „неща“ едновременно искат вашето внимание .. .Това не е много научно, нали? Ами архитектурата на Kafka е собствена заешка дупка и заслужава независимо лечение. Нека първо видим внедряването на софтуера на много повърхностно ниво.

Използване на Docker Compose

По какъвто и въобразителен начин да решите да използвате Kafka, едно е сигурно - няма да го използвате като единичен екземпляр. Не е предназначено да се използва по този начин и дори ако вашето разпределено приложение се нуждае от само един екземпляр (брокер) засега, то в крайна сметка ще нарасне и трябва да сте сигурни, че Kafka може да продължи.

Docker-compose е идеалният партньор за този вид мащабируемост. Вместо да стартираме брокери на Kafka на различни виртуални машини, ние го съдържаме и използваме Docker Compose за автоматизиране на внедряването и мащабирането. Контейнерите на Docker са силно мащабируеми както на единични хостове на Docker, така и в клъстер, ако използваме Docker Swarm или Kubernetes. Така че има смисъл да го използваме, за да направим Кафка мащабируема.

Нека започнем с един екземпляр на брокер. Създайте директория, наречена apache-kafka, и в нея създайте вашия docker-compose.yml.

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

Следното съдържание ще бъде поставено във вашия docker-compose.yml файл:

версия: '3'
услуги:
зоопарк:
изображение: wurstmeister / zookeeper
 
kafka:
изображение: wurstmeister / kafka
портове:
- „9092: 9092“
околен свят:
KAFKA_ADVERTISED_HOST_NAME: localhost
KAFKA_ZOOKEEPER_CONNECT: пазач на зоопарка: 2181

След като запазите горното съдържание във вашия композиращ файл, от същата директория изпълнете:

$ docker-compose up -d

Добре, така че какво направихме тук?

Разбиране на Docker-Compose.yml

Compose ще стартира две услуги, както са изброени в yml файла. Нека разгледаме файла малко отблизо. Първото изображение е zookeeper, което Kafka изисква, за да следи различни брокери, топологията на мрежата, както и да синхронизира друга информация. Тъй като услугите на zookeeper и kafka ще бъдат част от една и съща мостова мрежа (това се създава, когато стартираме docker-compose up), не е нужно да излагаме никакви портове. Брокерът на Kafka може да разговаря със зоопарка и това е всичко, от което се нуждае зоопаркът.

Втората услуга е самата kafka и ние просто изпълняваме един единствен екземпляр от нея, т.е. един брокер. В идеалния случай бихте искали да използвате множество брокери, за да използвате разпределената архитектура на Kafka. Услугата слуша на порт 9092, който е съпоставен със същия номер на порт на Docker Host и по този начин услугата комуникира с външния свят.

Втората услуга също има няколко променливи на средата. Първо, KAFKA_ADVERTISED_HOST_NAME е зададен на localhost. Това е адресът, на който работи Kafka и където производителите и потребителите могат да го намерят. Още веднъж, това трябва да бъде настроено на localhost, а по-скоро на IP адреса или името на хоста, с което сървърите могат да бъдат достигнати във вашата мрежа. Второто е името на хоста и номера на порта на вашата услуга zookeeper. Тъй като нарекохме услугата zookeeper ... добре, zookeeper това ще бъде името на хоста, в мрежата на докер мост, за която споменахме.

Стартиране на обикновен поток от съобщения

За да започне да работи Кафка, трябва да създадем тема в нея. След това клиентите на производителите могат да публикуват потоци от данни (съобщения) към споменатата тема, а потребителите могат да прочетат споменатия поток от данни, ако са абонирани за тази конкретна тема.

За целта трябва да стартираме интерактивен терминал с контейнера Kafka. Избройте контейнерите, за да извлечете името на контейнера на kafka. Например, в този случай нашият контейнер се нарича apache-kafka_kafka_1

$ docker ps

С името на контейнера на kafka, вече можем да пуснем вътре в този контейнер.

$ docker exec -it apache-kafka_kafka_1 bash
баш-4.4 #

Отворете два толкова различни терминала, за да използвате един като потребител и друг производител.

Продуцентска страна

В един от подканите (този, който сте избрали да бъде продуцент) въведете следните команди:

## За създаване на нова тема с име test
баш-4.4 # kafka-теми.sh --create --zookeeper zookeeper: 2181 - репликационен фактор 1
--дялове 1 - темен тест
 
## За стартиране на производител, който публикува поток от данни от стандартен вход към kafka
баш-4.4 # производител на конзола kafka.sh --broker-list localhost: 9092 - тематичен тест
>

Продуцентът вече е готов да вземе вход от клавиатурата и да го публикува.

Потребителска страна

Придвижете се до втория терминал, свързан към вашия контейнер kafka. Следващата команда стартира потребител, който се храни с тестова тема:

$ kafka-console-consumer.sh --bootstrap-server localhost: 9092 - тематичен тест

Обратно към продуцента

Вече можете да пишете съобщения в новия ред и всеки път, когато натиснете връщане, новият ред се отпечатва в потребителския ред. Например:

> Това е съобщение.

Това съобщение се предава на потребителя чрез Kafka и можете да го видите отпечатано в потребителския ред.

Настройки в реалния свят

Вече имате приблизителна картина как работи настройката на Kafka. За вашия случай на употреба трябва да зададете име на хост, което не е localhost, имате нужда от множество такива брокери, които да бъдат част от вашия клъстер kafka и накрая трябва да настроите клиенти за потребители и производители.

Ето няколко полезни връзки:

1. Клиентът на Python на Confluent
2. Официална документация
3. Полезен списък с демонстрации

Надявам се да се забавлявате да изследвате Apache Kafka.