Message Middleware: Conociendo a Kafka por primera vez

1. Introducción a Kafka

1.1, cola de mensajes

1.1.1 ¿Por qué hay una cola de mensajes?

1.1.2, cola de mensajes

• Mensaje
  Los datos transmitidos entre dos computadoras o dos dispositivos de comunicación en una red de mensajes. Por ejemplo: texto, música, vídeo y otros contenidos.
• Queue Queue
  es una tabla lineal especial (elementos de datos de un extremo a otro), que tiene la particularidad de que solo permite eliminar elementos al principio y agregar elementos al final (FIFO).
  Dentro del equipo, fuera del equipo.
• Cola de mensajes Mensaje MQ
  + cola, una cola para guardar mensajes. El contenedor en el proceso de transmisión de mensajes; proporciona principalmente interfaces de producción y consumo para llamadas externas para almacenar
  y obtener datos.

1.1.3 Clasificación de colas de mensajes

MQ se divide principalmente en dos categorías: p2p punto a punto, suscripción de publicación (Pub / Sub)

• Peer-to-Peer generalmente recibe datos basándose en Pull o Polling. El mensaje enviado a la cola es aceptado por un solo receptor.
  Incluso si Método de entrega de mensajes "Recibir", también admite
  el método de transmisión sincrónica de solicitud/respuesta.
  

• Publicar y suscribirse Los mensajes publicados en el mismo tema pueden ser recibidos por múltiples suscriptores. La publicación/suscripción puede consumir datos basados ​​en Push o consumir
  datos basados ​​en Pull o Polling. La capacidad de desacoplamiento es más fuerte que el modelo P2P.
  

1.1.4 Comparación entre p2p y MQ de publicación-suscripción

• Puntos comunes
  Los productores de mensajes envían mensajes a la cola y luego los consumidores leen y consumen mensajes de la cola.
• Diferencias
  El modelo p2p incluye: cola de mensajes (Queue), remitente (Sender), receptor (Receiver)
  Un mensaje producido por un productor tiene un solo consumidor (Consumer) (es decir, una vez consumido, el mensaje no está en el cola de mensajes). Por ejemplo, haga una
  llamada telefónica.
  pub / Sub incluye: cola de mensajes (Cola), tema (Tema), editor (Editor), suscriptor (Suscriptor). Cada
  mensaje puede tener múltiples consumidores, que no se afectan entre sí. Por ejemplo, si publico un Weibo: cualquiera que me siga puede verlo.

1.1.5, el escenario de uso del sistema de mensajes

• Desacoplamiento Los sistemas intercambian datos a través de la interfaz unificada del sistema de mensajes sin conocer la existencia de cada uno.
• Redundancia Parte del sistema de mensajes tiene capacidad de persistencia de mensajes, lo que puede evitar el riesgo de pérdida de mensajes antes de procesarlos.
• Expansión El sistema de mensajes es una interfaz de datos unificada y cada sistema se puede expandir de forma independiente.
• Capacidad máxima de procesamiento El sistema de mensajes puede soportar el tráfico máximo y el sistema empresarial puede obtener y procesar la cantidad correspondiente de solicitudes del sistema de mensajes de acuerdo con la capacidad de procesamiento.
• Recuperabilidad La falla de algunas claves en el sistema no afectará a todo el sistema y aún podrá obtener y procesar datos del sistema de mensajes cuando se recupere.
• Comunicación asincrónica En el escenario donde no es necesario procesar la solicitud de inmediato, la solicitud se puede colocar en el sistema de mensajes y procesar cuando sea apropiado.

1.1.6, sistema de mensajes común

• RabbitMQ escrito en Erlang, admite multiprotocolo AMQP, XMPP, SMTP, STOMP. Admite equilibrio de carga y persistencia de datos.
  Se admiten los modos de igual a igual y de publicación/suscripción .
• Redis se basa en la base de datos NoSQL de pares clave-valor y al mismo tiempo admite la función MQ, que se puede utilizar como un servicio de cola ligero. En lo que respecta a las operaciones de puesta en cola,
  Redis funciona mejor que RabbitMQ para mensajes cortos (menos de 10 kb) y peor que RabbitMQ para mensajes largos.
• ZeroMQ es liviano y no requiere un servidor de mensajes o middleware separado. La aplicación en sí desempeña el papel de Peer-to-Peer. Es esencialmente
  una biblioteca, que requiere que los desarrolladores combinen múltiples tecnologías por sí mismos, lo cual es muy complejo de usar.
• Implementación ActiveMQ JMS, Peer-to-Peer, admite persistencia, transacciones XA (distribuidas)
• Kafka /Jafka es un sistema de mensajes de publicación/suscripción distribuido en varios idiomas de alto rendimiento, persistencia de datos, totalmente distribuido y admite procesamiento tanto en línea como fuera de línea.
• Implementación de Java puro de MetaQ/RocketMQ , sistema de mensajes de publicación/suscripción, soporte para transacciones locales y transacciones distribuidas XA

1.2 Introducción a Kafka

1.2.1 Introducción

Kafka es un sistema distribuido de mensajería de publicación y suscripción . Fue publicado originalmente por LinkedIn, escrito en lenguaje Scala y
de código abierto en diciembre de 2010, convirtiéndose en el proyecto de nivel superior de Apache. Kafka es un sistema de mensajería de publicación-suscripción distribuido, persistente y de alto rendimiento. Se utiliza principalmente para procesar
datos activos en vivo (datos generados por comportamientos del usuario como iniciar sesión, navegar, hacer clic, compartir, dar me gusta, etc.).

Tres características principales de Kafka:

• El alto rendimiento
  puede satisfacer la producción y el consumo de millones de mensajes por segundo: consumo de producción.
• Persistencia
  Existe un mecanismo completo de almacenamiento de mensajes para garantizar la persistencia eficiente y segura de los datos: almacenamiento intermedio.
• Distribuido
  Basado en un mecanismo de expansión distribuida y tolerancia a fallas, los datos de Kafka se copiarán a varios servidores. Cuando una falla, los productores y consumidores
  cambian a otras máquinas:
  robustez general.

1.2.2 Objetivos de diseño

• Alto rendimiento : una sola máquina puede soportar la lectura y escritura de 1 millón de mensajes por segundo en una máquina comercial barata.
• Persistencia de mensajes Todos los mensajes se conservan en el disco, no se pierde ningún mensaje y se admite la reproducción de mensajes.
• Productor, Corredor y Consumidor totalmente distribuidos apoyan la expansión horizontal
• Adáptese tanto al procesamiento de secuencias en línea como al procesamiento por lotes fuera de línea

1.2.3 El concepto central de Kafka

¿Qué piezas necesita un MQ? Produzca, consuma, envíe clases de mensajes, almacene y más. Para Kafka, el servicio Kafka es como una gran piscina.
Producir, almacenar y consumir constantemente varios tipos de mensajes. ¿En qué consiste entonces Kafka?

Servicio Kafka:

• Tema: tema, diferentes categorías de mensajes procesados ​​por Kafka.
• Agente: agente del servidor de mensajes, un nodo de servicio Kafka en el clúster de Kafka se denomina agente y almacena principalmente datos de mensajes. almacenados en el
  disco duro. Cada tema está dividido.
• Partición: agrupación física de temas, un tema se divide en una o más particiones en el intermediario y las particiones se especifican al crear el tema
  .
• Mensaje: mensaje, que es la unidad básica de comunicación, y cada mensaje pertenece a una partición

Relacionado con el servicio Kafka

• Productor: El productor de mensajes y datos, publica mensajes en un tema de Kafka.
• Consumidor: Consumidor de mensajes y datos, asignado a un tema y procesa sus mensajes publicados.
• Zookeeper: Coordina el funcionamiento normal de Kafka.

2. Instalación distribuida de Kafka

Dirección de descarga: https://kafka.apache.org/downloads
Sitio web oficial de descarga en chino: https://kafka.apachecn.org/downloads.html
Enlace del paquete de instalación: https://pan.baidu.com/s/1G9F8TEfI88wPi_j2- hkK1A ?pwd=e9tu
enlace del paquete fuente: https://pan.baidu.com/s/1LR7X3Is-JRsOOu3DdAp2aw?pwd=7249

2.1 instalación de jdk y zookeeper

Sabemos que Kafka es administrado por Zookeeper, así que antes de instalar Kafka, instalemos Zookeeper ~

1. configuración de instalación de jdk

En primer lugar, CentOS7 viene con jdk de forma predeterminada. En mi máquina virtual, centos7 viene con jdk 1.8.0_262_b10 abierto de forma predeterminada.

Si desea instalar una versión específica de jdk, primero descargue el paquete de instalación de jdk.
Pasos detallados para instalar jdk en Linux

2. instalación del cuidador del zoológico

Mi paquete de instalación de Kafka es la versión 3.4.0 y la versión correspondiente de Zookeeper es 3.6.3, así que vaya al sitio web oficial para descargar el paquete comprimido (tenga en cuenta que es un paquete comprimido bin.tar.gz): Sitio web oficial: http :
//archive.apache.org/dist/zookeeper/ _

Primero, coloque el paquete de instalación en el directorio de Linux y ejecute el siguiente comando:

$ mkdir zk
# 创建Zookeeper数据存储路径
$ mkdir zk/data
# 创建Zookeeper日志存放路径
$ mkdir zk/logs
# 解压安装包
$ tar -zxvf apache-zookeeper-3.8.1-bin.tar.gz
# 配置环境变量,添加下述内容
$ vi /etc/profile
export ZK_HOME=/home/install_package/apache-zookeeper-3.8.1-bin/bin
export PATH=$ZK_HOME/bin:$PATH
$ source /etc/profile
# 生成Zookeeper配置文件
$ cd apache-zookeeper-3.8.1-bin/conf
$ cp zoo_sample.cfg zoo.cfg   # 因为zookeeper默认加载的配置文件名是zoo.cfg

Luego modifique la configuración (directorio de datos y directorio de registro):

vim zoo.cfg

# 心跳间隔时间，时间单位为毫秒值
tickTime=2000
# leader与客户端连接超时时间，设为5个心跳间隔
initLimit=10
# Leader与Follower之间的超时时间，设为2个心跳间隔
syncLimit=5
# 数据存放目录
dataDir=/home/admin/Study/zk/data
# 日志存放目录
dataLogDir=/home/admin/Study/zk/logs
# 客户端通信端口
clientPort=2181
# 清理间隔，单位是小时，默认是0，表示不开启
#autopurge.purgeInterval=1
# 这个参数和上面的参数搭配使用，这个参数指定了需要保留的文件数目，默认是保留3个
#autopurge.snapRetainCount=5
# 单机版不配下述配置
# server.NUM=IP:port1:port2 NUM表示本机为第几号服务器；IP为本机ip地址；
# port1为leader与follower通信端口；port2为参与竞选leader的通信端口
# 多个实例的端口配置不能重复，如下：
#server.0=192.168.101.136:12888:13888
#server.1=192.168.101.146:12888:13888

1. Inicie el servicio en segundo plano del cuidador del zoológico:

zkServer.sh start

2. Cierre el servicio en segundo plano del cuidador del zoológico:

zkServer.sh stop

3. Vea el estado de ejecución del servicio en segundo plano del cuidador del zoológico:

zkServer.sh status

2.2, pasos de instalación de Kafka

1. Primero, en el directorio donde se encuentra el paquete comprimido Kafka en Linux, descomprima:

$ mkdir kafka
# 创建kafka日志存放路径
$ mkdir kafka/logs
# 解压安装包
$ tar -zxvf kafka_2.12-3.4.0.tgz
# 移动到kafka目录下
mv kafka_2.12-3.4.0 kafka
# 配置环境变量,添加下述内容
$ vi /etc/profile
export KAFKA_HOME=/home/admin/Study/kafka/kafka_2.12-3.4.0
export PATH=$KAFKA_HOME/bin:$PATH
$ source /etc/profile
# 修改kafka配置
$ cd kafka_2.12-3.4.0/config
$ vi server.properties

Modificar la configuración de Kafka

# broker.id每个实例的值不能重复
broker.id=0
# 配置主机的ip和端口
#listeners=PLAINTEXT://:9092
listeners=PLAINTEXT://192.168.57.30:9092
#advertised.listeners=PLAINTEXT://10.11.0.203:9092
# 配置日志存储路径
log.dirs=/home/admin/Study/kafka/logs
# 配置zookeeper集群
zookeeper.connect=localhost:2181

Inicie Kafka, bajo la premisa de que zkeeper inicia:

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

Juzgando que Kafka comenzó con éxito:

cierre de kafka:

bin/kafka-server-stop.sh -daemon config/server.properties

3. Clúster de Kafka

Prepare tres máquinas virtuales. Aquí, se clonan directamente dos copias de la máquina virtual instalada anteriormente.
El proceso de clonación es muy sencillo y no lo repetiremos aquí. A continuación, echemos un vistazo a qué cambios de configuración se necesitan después de la clonación.

3.1, modificación de la configuración de la máquina clonadora

① Modifique el nombre del host
Cierre todas las máquinas virtuales, abra la primera clonada y modifique el nombre del host a kafka02:

vim /etc/hostname

② Modificar la dirección de red

vim /etc//sysconfig/network-scripts/ifcfg-ens33

③ Reiniciar:

reboot

Otra modificación del mismo modo:

Nombre de host: kafka03
dirección IP: 192.168.255.214

(Digresión: modifique el color de fondo y el color de fuente de la línea de comando)

Abra la línea de comando --> Editar --> Preferencias --> Colores: Desmarque Usar colores del tema del sistema

④ Vaya al directorio de instalación de Kafka y modifique el archivo de configuración kafka server.properties:

vim config/server.properties

corredor.id

Este atributo se utiliza para marcar de forma única un Kafka Broker y su valor es un valor entero arbitrario.
Esto es especialmente importante cuando Kafka se ejecuta en un clúster distribuido.
Es mejor que el valor esté relacionado con el host físico donde se encuentra el Broker. Por ejemplo, si el nombre de host es host1.lagou.com, entonces broker.id=1, si el nombre de host es 192.168.100.101, entonces broker. .id=101 y así sucesivamente.

oyentes

Se utiliza para especificar la dirección y el puerto del Broker actual para publicar servicios al mundo exterior.
Coopere con los oyentes anunciados para aislar las redes internas y externas.

Configuración de aislamiento de red interna y externa:

• oyente.seguridad.protocolo.mapa

Configuración de mapeo para nombres de oyentes y protocolos de seguridad.

Por ejemplo, las redes interna y externa se pueden aislar incluso si ambas usan SSL.

• listener.security.protocol.map=INTERNO:SSL,EXTERNO:SSL

El nombre de cada oyente solo puede aparecer una vez en el mapa.

• inter.broker.nombre.oyente

Se utiliza para configurar el nombre del oyente utilizado para la comunicación entre intermediarios, y el nombre debe estar en la lista de oyentes anunciados.

• inter.broker.listener.name=EXTERNO

• oyentes

Una lista de URI y nombres de oyentes utilizados para configurar la supervisión del intermediario. Utilice comas para separar varios URI y nombres de oyentes.

Si el nombre del oyente no representa un protocolo de seguridad, se debe configurar listener.security.protocol.map.

Cada oyente debe utilizar un puerto de red diferente.

• anunciado.oyentes

La dirección debe publicarse en zookeeper para que la use el cliente, si la dirección utilizada por el cliente es diferente de la configuración de los oyentes.

Se puede encontrar en get /myKafka/brokers/ids/<broker.id> del cuidador del zoológico.

En un entorno IaaS, la interfaz de red de esta entrada debe ser diferente de la interfaz de red vinculada al intermediario.

Si esta entrada no está configurada, se utiliza la configuración de oyentes. A diferencia de los oyentes, esta entrada no puede utilizar el puerto de red 0.0.0.0.

La dirección de los oyentes anunciados debe estar configurada o ser parte de la configuración en los oyentes.

cuidador del zoológico.conectar

Este parámetro se utiliza para configurar la dirección del Zookeeper/clúster al que se conectará Kafka.

Su valor es una cadena y utiliza comas para separar varias direcciones de Zookeeper. La dirección única de Zookeeper tiene el formato host: puerto, y la ruta del nodo raíz de Kafka en Zookeeper se puede agregar al final.

3.2 Inicio del clúster Kafka

1. Inicio del cuidador del zoológico

zkServer.sh start

2. El comienzo de Kafka

Orden:

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

El siguiente mensaje de error:

Se debe a que broker.id en el archivo meta.properties de la carpeta de registros en el directorio kafka no es consistente con el de server.properties, simplemente modifíquelo.

Comenzó con éxito:

3.3, comando de operación kafka

Consulte el sitio web oficial para un inicio rápido: Documentación china de Kafka

1. Ver el tema

(El Kafka recién instalado no tiene tema)

bin/kafka-topics.sh --list --bootstrap-server 192.168.255.212:9092

2. Crea un tema:

2.1. Crear un tema llamado "prueba", que tenga una partición y una réplica.

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

Consulte el tema en este momento:

también puede verlo en los otros dos hosts de Kafka:


en este momento, verificamos el directorio de registros de los tres Kafka:



puede ver el tema de prueba creado.

2.2 Prueba Cree un tema nuevamente, configure la partición en 3 (preferiblemente consistente con la cantidad de hosts):

bin/kafka-topics.sh --create --bootstrap-server 192.168.255.212:9092 --replication-factor 1 --partitions 3 --topic city

Puede ver que cada una de las tres máquinas tiene una partición de tema en el directorio de registros.

2.3 Cree las ciudades temáticas, el factor de replicación es 2 y la partición es 3

Orden:

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

Verifique el directorio de registro y podrá ver que hay tres particiones, cada una con dos copias :

3. Eliminar el tema

bin/kafka-topics.sh --delete --bootstrap-server 192.168.255.212:9092 --topic 主题名

4. Iniciar el productor/consumidor

El siguiente comando: cree un cliente productor, genere mensajes y el asunto es prueba. Tenga en cuenta que el cliente productor se puede ejecutar en cualquier host siempre que se incluya kafka y el comando exista. Actualmente, en el kafka de 213, actúa como servidor y cliente.

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

Ingresa e ingresa el mensaje:

>Beijing
>Shanghai

Ahora inicie un consumidor:

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

Agregar –desde el principio al final significa aceptar todos los mensajes anteriores; no agregar significa aceptar solo las últimas noticias, y el pasado (antes de que el consumidor comience) no será aceptado.


En este punto, se genera un mensaje de saludo:

dos consumidores reciben:

Nota: los consumidores pueden recibir mensajes sin importar qué IP consuman ~

4. Zokeeper ver el registro de Kafka

Ejecutamos los comandos de operación anteriores en secuencia y vemos los temas generados en el directorio de registros de Kafka. De hecho, también podemos comprobarlo en zookeeper.
Comando:
ingrese al directorio bin del cuidador del zoológico

zkCli.sh

ls /

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

Abra brokerid = 0 para ver el contenido de los datos:

ls /brokers/ids/0
get /brokers/ids/0

Puede ver la información del host actual y almacenarla en formato json.

Mira el tema a continuación:

ls /brokers/topics/cities
ls /brokers/topics/cities/partitions
ls /brokers/topics/cities/partitions/0
ls /brokers/topics/cities/partitions/0/state
get /brokers/topics/cities/partitions/0/state

get /brokers/topics/cities

El host 0 tiene particiones ciudades-1 y ciudades-2.

Del mismo modo, también se pueden ver otras partes:

---

segmento segmento

Un segmento es un concepto lógico que consta de dos tipos de archivos físicos, a saber, archivos ".index" y archivos ".log"
. El archivo ".log" almacena los mensajes y el archivo ".index" almacena el índice de los mensajes en el archivo ".log".

Ingrese los registros del host donde se encuentra el tema de prueba:

significa que hay 0 mensajes antes.
00000000000000001456.log indica que hay 1456 mensajes por delante.

ver segmento

Para ver los archivos de registro en el segmento, debe verlos a través de una herramienta que viene con Kafka.

bin/kafka-run-class.sh kafka.tools.DumpLogSegments --files 
/home/admin/Study/kafka/logs/test-0/00000000000000000000.log --print-data-log

Un tema para un usuario está comprometido en una partición __consumer_offsets. Utilice
el valor hash de la cadena del tema y 50 para tomar el módulo y el resultado es el índice de partición. Generalmente, el valor predeterminado es 50 particiones (0 ~ 49).