El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Què és Kafka?

Següent ►
►

Introducció

Apache Kafka és una plataforma de codi obert per a la gestió de fluxos de dades en temps real. Va ser desenvolupada originalment per LinkedIn i posteriorment es va convertir en un projecte de l'Apache Software Foundation. Kafka és conegut per la seva capacitat de manejar grans volums de dades amb alta velocitat i fiabilitat.

Característiques Clau de Kafka

  1. Alta Rendibilitat: Kafka pot manejar milions de missatges per segon amb baixa latència.
  2. Escalabilitat: Kafka és altament escalable, tant horitzontalment com verticalment.
  3. Durabilitat: Kafka emmagatzema dades de manera persistent, assegurant que els missatges no es perdin.
  4. Fiabilitat: Kafka garanteix l'entrega de missatges amb mecanismes de confirmació i replicació.
  5. Flexibilitat: Kafka pot ser utilitzat per a una àmplia varietat de casos d'ús, des de la ingesta de dades en temps real fins a la integració de sistemes.

Components Principals de Kafka

  1. Productors (Producers): Són les aplicacions que publiquen missatges a Kafka.
  2. Consumidors (Consumers): Són les aplicacions que llegeixen i processen els missatges de Kafka.
  3. Brokers: Són els servidors que emmagatzemen les dades i serveixen els missatges als consumidors.
  4. Temes (Topics): Són les categories o fluxos de dades als quals els missatges són publicats.
  5. Particions (Partitions): Cada tema es divideix en particions per permetre l'escalabilitat i la paral·lelització.

Arquitectura de Kafka

Kafka segueix una arquitectura distribuïda basada en clústers. Un clúster de Kafka està format per múltiples brokers que treballen junts per gestionar les dades. Els missatges són publicats pels productors a temes específics, que es divideixen en particions. Els consumidors llegeixen els missatges de les particions de manera paral·lela, permetent una alta capacitat de processament.

Diagrama de l'Arquitectura de Kafka

+-------------------+       +-------------------+
|    Productor 1    |       |    Productor 2    |
+--------+----------+       +--------+----------+
         |                           |
         v                           v
+--------+---------------------------+----------+
|                 Broker 1 (Kafka)               |
|  +-------------------+  +-------------------+  |
|  |     Partició 1    |  |     Partició 2    |  |
|  +-------------------+  +-------------------+  |
+-----------------------------------------------+
         |                           |
         v                           v
+--------+----------+       +--------+----------+
|    Consumidor 1   |       |    Consumidor 2   |
+-------------------+       +-------------------+

Casos d'Ús de Kafka

  1. Ingesta de Dades en Temps Real: Kafka és utilitzat per recollir i processar dades en temps real des de diverses fonts, com ara sensors IoT, aplicacions web, i sistemes de registre.
  2. Integració de Sistemes: Kafka actua com a intermediari per a la comunicació entre diferents sistemes, permetent la integració fluida de dades.
  3. Monitorització i Anàlisi: Kafka és utilitzat per recollir i analitzar dades de monitorització en temps real, com ara logs de servidors i mètriques de rendiment.
  4. Processament de Fluxos: Kafka Streams permet el processament de fluxos de dades en temps real, facilitant l'anàlisi i la transformació de dades sobre la marxa.

Exemples Pràctics

Exemple 1: Publicació de Missatges amb un Productor

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;

public class SimpleProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<>("my-topic", Integer.toString(i), "message-" + i));
        }
        producer.close();
    }
}

Exemple 2: Consum de Missatges amb un Consumidor

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import java.util.Collections;
import java.util.Properties;

public class SimpleConsumer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test-group");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList("my-topic"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
        }
    }
}

Exercici Pràctic

Exercici 1: Configura un Clúster de Kafka Local

  1. Descarrega i instal·la Apache Kafka des del lloc oficial.
  2. Configura un clúster de Kafka amb almenys un broker.
  3. Crea un tema anomenat test-topic.
  4. Publica missatges al tema test-topic utilitzant un productor.
  5. Consumeix els missatges del tema test-topic utilitzant un consumidor.

Solució

  1. Descarrega i descomprimeix Kafka:

    tar -xzf kafka_2.13-2.8.0.tgz
cd kafka_2.13-2.8.0

  2. Inicia el servidor de Zookeeper:

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

  3. Inicia el broker de Kafka:

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

  4. Crea un tema:

    bin/kafka-topics.sh --create --topic test-topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

  5. Publica missatges:

    bin/kafka-console-producer.sh --topic test-topic --bootstrap-server localhost:9092

  6. Consumeix missatges:

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

Conclusió

En aquesta secció, hem après què és Apache Kafka, les seves característiques clau, components principals, arquitectura i alguns casos d'ús pràctics. També hem vist exemples de codi per a productors i consumidors, i hem realitzat un exercici pràctic per configurar un clúster de Kafka local. Amb aquesta base, estem preparats per aprofundir en els conceptes bàsics de Kafka en el següent mòdul.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats