El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Visión General de la Arquitectura de Kafka

Siguiente ►
►

Apache Kafka es una plataforma de transmisión de datos distribuida que permite la publicación, suscripción, almacenamiento y procesamiento de flujos de registros en tiempo real. Para entender cómo funciona Kafka, es esencial conocer su arquitectura. En esta sección, desglosaremos los componentes clave de Kafka y cómo interactúan entre sí.

Componentes Principales de Kafka

  1. Broker
  2. Zookeeper
  3. Productores (Producers)
  4. Consumidores (Consumers)
  5. Temas (Topics)
  6. Particiones (Partitions)
  7. Réplicas (Replicas)
  8. Desplazamientos (Offsets)

  1. Broker

Un broker de Kafka es un servidor que almacena datos y sirve a los clientes. Un clúster de Kafka está compuesto por múltiples brokers para garantizar la alta disponibilidad y la tolerancia a fallos.

  • Función: Almacenar y servir datos.
  • Escalabilidad: Se pueden añadir más brokers para aumentar la capacidad y la redundancia.

  1. Zookeeper

Zookeeper es un servicio centralizado para mantener la información de configuración, nombrar, proporcionar sincronización distribuida y servicios de grupo. Kafka utiliza Zookeeper para gestionar el clúster de brokers.

  • Función: Coordinar y gestionar el clúster de Kafka.
  • Dependencia: Kafka depende de Zookeeper para la gestión de la configuración y la coordinación de los brokers.

  1. Productores (Producers)

Los productores son aplicaciones que publican datos en los temas de Kafka. Los productores envían registros a un tema específico y pueden elegir la partición a la que enviar los datos.

  • Función: Publicar datos en los temas.
  • Configuración: Pueden configurarse para enviar datos a una partición específica o dejar que Kafka lo haga automáticamente.

  1. Consumidores (Consumers)

Los consumidores son aplicaciones que leen datos de los temas de Kafka. Los consumidores se agrupan en grupos de consumidores, y cada mensaje en un tema es leído por un solo consumidor dentro de un grupo.

  • Función: Leer datos de los temas.
  • Grupos de Consumidores: Permiten la escalabilidad horizontal y la tolerancia a fallos.

  1. Temas (Topics)

Un tema es una categoría o flujo de datos a la que los registros son publicados. Los temas son particionados y replicados para garantizar la escalabilidad y la durabilidad.

  • Función: Categorizar y almacenar datos.
  • Particiones: Dividen los datos para permitir la paralelización.

  1. Particiones (Partitions)

Cada tema se divide en particiones, que son unidades de paralelización dentro de un tema. Cada partición es una secuencia ordenada e inmutable de registros.

  • Función: Permitir la paralelización y la escalabilidad.
  • Orden: Los registros dentro de una partición están ordenados.

  1. Réplicas (Replicas)

Las réplicas son copias de las particiones que se almacenan en diferentes brokers para garantizar la durabilidad y la disponibilidad de los datos.

  • Función: Garantizar la alta disponibilidad y la tolerancia a fallos.
  • Líder y Réplicas: Cada partición tiene una réplica líder que maneja todas las lecturas y escrituras, y varias réplicas seguidoras.

  1. Desplazamientos (Offsets)

El desplazamiento es un identificador único que representa la posición de un registro dentro de una partición. Los consumidores utilizan los desplazamientos para rastrear su posición en el flujo de datos.

  • Función: Rastrear la posición de los registros.
  • Persistencia: Los desplazamientos pueden ser gestionados por los consumidores o almacenados en Kafka.

Ejemplo Práctico

A continuación, se muestra un ejemplo de cómo un productor envía mensajes a un tema y cómo un consumidor los lee.

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();
    }
}

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());
            }
        }
    }
}

Ejercicio Práctico

Ejercicio: Configura un clúster de Kafka con tres brokers y un Zookeeper. Crea un tema con tres particiones y dos réplicas. Escribe un productor que envíe 100 mensajes al tema y un consumidor que lea esos mensajes.

Solución

  1. Configurar Zookeeper y Brokers:

    • Descarga y descomprime Kafka.
    • Configura zookeeper.properties y server.properties para cada broker.
    • Inicia Zookeeper y los brokers.

  2. Crear el Tema:

    bin/kafka-topics.sh --create --topic my-topic --partitions 3 --replication-factor 2 --bootstrap-server localhost:9092

  3. Escribir el Productor y el Consumidor:

    • Usa los ejemplos de código proporcionados anteriormente.
    • Modifica el productor para enviar 100 mensajes.
    • Ejecuta el productor y luego el consumidor.

Conclusión

En esta sección, hemos cubierto los componentes clave de la arquitectura de Kafka y cómo interactúan entre sí. Entender estos conceptos es fundamental para trabajar eficazmente con Kafka y diseñar sistemas de transmisión de datos robustos y escalables. En el próximo módulo, profundizaremos en los conceptos básicos de Kafka, incluyendo productores, consumidores, temas y particiones.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados