Unidad 4.3: Integración de transmisión de eventos

Introducción

Está conectando el servicio API de TaskBoard a su trabajador en segundo plano. Cuando un usuario crea, mueve o cierra una tarea, el API no debe bloquear el envío de un correo electrónico o una webhook. En su lugar, el API produce un evento task-changed a Kafka y devuelve inmediatamente, mientras que un servicio de trabajador separado consume esos eventos y dispara notificaciones. Esto desconecta el camino de la solicitud de los efectos laterales lentos y le permite escalar el trabajador de forma independiente.

IONOS Event Streams for Apache Kafka ejecuta Apache Kafka 4.0.0, por lo que sus bibliotecas de cliente Kafka existentes funcionan sin cambios. Lo que difiere de un broker autoadministrado es la conexión: el plano de datos requiere autenticación mutua TLS, no SASL o texto plano, y las direcciones del broker y los certificados provienen del Cluster que provisionó en la Unidad 2.5. Esta unidad comienza en la conexión del cliente, luego construye el diseño de tema, la entrega confiable, el manejo de cartas muertas y la escalabilidad del consumidor, todo contra el flujo de eventos de TaskBoard.

1. Conexión de clientes con mTLS

El plano de datos de IONOS Kafka está TLS seguro con autenticación mutua. Ambas partes se autenticican entre sí: su cliente verifica el certificado del broker contra la autoridad de certificación de Cluster, y el broker verifica el certificado del cliente, que la autoridad de certificación de Cluster firma. No hay listener de texto sin formato ni SASL/PLAIN. Cada productor y consumidor presenta un certificado de cliente.

Usted recupera las credenciales, la autoridad de certificación, la clave privada del cliente y el certificado del cliente, desde el punto de acceso de Cluster. Estos son los mismos valores que Cluster expone a través de sus direcciones de broker y acceso API. Cada certificado de cliente es válido durante 365 días, por lo que la rotación de certificados pertenece a su libro de operaciones antes de que termine el año.

1.1 Configuración de la conexión del cliente

Un cliente de Kafka con administración propia utiliza security.protocol=SSL con un almacén de confianza (para la CA de Cluster) y un almacén de claves (para el certificado del cliente y la clave). La documentación de IONOS muestra el archivo de propiedades del cliente canónico. El cliente de Kafka se conecta al plano de datos de IONOS Kafka mediante el punto de acceso de Cluster, y el broker verifica el certificado del cliente, que la autoridad de certificación de Cluster firma, y su cliente verifica el certificado del broker contra la autoridad de certificación de Cluster, y el cliente utiliza las credenciales, la autoridad de certificación, la clave privada del cliente y el certificado del cliente, que se recuperan desde el punto de acceso de Cluster, que son los mismos valores que Cluster expone a través de sus direcciones de broker y acceso, y cada certificado de cliente es válido durante 365 días, por lo que la rotación de certificados pertenece a su libro de operaciones antes de que termine el año, con el cliente que se conecta al plano de datos de IONOS Kafka mediante el punto de acceso de Cluster, y el broker verifica el certificado del cliente, que la autoridad de certificación de Cluster firma, y su cliente verifica el certificado del broker contra la autoridad de certificación de Cluster, con las credenciales, la autoridad de certificación, la clave privada del cliente y el certificado del cliente, que se recuperan desde el punto de acceso de Cluster, que son los mismos valores que Cluster expone a través de sus direcciones de broker y acceso API, y cada certificado de cliente es válido durante 365 días, por lo que la rotación de certificados pertenece a su libro de operaciones antes de que termine el año, con el cliente que utiliza las credenciales, la autoridad de certificación, la clave privada del cliente y el certificado del cliente, que se recuperan desde el punto de acceso de Cluster, que son los mismos valores que Cluster expone a través de sus direcciones de broker y acceso, y el cliente se conecta al plano de datos de IONOS Kafka mediante el punto de acceso de Cluster, con el broker que verifica el certificado del cliente, que la autoridad de certificación de Cluster firma, y su cliente verifica el certificado del broker contra la autoridad de certificación de Cluster, y el cliente utiliza las credenciales, la autoridad de certificación, la clave privada del cliente y el certificado del cliente, que se recuperan desde el punto de acceso de Cluster, que son los mismos valores que Cluster expone a través de sus direcciones de broker y acceso API, con cada certificado de cliente que es válido durante 365 días, por lo que la rotación de certificados pertenece a su libro de operaciones antes de que termine el año, y el cliente se conecta al plano de datos de IONOS Kafka mediante el punto de acceso de Cluster.

security.protocol=SSL
ssl.truststore.type=PKCS12
ssl.truststore.location=ca-cert.p12
ssl.truststore.password=changeit
ssl.endpoint.identification.algorithm=

ssl.keystore.type=PKCS12
ssl.keystore.location=admin.p12
ssl.keystore.password=adminp12pass

Nota ssl.endpoint.identification.algorithm está vacío. Debido a que Cluster utiliza una CA privada en lugar de certificados firmados públicamente, la verificación del nombre de host contra las direcciones del broker está deshabilitada aquí. El almacén de confianza valida la cadena en su lugar.

1.2 Conexión del productor en Python

La biblioteca confluent-kafka acepta las mismas claves SSL. Apunte el cliente a las direcciones del broker desde su salida Terraform y proporcione la CA, el certificado y la clave como archivos PEM.

from confluent_kafka import Producer

# Broker addresses come from the ionoscloud_kafka_cluster Terraform output.
conf = {
    "bootstrap.servers": "192.168.1.101:9093,192.168.1.102:9093,192.168.1.103:9093",
    "security.protocol": "ssl",
    "ssl.ca.location": "ca-cert.pem",
    "ssl.certificate.location": "client-cert.pem",
    "ssl.key.location": "client-key.pem",
    "ssl.endpoint.identification.algorithm": "none",
    "client.id": "taskboard-api",
}

producer = Producer(conf)

El Cluster ejecuta tres brokers en toda la topología de Cluster, así que enumere los tres en bootstrap.servers para la resiliencia de la conexión. El cliente solo necesita un broker accesible para arrancar, pero enumerar los tres evita un solo punto de fallo durante el arranque.

2. Diseño de tema y partición

El diseño de tema es donde las limitaciones específicas de IONOS comienzan a tener efecto. Utilice un tema por tipo de evento en lugar de un tema de firehose único, porque los consumidores se suscriben a los eventos que les interesan y usted puede establecer la retención y la partición por preocupación. Para TaskBoard, usted crea un task-changed tema para el trabajador, y más tarde un task-changed.dlq tema de carta muerta.

2.1 Creación de temas a través del API

El Kafka de gestión API es regional y separado de cloudapi. El host sigue el patrón https://kafka.<region>.ionos.com, y a diferencia del plano de datos, el API de gestión autentica con un token Bearer, no mTLS. Cree un tema con POST /clusters/{clusterId}/topics:

curl -X POST \
  'https://kafka.de-txl.ionos.com/clusters/e69b22a5-8fee-56b1-b6fb-4a07e4205ead/topics' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer '"$IONOS_TOKEN" \
  --data '{
    "properties": {
      "name": "task-changed",
      "replicationFactor": 3,
      "numberOfPartitions": 6,
      "logRetention": { "retentionTime": 604800000 }
    }
  }'

Los parámetros del cuerpo son name (el único campo obligatorio), replicationFactor, numberOfPartitions, y la configuración logRetention. Lea temas con GET /clusters/{clusterId}/topics y GET /clusters/{clusterId}/topics/{topicId}, que devuelven name, replicationFactor, numberOfPartitions, y logRetention. La eliminación es DELETE /clusters/{clusterId}/topics/{topicId} y devuelve 202 Accepted, ya que la eliminación es asíncrona.

2.2 Recuento de particiones y restricciones de replicación

Elija el número de particiones como múltiplo de 3 (3, 6, 9, 12, etc.) para evitar una distribución desigual de particiones en los tres corredores. Un recuento de particiones que no es múltiplo del recuento de corredores deja a un corredor con más particiones que los demás, lo que sesga la carga.

El factor de replicación recomendado es 3, que coincide con la topología de tres corredores, pero esta es una recomendación de IONOS, no un valor predeterminado impuesto por el sistema; debe establecer replicationFactor explícitamente al crear un tema. Con un factor de replicación de 3, el Cluster mantiene tres copias de cada mensaje, por lo que el tema sobrevive a la pérdida de un corredor sin pérdida de datos. La retención de tema predeterminada es 604800000 ms (7 días). Establecer retentionTime en -1 no aplica ningún límite de tiempo, en cuyo caso la retención está limitada solo por el almacenamiento que ha provisionado para el Cluster (por ejemplo, 750 GB en el tamaño S, 1200 GB en el tamaño M).

La siguiente tabla asigna los parámetros del cuerpo del tema a su función al diseñar un tema.

Las particiones son importantes más allá del almacenamiento. El recuento de particiones es el techo duro para el paralelismo del consumidor dentro de un grupo de consumidores, así que tamaño para el rendimiento máximo ahora, ya que aumentar las particiones más adelante cambia el mapeo de clave a partición y perturba las garantías de orden.

3. Confiabilidad del productor

Un productor de fuego y olvido pierde mensajes cuando el corredor de mensajes tiene problemas. Para los eventos de tareas de TaskBoard, donde la pérdida de un evento significa una notificación perdida, configure el productor para la durabilidad antes de optimizar para el rendimiento.

3.1 Acks, idempotencia y claves

Establezca acks=all para que el productor espere a que todos los réplicas sincronizados confirmen una escritura antes de considerarla exitosa. Combinado con un factor de replicación 3, esto significa que un mensaje es duradero en los corredores de mensajes antes de que su código continúe. Active el productor idempotente para que los reintentos no creen duplicados en el lado del corredor de mensajes.

from confluent_kafka import Producer
import json

conf = {
    "bootstrap.servers": "192.168.1.101:9093,192.168.1.102:9093,192.168.1.103:9093",
    "security.protocol": "ssl",
    "ssl.ca.location": "ca-cert.pem",
    "ssl.certificate.location": "client-cert.pem",
    "ssl.key.location": "client-key.pem",
    "ssl.endpoint.identification.algorithm": "none",
    "acks": "all",
    "enable.idempotence": True,
    "retries": 5,
    "linger.ms": 20,
    "batch.size": 65536,
}
producer = Producer(conf)

def on_delivery(err, msg):
    if err:
        # Persist for replay; never silently drop.
        print(f"delivery failed: {err}")
    else:
        print(f"delivered to {msg.topic()} [{msg.partition()}] @ {msg.offset()}")

def emit_task_changed(task_id: str, event: dict):
    producer.produce(
        topic="task-changed",
        key=task_id.encode("utf-8"),   # same task -> same partition -> ordered
        value=json.dumps(event).encode("utf-8"),
        on_delivery=on_delivery,
    )
    producer.poll(0)

Claveando por task_id se enrutan todos los eventos de una tarea a la misma partición, lo que conserva el orden por tarea. Sin una clave, Kafka distribuye los registros de forma round-robin y un evento de "tarea cerrada" podría procesarse antes que "tarea creada".

3.2 Procesamiento por lotes y descarga

linger.ms y batch.size intercambian unos pocos milisegundos de latencia por un rendimiento mucho mayor mediante el procesamiento por lotes de registros por partición. Siempre flush() antes de que el proceso termine, o se pierden los registros almacenados en búfer.

# At shutdown, block until all buffered messages are delivered or fail.
remaining = producer.flush(timeout=10)
if remaining > 0:
    raise RuntimeError(f"{remaining} messages not delivered before shutdown")

4. Grupos de consumidores, desplazamientos y semántica de entrega

El trabajador de TaskBoard lee task-changed como un grupo de consumidores. Cada consumidor en el mismo grupo comparte las particiones, por lo que agregar un trabajador Pods escala el rendimiento hasta el recuento de particiones. Un cuarto consumidor en un tema de 3 particiones permanece inactivo.

4.1 Al menos una vez con confirmaciones manuales

Para la entrega de notificaciones, al menos una vez es el valor predeterminado correcto: procesar el mensaje, luego confirmar el desplazamiento. Si el trabajador se bloquea después de procesar pero antes de confirmar, el mensaje se vuelve a entregar y la notificación puede activarse dos veces, lo que puede hacer seguro con una clave de idempotencia. Lo contrario, confirmar antes de procesar (como máximo una vez), riesgo de perder eventos en caso de bloqueo.

from confluent_kafka import Consumer, KafkaException
import json

conf = {
    "bootstrap.servers": "192.168.1.101:9093,192.168.1.102:9093,192.168.1.103:9093",
    "security.protocol": "ssl",
    "ssl.ca.location": "ca-cert.pem",
    "ssl.certificate.location": "client-cert.pem",
    "ssl.key.location": "client-key.pem",
    "ssl.endpoint.identification.algorithm": "none",
    "group.id": "taskboard-notifier",
    "enable.auto.commit": False,        # manual commit = control over semantics
    "auto.offset.reset": "earliest",
}
consumer = Consumer(conf)
consumer.subscribe(["task-changed"])

while True:
    msg = consumer.poll(1.0)
    if msg is None:
        continue
    if msg.error():
        raise KafkaException(msg.error())
    event = json.loads(msg.value())
    send_notification(event)            # do the work first
    consumer.commit(msg)                # then commit only this offset

enable.auto.commit=False es la elección clave. Auto-commit avanza los desplazamientos en un temporizador independientemente de si el procesamiento tuvo éxito, lo que silencia los mensajes cuyo procesamiento falló.

4.2 Escalabilidad y reequilibrio del consumidor

La cuenta de particiones es el techo de la parallelismo. Para escalar el trabajador de TaskBoard en Managed Kubernetes (ver Unidad 3.2), aumente el recuento de réplicas de implementación hasta la cuenta de particiones, y cada nuevo pod se une al grupo taskboard-notifier y se le asigna un subconjunto de particiones a través de un reequilibrio. Durante un reequilibrio, las particiones dejan de consumirse brevemente, así que mantenga el procesamiento idempotente y los compromisos frecuentes para minimizar la reprocesamiento.

Dimensione las particiones para su recuento de consumidores máximo de antemano. Puede agregar particiones más adelante, pero hacerlo reorganiza el mapeo de clave a partición y rompe el orden para las claves en vuelo.

5. Manejo de cartas muertas y disciplina de esquema

No todos los mensajes pueden ser procesados. Una carga útil mal formada o una interrupción en la parte inferior hará que fallen las retransmisiones, y un mensaje de veneno que se reintenta para siempre bloquea toda su partición.

5.1 Patrón de tema de carta muerta

Ruta los mensajes que agotan sus reintentos a un tema de carta muerta dedicado, task-changed.dlq, luego confirme el desplazamiento original para que la partición principal siga fluyendo. Usted inspecciona la cola de letras muertas más tarde, corrige la causa y, opcionalmente, reproduce.

from confluent_kafka import Producer, Consumer
import json

dlq = Producer(conf_producer)  # same mTLS settings as the main producer

def process_with_dlq(consumer, msg, max_attempts=3):
    attempts = int(dict(msg.headers() or {}).get("x-attempts", b"0") or 0)
    try:
        send_notification(json.loads(msg.value()))
        consumer.commit(msg)
    except Exception as exc:
        if attempts + 1 >= max_attempts:
            dlq.produce(
                "task-changed.dlq",
                key=msg.key(),
                value=msg.value(),
                headers={"x-error": str(exc), "x-attempts": str(attempts + 1)},
            )
            dlq.flush(5)
            consumer.commit(msg)        # advance past the poison message
        else:
            raise                        # let it redeliver for a transient error

Distinga entre fallos transitorios (un tiempo de espera en el servicio de notificación, que merece una reintento) y los permanentes (un evento mal formado, que va directamente a la cola de letras muertas). Reintentar ciegamente fallos permanentes detiene la partición; ciegamente enviar cartas muertas a fallos transitorios pierde eventos recuperables.

5.2 Contratos de eventos con JSON Esquema

Los productores y consumidores se implementan de forma independiente, por lo que la carga útil del evento es un contrato entre ellos. Defínalo con JSON Esquema y valídelo en ambos lados. Evolucione el esquema de forma aditiva: agregue campos opcionales, nunca elimine ni renombre los existentes, para que los consumidores antiguos sigan funcionando mientras los productores nuevos se envían.

import jsonschema

TASK_CHANGED_V1 = {
    "type": "object",
    "required": ["task_id", "action", "occurred_at"],
    "properties": {
        "task_id": {"type": "string"},
        "action": {"enum": ["created", "moved", "closed"]},
        "occurred_at": {"type": "string", "format": "date-time"},
        "assignee": {"type": "string"},   # added in v1.1, optional = safe
    },
    "additionalProperties": False,
}

def validate_event(event: dict):
    jsonschema.validate(event, TASK_CHANGED_V1)  # raises ValidationError on breach

Lleve una versión de esquema en el evento o en un encabezado para que los consumidores puedan ramificarse en él durante una ventana de migración. Esta disciplina es lo que le permite cambiar la forma del evento de TaskBoard sin una reimplementación coordinada y sincronizada de productor y trabajador.

API Tarjeta de referencia rápida

Puntos finales clave para la administración de API de Kafka. El host es regional, por ejemplo https://kafka.de-txl.ionos.com:

Autenticación de administración de API: Authorization: Bearer <token> Autenticación de plano de datos (productores/consumidores): autenticación mutua TLS con certificado de cliente

Laboratorio de código

Objetivo: Producir y consumir eventos de TaskBoard task-changed en un IONOS Kafka Cluster con un grupo de consumidores, confirmaciones de desplazamiento manuales y enrutamiento de carta muerta en caso de fallo.

Requisitos previos:

• Cuenta de IONOS Cloud con token API (IONOS_TOKEN)
• Un Kafka Cluster aprovisionado de la Unidad 2.5 con direcciones de broker disponibles
• Python 3.10+ con confluent-kafka y jsonschema instalados
• El CA de Cluster, el certificado de cliente y la clave de cliente guardados como archivos PEM

Paso 1: Recuperar direcciones de broker y credenciales de acceso

CLUSTER_ID="e69b22a5-8fee-56b1-b6fb-4a07e4205ead"
curl -s -X GET \
  "https://kafka.de-txl.ionos.com/clusters/$CLUSTER_ID" \
  -H "Authorization: Bearer $IONOS_TOKEN" | python3 -m json.tool

No hay texto para traducir.

{
  "id": "e69b22a5-8fee-56b1-b6fb-4a07e4205ead",
  "properties": { "name": "...", "version": "4.0.0", "size": "S",
    "connections": [ { "brokerAddresses": ["192.168.1.101/24", ...] } ] }
}

Paso 2: Crear los temas principales y de carta muerta

for T in task-changed task-changed.dlq; do
  curl -s -X POST "https://kafka.de-txl.ionos.com/clusters/$CLUSTER_ID/topics" \
    -H "Content-Type: application/json" -H "Authorization: Bearer $IONOS_TOKEN" \
    --data "{\"properties\":{\"name\":\"$T\",\"replicationFactor\":3,\"numberOfPartitions\":6}}"
done

No hay texto para traducir.

{"id":"ae085c4c-...","type":"topic","properties":{"name":"task-changed",
 "replicationFactor":3,"numberOfPartitions":6}}

Paso 3: Producir un evento de cambio de tarea

producer.produce("task-changed", key=b"task-42",
    value=b'{"task_id":"task-42","action":"created","occurred_at":"2026-06-05T10:00:00Z"}')
producer.flush(10)
print("produced")

No hay texto para traducir. Por favor, proporcione el texto que desea traducir.

delivered to task-changed [3] @ 0
produced

Paso 4: Consumir con un grupo de consumidores y confirmación manual

consumer.subscribe(["task-changed"])
msg = consumer.poll(5.0)
print(msg.topic(), msg.partition(), msg.offset(), msg.value())
consumer.commit(msg)

No hay texto para traducir.

task-changed 3 0 b'{"task_id":"task-42",...}'

Paso 5: Activar una carta de defunción en una carga útil incorrecta

producer.produce("task-changed", key=b"task-99", value=b'{not valid json')
producer.flush(10)
# Consumer's process_with_dlq routes it to task-changed.dlq after max_attempts

No hay texto para traducir. Por favor, proporcione el texto que desea traducir.

delivered to task-changed.dlq [1] @ 0

Paso 6: Verificar que el tema de carta muerta recibió el mensaje

dlq_consumer.subscribe(["task-changed.dlq"])
m = dlq_consumer.poll(5.0)
print(dict(m.headers()), m.value())

No hay texto para traducir. Por favor, proporcione el texto que desea traducir.

{'x-error': b'...', 'x-attempts': b'3'} b'{not valid json'

Lista de verificación de validación:

• [ ] task-changed y task-changed.dlq temas creados con factor de replicación 3
• [ ] El productor entrega con acks=all y la idempotencia habilitada
• [ ] El consumidor confirma los desplazamientos manualmente después de procesar
• [ ] Un mensaje con formato incorrecto aterriza en el tema de carta muerta, no en un bucle de reintento infinito

Limpieza:

for ID in $(curl -s "https://kafka.de-txl.ionos.com/clusters/$CLUSTER_ID/topics" \
  -H "Authorization: Bearer $IONOS_TOKEN" | python3 -c \
  "import sys,json;[print(t['id']) for t in json.load(sys.stdin)['items']]"); do
  curl -s -X DELETE "https://kafka.de-txl.ionos.com/clusters/$CLUSTER_ID/topics/$ID" \
    -H "Authorization: Bearer $IONOS_TOKEN"
done

Errores comunes

1. Usar SASL o texto sin formato en lugar de mTLS

   • Problema: El cliente se bloquea al conectarse o falla con SSL handshake failed, a pesar de que las credenciales parecen correctas.
   • Por qué sucede: El plano de datos de IONOS solo acepta TLS mutuo. No hay un listener SASL/PLAIN o de texto sin formato, y los brokers utilizan una autoridad de certificación privada, por lo que un almacén de confianza predeterminado los rechaza.
   • Solución: Establecer security.protocol=ssl, proporcionar el certificado de autoridad de certificación Cluster como ssl.ca.location, el certificado del cliente y la clave, y deshabilitar la verificación de nombre de host con ssl.endpoint.identification.algorithm=none.

2. Auto-confirmación silenciosa que descarta mensajes fallidos

   • Problema: Algunas notificaciones de tareas nunca se disparan, pero no aparecen errores en los registros y el retraso del consumidor es cero.
   • Por qué sucede: Con enable.auto.commit=True, los desplazamientos avanzan en un temporizador independientemente de si send_notification tuvo éxito, por lo que un mensaje que generó una excepción se marca como consumido.
   • Solución: Establecer enable.auto.commit=False y llamar consumer.commit(msg) solo después de que el procesamiento tenga éxito, enrutando los fallos permanentes al tema de carta muerta.

3. Recuento de particiones no es múltiplo del recuento de brokers

   • Problema: Un broker muestra una carga de CPU y disco más alta que los otros dos, y el rendimiento se estanca por debajo de las expectativas.
   • Por qué sucede: Con 3 brokers, un tema creado con 4 o 5 particiones se distribuye de manera desigual, por lo que un broker hospeda un líder de partición adicional.
   • Solución: Crear temas con un recuento de particiones que sea múltiplo de 3 (3, 6, 9, 12) para que las particiones se distribuyan uniformemente en los tres brokers.

Resumen

Ahora puede integrar IONOS Event Streams for Apache Kafka en el código de la aplicación como una parte de primera clase de la arquitectura de TaskBoard. Conecta productores y consumidores a través de TLS mutuo utilizando direcciones de brokers y certificados de su Cluster provisionado, crea temas a través de la administración regional API con autenticación Bearer, y diseña la configuración de particiones y réplicas que respetan la topología de tres brokers. Además, tiene un productor confiable con idempotencia y acks=all, un grupo de consumidores con confirmaciones manuales de al menos una vez, un tema de carta muerta para mensajes venenosos, y contratos de esquema JSON que permiten que el productor y el consumidor evolucionen de forma independiente.

Puntos clave:

• El plano de datos de Kafka requiere TLS mutuo con un certificado de cliente; la administración API utiliza tokens Bearer. Son dos modelos de autenticación diferentes en dos puntos de conexión diferentes.
• Los recuentos de particiones de temas deben ser múltiplos de 3 para distribuirse uniformemente entre los tres brokers; el factor de réplica recomendado es 3, pero debe establecerlo explícitamente ya que no es un valor predeterminado impuesto por el sistema.
• La entrega de al menos una vez se logra deshabilitando el auto-compromiso y comprometiendo los desplazamientos solo después del procesamiento exitoso; haga que el procesamiento sea idempotente para tolerar la reentrega.
• El recuento de particiones es el límite superior duro para la paralelización del consumidor; dimensione las particiones para la carga pico antes de implementar, porque agregarlas más tarde interrumpe el orden de clave.
• Los temas de carta muerta aíslan los mensajes venenosos para que una carga útil mala no bloquee su partición, y el esquema JSON hace cumplir el contrato del productor al consumidor.

Terminología importante:

• mTLS (TLS mutuo): Tanto el cliente como el broker se autenticican mutuamente con certificados; el único método de autenticación del plano de datos de IONOS, con certificados de cliente válidos durante 365 días.
• Grupo de consumidores: Un conjunto de consumidores que comparten el trabajo de las particiones de un tema, la unidad de escalado horizontal para el trabajador de TaskBoard.
• Compromiso de desplazamiento: Registrar la posición que un consumidor ha procesado; comprometer después del procesamiento produce una entrega de al menos una vez.
• Tema de carta muerta (DLQ): Un tema separado para los mensajes que fallan el procesamiento después de los reintentos, manteniendo la partición principal desbloqueada.
• Factor de réplica: El número de copias de cada partición en los brokers; 3 en IONOS, que coincide con la topología de tres brokers Cluster, para que el tema sobreviva a la pérdida de un broker, y con TLS, API, JSON, Kafka, y Cluster, y también con TLS, API, y JSON, y finalmente con TLS y Cluster.

Próximos pasos

Continúe aprendiendo: Unidad 4.4: AI Model Hub Integración

Temas relacionados:

• Unidad 2.5: Provisionamiento de base de datos y servicio de transmisión
• Unidad 3.2: Despliegue y operaciones de Kubernetes