Tutoriales de VPS
Kafka KRaft en VPS: TLS explícito, ACL y recuperación de datos
Instale Kafka de un nodo con el parche 4.3 admitido, almacenes TLS explícitos y autenticación controller. Configure rutas y ACL de topics/grupos, pruebe acceso de aplicación y planifique retención, supervisión y recuperación fría.

Cuando varios servicios producen y consumen pagos, logs o eventos de pedidos, las llamadas directas a bases de datos y HTTP pueden acoplarlos. Kafka conserva eventos en un log particionado y reproducible, para que productores y grupos de consumidores independientes trabajen a su ritmo.
La guía usa Ubuntu 24.04, Docker Compose, KRaft, imágenes oficiales, SASL/PLAIN sobre TLS, ACL y almacenamiento persistente. El ejemplo del 15 de septiembre de 2026 utilizaba Kafka 4.3.1. La página oficial consultada el 16 de noviembre enumera 4.4.0, 4.3.2 y 4.2.2 como versiones admitidas y archiva 4.3.1. Se conserva el ejemplo y se añade un override obligatorio para TLS explícito. Para instalación nueva, utilice el parche admitido 4.3.2 después de revisar sus notas.
- Separar pedidos, pagos e inventario mediante eventos.
- Enviar logs o analítica a varios sistemas independientes.
- Guardar offsets y reanudar consumo dentro del historial retenido.
- Permitir que varios grupos lean el mismo topic por separado.
- Paralelizar con particiones y conservar eventos un período definido.
Para tareas individuales, rutas flexibles y confirmación de cada mensaje, RabbitMQ suele ser más sencillo. Kafka resulta útil para reproducción, procesamiento de streams e historial compartido.
| Arquitectura | Ventaja | Limitación | Uso |
|---|---|---|---|
| KRaft de un nodo | Menor coste y operación sencilla | Fallo de host, disco o proceso interrumpe; réplica 1 | Desarrollo o cargas recuperables de poco riesgo |
| Tres contenedores en una VPS | Prueba configuración | Comparte fallos de host, disco y red | Solo laboratorio |
| Nodos independientes | Tres réplicas pueden tolerar una indisponible | Más coste y operación | Servicios críticos |
Combined mode ejecuta broker y controller juntos; la documentación no lo recomienda para despliegues críticos. Diseñe dominios de fallo independientes para brokers y un quorum de 3 o 5 controllers, sin confundir contenedores copiados con HA.
Con tres réplicas, replication.factor=3, min.insync.replicas=2 y acks=all exigen suficientes réplicas sincronizadas antes de confirmar. La confirmación corresponde al ISR actual y su mínimo, no significa que siempre confirmen todas las réplicas configuradas ni constituye una copia.
Kafka 4.x utiliza KRaft, sin ZooKeeper. Admite quorums dinámicos, pero este ejemplo usa controller.quorum.voters estático. Planifique una migración de roles/quorum admitida; no clone datos existentes para crear otro nodo.
Planifique escritura máxima, tamaño de mensajes, particiones, retención, réplicas, reproducción y rendimiento de disco/red.
| Carga | VPS orientativa | Supuesto |
|---|---|---|
| Desarrollo | 2 vCPU, 4GB RAM, 50GB SSD | Heap de 1GB y datos reconstruibles |
| Nodo pequeño | 4 vCPU, 8GB RAM, al menos 100GB NVMe | Heap de 2GB y margen para page cache |
| Clúster crítico | Al menos 3 dominios de broker, 4–8 vCPU/8–16GB por nodo, NVMe independiente | Controllers planificados y pruebas reales |
Son estimaciones. No ocupe toda la RAM con heap: Kafka depende de la caché del sistema. El ejemplo limita contenedor a 4GB y heap a 2GB; con host de desarrollo de 4GB, reduzca heap a cerca de 1GB y ajuste el límite. Evite compartir disco con otra base de alto I/O.
| Puerto | Uso | Exposición |
|---|---|---|
9094/TCP | Cliente SASL_SSL | 127.0.0.1; IP WireGuard para remoto |
19094/TCP | Broker interno | Sin publicar |
29093/TCP | Controller KRaft | Sin publicar |
Restrinja orígenes aun con TLS/ACL. No exponga controllers ni 9092 sin cifrar. Compruebe Docker y reglas del proveedor con la lista de exposición de middleware.
Instale antes Docker Engine y Compose v2 con las instrucciones oficiales para Ubuntu:
sudo apt update
sudo apt full-upgrade -y
sudo apt install -y ca-certificates curl openssl openjdk-21-jre-headless
docker --version
docker compose version
keytool -help >/dev/null
Java del host aporta keytool; la imagen incluye el runtime Kafka. Instale netcat-openbsd para usar nc. Revise reinicios, rotación de logs, límites y recuperación con la lista de Compose para producción.
sudo install -d -m 0750 -o "$USER" -g "$USER" /opt/kafka
cd /opt/kafka
install -d -m 0750 data backups
install -d -m 0700 secrets pki
umask 077
docker run --rm --entrypoint /opt/kafka/bin/kafka-storage.sh \
apache/kafka:4.3.1 random-uuid
Guarde el Cluster ID generado. Cree .env con ese ID, dominio y binding privado:
CLUSTER_ID=请替换为上一步输出
KAFKA_HOST=mq.example.com
KAFKA_BIND_IP=127.0.0.1
Sustituya todo el marcador tras CLUSTER_ID por el valor generado. No genere otro ID al reutilizar datos.
Con WireGuard en 10.66.0.1, configure KAFKA_BIND_IP y haga que mq.example.com resuelva a esa IP desde los clientes. Para pruebas del listener externo en modo loopback, el hostname debe resolver a loopback en la VPS.
Genere credenciales hexadecimales en la misma sesión:
ADMIN_PASSWORD="$(openssl rand -hex 32)"
APP_PASSWORD="$(openssl rand -hex 32)"
STORE_PASSWORD="$(openssl rand -hex 24)"
printf '%s\n' "$STORE_PASSWORD" > secrets/kafka_keystore_creds
printf '%s\n' "$STORE_PASSWORD" > secrets/kafka_ssl_key_creds
printf '%s\n' "$STORE_PASSWORD" > secrets/kafka_truststore_creds
printf 'KafkaServer {\n org.apache.kafka.common.security.plain.PlainLoginModule required\n username="admin"\n password="%s"\n user_admin="%s"\n user_app="%s";\n};\n' \
"$ADMIN_PASSWORD" "$ADMIN_PASSWORD" "$APP_PASSWORD" \
> secrets/broker_jaas.conf
Reserve admin para operación y app para aplicaciones. PLAIN no cifra contraseñas: exige TLS. Mantenga JAAS, propiedades y .env privados. Guarde la contraseña de aplicación antes de cerrar la sesión.
Incluya el hostname del contenedor kafka y el de los clientes mq.example.com:
cd /opt/kafka/pki
openssl genrsa -out ca.key 4096
openssl req -x509 -new -sha256 -days 3650 \
-key ca.key \
-subj '/CN=Kafka Internal CA' \
-out ca.crt
openssl genrsa -out broker.key 4096
openssl req -new -sha256 \
-key broker.key \
-subj '/CN=mq.example.com' \
-out broker.csr
printf '%s\n' \
'subjectAltName=DNS:kafka,DNS:mq.example.com' \
'extendedKeyUsage=serverAuth' > broker.ext
openssl x509 -req -sha256 -days 825 \
-in broker.csr \
-CA ca.crt \
-CAkey ca.key \
-CAcreateserial \
-extfile broker.ext \
-out broker.crt
openssl pkcs12 -export \
-name kafka-broker \
-in broker.crt \
-inkey broker.key \
-certfile ca.crt \
-out /opt/kafka/secrets/kafka.keystore.p12 \
-passout "pass:$STORE_PASSWORD"
keytool -importcert -noprompt \
-alias kafka-ca \
-file ca.crt \
-keystore /opt/kafka/secrets/kafka.truststore.p12 \
-storetype PKCS12 \
-storepass "$STORE_PASSWORD"
El DNS real debe aparecer en SAN y KAFKA_HOST. No monte ni distribuya ca.key; entregue CA o truststore a clientes y controle caducidad.
Cree propiedades de administrador para el health check:
printf 'security.protocol=SASL_SSL\nsasl.mechanism=PLAIN\nsasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="admin" password="%s";\nssl.truststore.location=/etc/kafka/secrets/kafka.truststore.p12\nssl.truststore.type=PKCS12\nssl.truststore.password=%s\n' \
"$ADMIN_PASSWORD" "$STORE_PASSWORD" \
> /opt/kafka/secrets/client-admin.properties
chmod 600 /opt/kafka/.env /opt/kafka/secrets/*
sudo chown -R 1000:1000 /opt/kafka/data /opt/kafka/secrets
Confirme UID/GID de la imagen antes de aplicar 1000:1000. El proceso sin privilegios necesita atravesar el directorio secrets y leer sus archivos 600; no los haga públicos para resolver permisos.
Cree /opt/kafka/compose.yml:
services:
kafka:
image: apache/kafka:4.3.1
container_name: kafka
hostname: kafka
restart: unless-stopped
ports:
- "${KAFKA_BIND_IP:-127.0.0.1}:9094:9094"
volumes:
- ./data:/var/lib/kafka/data
- ./secrets:/etc/kafka/secrets:ro
environment:
CLUSTER_ID: ${CLUSTER_ID}
KAFKA_NODE_ID: 1
KAFKA_PROCESS_ROLES: broker,controller
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,INTERNAL:SASL_SSL,EXTERNAL:SASL_SSL
KAFKA_LISTENERS: CONTROLLER://:29093,INTERNAL://:19094,EXTERNAL://:9094
KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka:19094,EXTERNAL://${KAFKA_HOST}:9094
KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka:29093
KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL
KAFKA_SASL_ENABLED_MECHANISMS: PLAIN
KAFKA_SASL_MECHANISM_INTER_BROKER_PROTOCOL: PLAIN
KAFKA_OPTS: -Djava.security.auth.login.config=/etc/kafka/secrets/broker_jaas.conf
KAFKA_SSL_KEYSTORE_FILENAME: kafka.keystore.p12
KAFKA_SSL_KEYSTORE_TYPE: PKCS12
KAFKA_SSL_KEYSTORE_CREDENTIALS: kafka_keystore_creds
KAFKA_SSL_KEY_CREDENTIALS: kafka_ssl_key_creds
KAFKA_SSL_TRUSTSTORE_FILENAME: kafka.truststore.p12
KAFKA_SSL_TRUSTSTORE_TYPE: PKCS12
KAFKA_SSL_TRUSTSTORE_CREDENTIALS: kafka_truststore_creds
KAFKA_SSL_CLIENT_AUTH: none
KAFKA_AUTHORIZER_CLASS_NAME: org.apache.kafka.metadata.authorizer.StandardAuthorizer
KAFKA_SUPER_USERS: User:admin
KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "false"
KAFKA_LOG_DIRS: /var/lib/kafka/data
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
KAFKA_SHARE_COORDINATOR_STATE_TOPIC_REPLICATION_FACTOR: 1
KAFKA_SHARE_COORDINATOR_STATE_TOPIC_MIN_ISR: 1
KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
KAFKA_HEAP_OPTS: -Xms2g -Xmx2g
KAFKA_LOG_RETENTION_HOURS: 168
healthcheck:
test:
- CMD-SHELL
- /opt/kafka/bin/kafka-broker-api-versions.sh --bootstrap-server kafka:19094 --command-config /etc/kafka/secrets/client-admin.properties >/dev/null 2>&1
interval: 30s
timeout: 10s
retries: 10
start_period: 60s
mem_limit: 4g
cpus: 2.0
ulimits:
nofile:
soft: 100000
hard: 100000
logging:
driver: json-file
options:
max-size: 10m
max-file: "5"
El listener controller es interno. KAFKA_ADVERTISED_LISTENERS indica a los clientes dónde reconectar tras bootstrap; errores de DNS, dominio o puerto explican fallos después de conectar inicialmente.
No arranque solo esta definición. El script oficial detecta SSL por nombres anunciados que contienen SSL; INTERNAL/EXTERNAL no activan ese atajo. Las variables de nombres de archivo no bastan para definir rutas y contraseñas de los almacenes. Además, un controller sin cifrar usaría un principal anónimo con ACL activas.
Guarde una vez la contraseña ya generada en el archivo restringido:
cd /opt/kafka
printf 'KAFKA_TLS_STORE_PASSWORD=%s\n' "$(sudo cat secrets/kafka_keystore_creds)" >> .env
chmod 600 .env
Cree compose.override.yml para la instalación nueva del parche admitido:
services:
kafka:
image: apache/kafka:4.3.2
environment:
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:SASL_SSL,INTERNAL:SASL_SSL,EXTERNAL:SASL_SSL
KAFKA_SASL_MECHANISM_CONTROLLER_PROTOCOL: PLAIN
KAFKA_SSL_KEYSTORE_LOCATION: /etc/kafka/secrets/kafka.keystore.p12
KAFKA_SSL_KEYSTORE_PASSWORD: ${KAFKA_TLS_STORE_PASSWORD:?store password required}
KAFKA_SSL_KEY_PASSWORD: ${KAFKA_TLS_STORE_PASSWORD:?store password required}
KAFKA_SSL_TRUSTSTORE_LOCATION: /etc/kafka/secrets/kafka.truststore.p12
KAFKA_SSL_TRUSTSTORE_TYPE: PKCS12
KAFKA_SSL_TRUSTSTORE_PASSWORD: ${KAFKA_TLS_STORE_PASSWORD:?store password required}
El controller usa la identidad admin de KafkaServer JAAS y confía en el certificado de kafka. En clústeres existentes, revise compatibilidad de versión y cambio de listeners. Para desarrollo con 4GB, añada heap -Xms1g -Xmx1g y reduzca límite del contenedor; el heap de 2GB corresponde al host mayor.
Valide sin mostrar secretos y arranque:
cd /opt/kafka
docker compose config --quiet
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=100 kafka
Cree orders con tres particiones y una réplica:
docker exec kafka /opt/kafka/bin/kafka-topics.sh \
--bootstrap-server kafka:19094 \
--command-config /etc/kafka/secrets/client-admin.properties \
--create \
--topic orders \
--partitions 3 \
--replication-factor 1
Conceda permisos de topic y grupo:
docker exec kafka /opt/kafka/bin/kafka-acls.sh \
--bootstrap-server kafka:19094 \
--command-config /etc/kafka/secrets/client-admin.properties \
--add --allow-principal User:app \
--operation Read --operation Write --operation Describe \
--topic orders
docker exec kafka /opt/kafka/bin/kafka-acls.sh \
--bootstrap-server kafka:19094 \
--command-config /etc/kafka/secrets/client-admin.properties \
--add --allow-principal User:app \
--operation Read \
--group orders-workers
Prepare propiedades de aplicación a partir de client-admin.properties, usando app y APP_PASSWORD. Mantenga security.protocol=SASL_SSL, sasl.mechanism=PLAIN y CA fiable. Los clientes fuera del contenedor necesitan la ruta local de su truststore. No use ssl.endpoint.identification.algorithm= para desactivar comprobación del hostname.
Esta prueba de administrador comprueba entrega básica:
printf 'order.created id=1001\n' | docker exec -i kafka \
/opt/kafka/bin/kafka-console-producer.sh \
--bootstrap-server kafka:19094 \
--producer.config /etc/kafka/secrets/client-admin.properties \
--topic orders
docker exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
--bootstrap-server kafka:19094 \
--consumer.config /etc/kafka/secrets/client-admin.properties \
--topic orders \
--from-beginning \
--max-messages 1
Repita con propiedades de aplicación y grupo explícito orders-workers; un grupo aleatorio no coincide con su ACL. Compruebe también denegación en topics ajenos y operaciones administrativas. La prueba de admin no valida permisos de aplicación.
Use acks=all en productores. Comprenda idempotencia, transacciones, permisos y orden de claves; conceda solo privilegios documentados. Enviar correctamente no demuestra que el proceso de negocio haya terminado.
La retención del ejemplo es 168 horas. Elimina historial, no archiva permanentemente. Estime almacenamiento como MB/s máximos × 86400 × días retenidos × réplicas:
峰值写入 MB/s × 86400 × 保留天数 × 副本数
Reserve margen para índices, segmentos, reproducción y limpieza retrasada. Un uso sostenido de 70%–80% reduce la capacidad de absorber compactación o consumidores lentos.
Ajuste particiones a consumidores y rendimiento. Solo pueden aumentarse, no reducirse directamente; aumentar puede cambiar la distribución de claves y el orden esperado.
JMX remoto no se publica por defecto. Use JMX Exporter como agente Java y Prometheus en endpoints privados:
UnderReplicatedPartitionsyUnderMinIsrPartitionCount.- Controller activo, colas de eventos y fallos de elección.
- Latencia, errores y BytesIn/BytesOut.
- Lag máximo y tasa de procesamiento por grupo.
- GC, heap, proceso y descriptores.
- Disco, inodes, latencia I/O y pérdida de red.
Con un broker, UnderReplicatedPartitions=0 no garantiza disponibilidad del host. Combine alertas de Kafka y VPS con Prometheus y Grafana.
La replicación mejora disponibilidad, pero propaga borrados y errores. Detenga productores/consumidores y tome una copia del nodo parado:
cd /opt/kafka
docker compose stop kafka
sudo tar -C /opt/kafka -czf \
"backups/kafka-data-$(date +%F-%H%M%S).tar.gz" \
data
docker compose start kafka
Confirme el tar, restrinja permisos, cifre y copie fuera del host. Incluye logs y metadatos KRaft solo si todos sus directorios están dentro de la ruta respaldada; revise montajes personalizados.
Copie aparte y cifrados entorno, Compose/override, JAAS, CA, almacenes y propiedades. Restaure en una instancia aislada y parada con Cluster ID original, configuración, metadatos y permisos. No reformatee datos existentes. Use versiones compatibles, compruebe topics, eventos y offsets y pruebe clientes antes de redirigir tráfico.
Para RPO/RTO bajos, planifique otro clúster con MirrorMaker 2 y checkpoints de grupos. Compruebe filtros, sincronización de offsets y conmutación; no ofrece automáticamente pérdida cero ni sustituye archivos independientes.
Lea notas y compatibilidad de clientes, plugins, Connect y protocolos. Un nodo necesita mantenimiento y copia fría:
cd /opt/kafka
docker compose config --quiet
docker compose exec kafka /opt/kafka/bin/kafka-topics.sh \
--bootstrap-server kafka:19094 \
--command-config /etc/kafka/secrets/client-admin.properties \
--list
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail=100 kafka
Cambie la imagen/override antes de descargar: la misma etiqueta no cambia de versión. Evite latest. Siga la secuencia de metadatos y feature versions KRaft; tras cambios irreversibles, restaure una copia anterior compatible en lugar de asumir downgrade.
Revise advertised.listeners:
getent hosts mq.example.com
nc -vz mq.example.com 9094
Pruebe DNS y rutas desde el cliente, reglas del proveedor y bindings Docker con la guía de acceso a puertos.
Examine SAN y cadena:
openssl s_client -connect mq.example.com:9094 \
-servername mq.example.com \
-showcerts </dev/null
Muestra certificados; para verificarlos añada CA, -verify_hostname real y -verify_return_error. Corrija certificado/DNS, no desactive validación.
Utilice PLAIN y SASL_SSL. La clave JAAS ilustrada en user_用户名 debe ser user_app o user_admin real. Recargue configuración tras editar broker_jaas.conf. Prepare nuevas credenciales y clientes probados antes de retirar las antiguas.
No cambie CLUSTER_ID en .env si reutiliza datos. Detenga y compare meta.properties, configuración y copias. Reformatear datos empresariales destruye información de recuperación.
cd /opt/kafka
docker compose logs --tail=200 kafka
namei -l /opt/kafka/data /opt/kafka/secrets
sudo chown -R 1000:1000 /opt/kafka/data /opt/kafka/secrets
Confirme UID/GID antes de chown, ajustes TLS explícitos, permisos de directorios, espacio y logs.
No; usa KRaft. No mezcle configuraciones antiguas ZooKeeper.
Para desarrollo ligero, heap cercano a 1GB y límites estrictos de disco/retención. Producción pequeña suele requerir 8GB/NVMe y medición real.
Solo si admite parada y recuperación. Servicios críticos necesitan dominios independientes y quorum diseñado; combined mode no se recomienda.
Prefiera VPN/red privada, SASL_SSL, ACL y restricciones de origen. Separe controllers de redes de clientes.
Úselo únicamente sobre TLS; evalúe SCRAM, OAuthBearer o autenticación externa.
No: añada copias, archivo independiente o replicación entre clústeres y ensaye recuperación.