Streaming on BigDataPassion

Praca z CLI w Apache Kafka

Sat, 25 Feb 2023 00:00:00 +0000

Poniżej lista przydatnych poleceń Apache Kafka.

Dla ułatwienia korzystania, używane są odpowiednie zmienne systemowe oraz aliasy.

Jeśli korzystamy z CLI w postaci obrazu Docker ustawmy aliasy jak poniżej:

docker run --rm -it confluentinc/cp-kafka --version
docker run --rm -it confluentinc/cp-kafka kafka-topics --version

alias kafka-topics="docker run --rm -it confluentinc/cp-kafka kafka-topics"

Jeśli jednak wolimy zainstalować Kafka CLI to ściągamy paczkę ze strony Apache Kafka i rozpakowujemy do wybranego katalogu, w moim przypadku ~/programs/kafka/

alias kafka-topics="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-topics.sh"
alias kafka-console-consumer="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-console-consumer.sh"
alias kafka-console-producer="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-console-producer.sh"
alias kafka-consumer-groups="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-consumer-groups.sh"

Gdy korzystamy z Kafki z zabezpieczonym dostępem (certyfikat lub Kerberos) to w większości poleceniach będziemy potrzebować przekazać konfigurację do polecenia dlatego ustawiamy odpowiednia zmienna

export KAFKA_CLIENT_CONFIG=client.properties

Jesli wszystko działa

kafka-topics --version

export KAFKA_BROKER="localhost:9092"
export TOPIC=test-topic
export GROUP=radek

Topiki

lista:

kafka-topics --bootstrap-server $KAFKA_BROKER --list

kafka-topics --bootstrap-server $KAFKA_BROKER --list \
  --command-config $KAFKA_CLIENT_CONFIG

tworzenie:

kafka-topics --create --bootstrap-server $KAFKA_BROKER --topic $TOPIC

kafka-topics --create --bootstrap-server $KAFKA_BROKER --topic $TOPIC --config cleanup.policy=compact

kafka-topics --create --bootstrap-server $KAFKA_BROKER  --topic $TOPIC --replication-factor 3 --partitions 10

opis:

kafka-topics --describe --bootstrap-server $KAFKA_BROKER

kafka-topics --describe --bootstrap-server $KAFKA_BROKER --topic $TOPIC

kafka-topics --describe --bootstrap-server $KAFKA_BROKER --topic $TOPIC \
  --command-config $KAFKA_CLIENT_CONFIG

kafka-topics --zookeeper $KAFKA_ZOOKEEPER --describe --under-replicated-partitions

kafka-topics --describe --zookeeper $KAFKA_ZOOKEEPER --topic __consumer_offsets

usuwanie

kafka-topics --bootstrap-server $KAFKA_BROKER --delete --topic $TOPIC

Do usuwania należy włączyć tą możliwość w ustawieniach (delete.topic.enable), inaczej tylko oznacza topic jako usunięty.

edycja:

kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic $TOPIC --partitions 20
kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic $TOPIC --replication-factor 3
kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic $TOPIC --replica-assignment 1003:1004:1005,0:1:2,0:1:2,2:1:0

kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic __consumer_offsets --replication-factor 3

Producent i konsument w konsoli

kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC

kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC --property "parse.key=true" --property "key.separator=|"

cat $TOPIC.json | kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC \
  --property "parse.key=true" --property "key.separator=|"

cat $TOPIC.json | kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC \
  --property "parse.key=true" --property "key.separator=|" \
  --property key.serializer=org.apache.kafka.common.serialization.IntegerSerializer \
  --property value.serializer=org.apache.kafka.common.serialization.StringSerializer \

time for i in {1..10}; do
  echo $i'|{"message": "message'$i'"}' | \
  kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC \
  --property "parse.key=true" --property "key.separator=|"; 
done

time for i in {11..100}; do echo $i'|{"message": "message'$i'"}' | kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC --property "parse.key=true" --property "key.separator=|"; done

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --consumer.config $KAFKA_CLIENT_CONFIG

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --property key.deserializer=org.apache.kafka.common.serialization.IntegerDeserializer \
  --property value.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
  --consumer.config $KAFKA_CLIENT_CONFIG

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --property key.deserializer=org.apache.kafka.common.serialization.LongDeserializer \
  --property value.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
  --consumer.config $KAFKA_CLIENT_CONFIG

kafka-console-consumer --bootstrap-server $KAFKA_BROKER \
    --topic test-topic-out \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.StringDeserializer

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  | tee -a $TOPIC.json

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --consumer.config $KAFKA_CLIENT_CONFIG \
  | tee -a $TOPIC.json

Grupy konsumentów

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER --list

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER --describe --group $GROUP \
    --command-config $KAFKA_CLIENT_CONFIG

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER  --topic $TOPIC  --reset-offsets --to-earliest --group $GROUP \
  --command-config $KAFKA_CLIENT_CONFIG

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER  --topic $TOPIC  --reset-offsets --to-earliest --group $GROUP \
  --execute \
  --command-config $KAFKA_CLIENT_CONFIG

Zarządzanie partycjami

bin/kafka-reassign-partitions.sh --zookeeper $KAFKA_ZOOKEEPER --reassignment-json-file /tmp/increase-replication-factor.json --execute

Uruchamianie i zatrzymywanie

zookeeper:

bin/zookeeper-server-start.sh config/zookeeper.properties

broker:

bin/kafka-server-start.sh config/server.properties

ZooKeeper

instalacja oddzielna:

cd $ZOOKEEPER_HOME
bin/zkCli.sh

wersja z paczki Apache Kafka:

bin/zookeeper-shell.sh $KAFKA_ZOOKEEPER

polecenia konsoli ZooKeepera:

ls /brokers
ls /brokers/ids
ls /brokers/topics
ls /brokers/seqid

Narzędzia

bin/bin/kafka-consumer-groups.sh \
    --topic $TOPIC --zookeeper $KAFKA_ZOOKEEPER \
    --group test_group

Confluent Platform - dystrybucja Big Data której sercem jest Apache Kafka

Thu, 14 Apr 2022 00:00:00 +0000

Apache Kafka stała się bazą wielu systemów przetwarzających dane strumieniowe. Jednakże często potrzebujemy rozszerzyć jej możliwości dodatkowymi komponentami jak rejestr schematów, rest proxy, replikację danych, dodatkowe konektory i wiele innych. W takich sytuacjach z pomocą przychodzi nam Confluent Platform, czyli kompletna dystrybucja Big Data, której sercem jest Apache Kafka. Z platformy korzysta obecnie ponad 80% firm z zestawienia Fortune 100. W tym artykule przedstawię najważniejsze informacje dotyczące tej platformy.

Komponenty platformy

Sercem Confluent Platform jest Apache Kafka, oczywiście z uwzględnieniem wszystkich modułów, czyli:

Kafka Core (broker)
Kafka Connect
Kafka Streams

Jednakże największą zaletą korzystania z platformy są dodatkowe komponenty jak:

Confluent Schema Registry — rejestr schematów, który znacząco ułatwia pracę z komunikatami Avro, JSON lub Protobuf
Confluent Clients — biblioteki dostępowe dla języków programowania spoza środowiska JVM jak C/C++, Python, Go, .NET
Confluent REST Proxy — REST API przydatne do pracy, gdy nie możemy skorzystać z natywnych bibliotek klienckich
Confluent Connectors to Kafka — dodatkowe pluginy dla Kafka Connect
ksqlDB — narzędzie umożliwiające strumieniowe przetwarzanie danych oraz budowanie przepływu danych za pomocą języka SQL, bazuje na Kafka Streams oraz Kafka Connect, wcześniejsza nazwa to KSQL
Confluent CLI — dodatkowe narzędzia konsolowe do codziennej pracy z platformą i jej składowymi
Confluent Control Center — narzędzie UI do zarządzania naszym klastrem
Confluent Replicator — narzędzie do replikacji danych pomiędzy klastrami
Confluent Cluster Linking — narzędzie do synchronizacji danych pomiędzy klastrami Apache Kafka (binarnie)
Confluent Auto Data Balancer / Self-Balancing Clusters — narzędzie umożliwiające automatyczne równomierne rozkładanie ruchu na Kafce, wykrywanie awarii oraz automatyczną naprawę klastra
Tiered Storage — optymalizacja kosztów w chmurze przez trzymanie starszych danych np. w Amazon S3, Google Cloud Storage lub MinIO
Confluent JMS Client — Klient JMS dla Kafki
Confluent MQTT Proxy — Możliwość komunikacji z Kafką za pomocą protokołu MQTT (np. RabbitMQ go używa)
Confluent Security Plugins — Dodatkowe pluginy zwiększające bezpieczeństwo

Jak widać, platforma znacząco zwiększa możliwości, jakie oferuje Apache Kafka.

Możliwość wdrożenia

Jeśli chcielibyśmy wypróbować Confluent Platform, najlepszym rozwiązaniem jest skorzystanie z kontenerów dostępnych w Docker Hub.

Gdy przyjdzie nam skorzystać z Confluent Platform produkcyjnie, mamy trzy ścieżki do wyboru

Klasyczna instalacja oparta o maszyny fizyczne (Bare metal) lub wirtualne
Confluent for Kubernetes (CFK) — możliwość instalacji na dowolnym klastrze Kubernetes
Confluent Cloud — gotowy serwis umożliwiający pracę z Confluent Platform w chmurze AWS, GCP lub Azure. Umożliwia on także pracę z Apache Kafka jako serverless.

W przypadku pierwszej wersji, czyli samodzielnej instalacji, można ją przeprowadzić ręcznie za pomocą gotowych paczek ZIP/TAR lub repozytoriów Linux dla systemów Debian, Ubuntu, Red Hat oraz CentOS. Dużo jednak lepszym i wygodniejszym rozwiązaniem jest skorzystanie z gotowych Ansible playbooks.

Licencja i cennik

Confluent Platform korzysta z trzech rodzajów licencji:

Apache 2.0 License — Apache Kafka, Kafka Streams, Kafka Connect, Kafka Clients, Serializers, Community Connectors
Confluent Community License — REST Proxy, Schema Registry, ksqlDB, Confluent Connectors
Confluent Enterprise License — Control Center, Replicator, Auto Data Balancer, Enterprise Connectors

Z narzędzi dostępnych na licencji Apache 2.0 może skorzystać każda firma. Jeśli jesteśmy firmą, która chce wykorzystać Confluent Platform do własnego użytku, to najprawdopodobniej możemy skorzystać za darmo także z rozwiązań objętych licencją community (szczegóły w treści licencji). Firmy chcące skorzystać ze wszystkich możliwości, jakie oferuje Confluent Platform, muszą liczyć się z koniecznością zakupu pełnej komercyjnej licencji, wraz z którą otrzymują wsparcie firmy Confluent. Cennik nie jest publicznie dostępny, dlatego w przypadku zainteresowania proszę o kontakt z przedstawicielami firmy.

W przypadku wersji chmurowej mamy możliwość pracy z platformą w modelu płatności za użycie, zaś cennik jest publicznie dostępny na stronie Confluent Cloud.

Dodatkowe informacje

W kolejnych artykułach przyjrzymy się bliżej możliwościom, jakie oferuje Confluent Platform.

Więcej informacji można także znaleźć pod poniższymi adresami:

Analiza danych w czasie rzeczywistym za pomocą Apache Kafka

Sat, 14 Dec 2019 00:00:00 +0000

Na kanale YouTube Confitury pojawiły się nagrania z tegorocznej konferencji.

Poniżej relacja:

oraz moja prezentacja:

Building Realtime & Big Data Pipelines with Apache Kafka

Mon, 08 Oct 2018 00:00:00 +0000

Na kanale YouTube Confitury pojawiły się nagrania z tegorocznej konferencji.

Poniżej relacja:

oraz moja prezentacja:

Apache Kafka w kontenerze Docker

Fri, 22 Jun 2018 00:00:00 +0000

Apache Kafka można z łatwością uruchomić na swoim komputerze korzystając z gotowych obrazów Dockera. Poniżej kilka przykładów jak to zrobić.

Użyjemy obrazów:

Jeden broker i ZooKeeper

Przygotowanie sieci:

docker network rm bdp_kafka_network
docker network create --driver bridge bdp_kafka_network
docker network ls

Kontener ZooKeepera:

docker run --name zookeeper.bigdatapassion.pl \
    -p 2181:2181 \
    --network=bdp_kafka_network \
    --hostname=zookeeper.bigdatapassion.pl \
    -d \
    wurstmeister/zookeeper:latest

Kontener Kafki:

docker run --name kafka.bigdatapassion.pl \
    -p 9092:9092 \
    --env KAFKA_ZOOKEEPER_CONNECT=zookeeper.bigdatapassion.pl \
    --network=bdp_kafka_network \
    --hostname=kafka.bigdatapassion.pl \
    -d \
    wurstmeister/kafka:1.0.1

Dodajemy w pliku /etc/hosts:

127.0.0.1   zookeeper.bigdatapassion.pl kafka.bigdatapassion.pl

Żeby zatrzymać i wyczyścić:

docker stop zookeeper.bigdatapassion.pl
docker stop kafka.bigdatapassion.pl

docker rm zookeeper.bigdatapassion.pl
docker rm kafka.bigdatapassion.pl

docker ps -a

Trzech brokerów i ZooKeeper

Jeśli chcemy uruchomić lokalnie Apache Kafka na więcej niż jednym brokerze za pomocą Dockera może użyć do tego Docker Compose

Kafka 1.0.0

version: '3.5'

services:

  zookeeper:
      container_name: cluster_zookeeper
      image: wurstmeister/zookeeper
      ports:
        - "2181:2181"
      networks:
        - kafkanetwork

  kafka1:
      container_name: cluster_kafka1
      image: wurstmeister/kafka:1.0.0
      ports:
        - "9092:9092"
      hostname: cluster_kafka1
      networks:
        - kafkanetwork
      environment:
        KAFKA_ADVERTISED_LISTENERS: cluster_kafka1
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - zookeeper

  kafka2:
      container_name: cluster_kafka2
      image: wurstmeister/kafka:1.0.0
      ports:
        - "9093:9092"
      hostname: cluster_kafka2
      networks:
        - kafkanetwork
      environment:
        KAFKA_ADVERTISED_LISTENERS: cluster_kafka2
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka1
  kafka3:
      container_name: cluster_kafka3
      image: wurstmeister/kafka:1.0.0
      ports:
        - "9094:9092"
      hostname: cluster_kafka3
      networks:
        - kafkanetwork
      environment:
        KAFKA_ADVERTISED_LISTENERS: cluster_kafka3
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka2

networks:
  kafkanetwork:
    driver: bridge

Kafka 1.1.0

version: '3.5'

services:

  zookeeper:
      container_name: cluster_zookeeper
      image: wurstmeister/zookeeper
      ports:
        - "2181:2181"
      networks:
        - kafkanetwork

  kafka1:
      container_name: cluster_kafka1
      image: wurstmeister/kafka:1.1.0
      ports:
        - "9092:9092"
      hostname: cluster_kafka1
      networks:
        - kafkanetwork
      environment:
        KAFKA_LISTENERS: PLAINTEXT://:9092
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - zookeeper

  kafka2:
      container_name: cluster_kafka2
      image: wurstmeister/kafka:1.1.0
      ports:
        - "9093:9092"
      hostname: cluster_kafka2
      networks:
        - kafkanetwork
      environment:
        KAFKA_LISTENERS: PLAINTEXT://:9092
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka1
  kafka3:
      container_name: cluster_kafka3
      image: wurstmeister/kafka:1.1.0
      ports:
        - "9094:9092"
      hostname: cluster_kafka3
      networks:
        - kafkanetwork
      environment:
        KAFKA_LISTENERS: PLAINTEXT://:9092
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka2

networks:
  kafkanetwork:
    driver: bridge

Instalacja Apache Kafka

Wed, 20 Jun 2018 00:00:00 +0000

W dzisiejszym poście jak zainstalować sobie szybko kafkę lokalnie do testów. Będziemy używać dystrybucji Apache.

Instalacja dla systemu Linux.

Instalacja wersji z jednym brokerem

Zaczynamy od ściągnięcia Kafki i rozpakowania w nowym katalogu. Najnowsza wersja jest do ściągnięcia ze strony projektu. Będziemy używać wersji Kafki 1.1.0 dla języka Scala w wersji 2.11 (aktualnie 2.11 jest zalecana zarówno dla Kafki jak i Sparka stąd dość oczywisty wybór).

mkdir kafka
cd kafka
wget http://ftp.man.poznan.pl/apache/kafka/1.1.0/kafka_2.11-1.1.0.tgz
tar -xzf kafka_2.11-1.1.0.tgz

Uruchomienie jednego brokera

Jeśli chcemy pracować w wersji z jednym brokerem to już koniec. Teraz wystarczy uruchomić Zookeepera

cd kafka_2.11-1.1.0/
bin/zookeeper-server-start.sh config/zookeeper.properties

oraz brokera

bin/kafka-server-start.sh config/server.properties

Oczywiście robimy to w oddzielnych terminalach lub w tle jako demony (pokazane niżej).

Operacje na Apache Kafka

Zaczynamy od stworzenia topicu

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

teraz możemy sprawdzić listę topiców

bin/kafka-topics.sh --list --zookeeper localhost:2181

Uruchamiamy skrypt producenta

bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test

oraz skrypt konsumenta

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

i wysyłamy kilka wiadomości z poziomu producenta sprawdzając czy zostały odebrane przez konsumenta. Jeśli zobaczymy nasze wiadomości, Kafka działa poprawnie.

Kilku brokerów

By poczuć się jak w środowisku rozproszonym, powołamy do życia dwóch kolejnych brokerów na tym samym komputerze

cp config/server.properties config/server1.properties
cp config/server.properties config/server2.properties

vim config/server1.properties
vim config/server2.properties

Edytując dwa ostatnie pliki zmieniamy

broker.id=0
listeners=PLAINTEXT://:9092
log.dirs=/tmp/kafka-logs

broker.id=1
listeners=PLAINTEXT://:9093
log.dirs=/tmp/kafka-logs1

oraz

broker.id=2
listeners=PLAINTEXT://:9094
log.dirs=/tmp/kafka-logs2

(uwaga opcja listeners może być zakomentowana, trzeba usunąć znak # przed nazwą)

Następnie uruchamiamy dwóch dodatkowych brokerów w oddzielnych oknach terminala (poprzedni jest ciągle włączony)

bin/kafka-server-start.sh config/server1.properties
bin/kafka-server-start.sh config/server2.properties

Tworzymy zreplikowany topic

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic my-replicated-topic

oraz topic z partycjami

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic my-partitioned-topic

oraz topic zreplikowany z partycjami

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 3 --topic my-super-topic

wyświetlamy listę topiców

bin/kafka-topics.sh --list --zookeeper localhost:2181

wyświetlamy informacje o topicach za pomocą describe

bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic test
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-replicated-topic
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-partitioned-topic
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-super-topic