Transmisión de datos eficiente: conecte fácilmente datos de Kafka en tiempo real a CnosDB

En este artículo, presentaremos principalmente cómo implementar una solución de almacenamiento y adquisición síncrona en tiempo real de datos de transmisión Kafka + Telegraf + CnosDB en el entorno Ubuntu 22.04.2 LTS. En esta operación, la versión de CnosDB es 2.3.0, la versión de Kafka es 2.5.1 y la versión de Telegraf es 1.27.1

A medida que más y más arquitecturas de aplicaciones avanzan hacia microservicios o estructuras sin servidor, la cantidad de aplicaciones y servicios aumenta cada día. Los usuarios pueden procesar cantidades cada vez mayores de datos de series temporales, ya sea mediante agregación en tiempo real o mediante cálculos cuyo resultado son mediciones o métricas. Ante las enormes cantidades de datos generados, los usuarios pueden capturar y observar cambios en los datos en el sistema de diversas formas. En un entorno nativo de la nube, la más popular es utilizar eventos.

Apache Kafka es un sistema de mensajería duradero y de alto rendimiento que también se considera una plataforma de procesamiento de flujo distribuido. Se puede aplicar a muchos casos de uso, incluida la mensajería, la integración de datos, la agregación de registros y las métricas. Y cuando se trata de métricas, no basta con contar con una red troncal de mensajes o un intermediario. Aunque Apache Kafka es duradero, no está diseñado para ejecutar métricas y monitorear consultas. Éste es exactamente el punto fuerte de CnosDB.

plano de arquitectura

Combinando Kafka, Telegraf y CnosDB, se puede realizar el proceso completo de datos:

Generación de datos: utilice sensores, dispositivos u otras fuentes de datos para generar datos y enviarlos a un tema de Kafka.
Cola de mensajes de Kafka: Kafka recibe y almacena flujos de datos para garantizar la seguridad y confiabilidad de los datos.
Consumidor de Telegraf: Telegraf, como consumidor de Kafka, se suscribe a temas de Kafka y obtiene flujos de datos.
Almacenamiento de datos CnosDB: Telegraf envía los datos preprocesados a CnosDB para almacenar datos de series temporales.

La arquitectura general de la aplicación se muestra en la figura:

imagen

kafka

Apache Kafka es una plataforma de procesamiento de flujo distribuido de código abierto, diseñada para procesar flujos de datos en tiempo real, con características de alta confiabilidad, alto rendimiento y baja latencia, y actualmente es utilizada por la mayoría de las empresas. Se puede utilizar de diversas formas, entre ellas:

Procesamiento de flujo: proporciona una columna vertebral de eventos al almacenar eventos en tiempo real para su agregación, enriquecimiento y procesamiento.
Métricas: Apache Kafka se convierte en el punto de agregación central para muchos componentes o aplicaciones distribuidas, como los microservicios. Estas aplicaciones pueden enviar métricas en tiempo real para su consumo por otras plataformas, incluido CnosDB.
Integración de datos: los cambios de datos y eventos se pueden capturar y enviar a Apache Kafka, donde pueden ser utilizados por cualquier aplicación que necesite actuar sobre estos cambios.
Agregación de registros: Apache Kafka puede actuar como la columna vertebral de mensajes de la plataforma de transmisión de registros, convirtiendo bloques de registros en flujos de datos.

Varios conceptos centrales

Instancia (Broker): El Broker de Kafka es el nodo del servidor en el clúster de Kafka, responsable de almacenar y reenviar mensajes, proporcionando alta disponibilidad, tolerancia a fallas y confiabilidad.
Tema: El tema en Apache Kafka es una unidad de almacenamiento lógica, como una tabla en una base de datos relacional. Los temas se distribuyen a través de intermediarios mediante particiones, lo que proporciona escalabilidad y resistencia.
Productor: el productor publica mensajes sobre el tema especificado en Kafka. Los productores pueden optar por enviar mensajes a particiones específicas o dejar que Kafka determine automáticamente la estrategia de distribución.
Consumidor: un consumidor lee mensajes de una o más particiones de un tema específico. Los consumidores se pueden organizar de diferentes formas, como unidifusión, multidifusión, grupos de consumidores, etc.
Modelo de publicación-suscripción: significa que los productores publican mensajes sobre uno o más temas, y los consumidores pueden suscribirse a uno o más temas, recibir y procesar mensajes de ellos.

En pocas palabras, cuando un cliente envía datos a una instancia de clúster de Apache Kafka, debe enviarlos a un tema.

Además, cuando un cliente lee datos de un clúster de Apache Kafka, debe leer de un tema. Los clientes que envían datos a Apache Kafka se convierten en productores, mientras que los clientes que leen datos del clúster de Kafka se convierten en consumidores. El diagrama de flujo de datos es el siguiente:

imagen

Nota: Aquí no se presentan conceptos más complejos, como particiones de temas, compensaciones, grupos de consumidores, etc. Los usuarios pueden consultar el documento de orientación oficial para obtener más información:

Kafka:【https://kafka.apache.org/documentation/#gettingStarted】

Departamento Kafka

Descargue e instale Kafka [https://kafka.apache.org/]

1. Requisito previo: debe asegurarse de tener un entorno JDK y un entorno Zookeeper. De lo contrario, puede utilizar el siguiente comando para instalarlo:

sudo apt install openjdk-8-jdk
sudo apt install zookeeper

2. Descargue el paquete de instalación de Kafka y descomprímalo.

wget https://archive.apache.org/dist/kafka/2.5.1/kafka_2.12-2.5.1.tgz
tar -zxvf kafka_2.12-2.5.1.tgz

3. Ingrese al directorio Kafka descomprimido.

cd  kafka_2.12-2.5.1

4. Modifique el archivo de configuración de $KAFKA_HOME/config/server.properties (el puerto, la ruta del registro y otra información de configuración se pueden modificar según sea necesario)

5. Guarde y cierre el editor. Ejecute el siguiente comando para iniciar Kafka:

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

Kafka se ejecutará en segundo plano y escuchará las conexiones a través del puerto predeterminado 9092.

Telégrafo

Telegraf es un agente de servidor de código abierto que se utiliza para recopilar, procesar y transmitir datos de métricas de aplicaciones y sistemas. Telegraf admite una variedad de complementos de entrada y salida y se puede integrar con una variedad de diferentes tipos de sistemas y servicios. Puede recopilar datos de indicadores de múltiples fuentes, como estadísticas del sistema, archivos de registro, interfaces API, colas de mensajes, etc., y enviarlos a varios objetivos, como CnosDB, Elasticsearch, Kafka, Prometheus, etc. Esto hace que Telegraf sea muy flexible y adaptable a diferentes escenarios de monitoreo y procesamiento de datos.

Ligero: Telegraf está diseñado como un agente liviano que ocupa relativamente pocos recursos del sistema y puede ejecutarse de manera eficiente en varios entornos.
Controlador de complemento: Telegraf utiliza complementos para admitir varias funciones de entrada y salida. Proporciona un rico ecosistema de complementos que cubre numerosos sistemas y servicios. Los usuarios pueden elegir los complementos apropiados según sus propias necesidades para recopilar y transmitir datos de indicadores.
Procesamiento y conversión de datos: Telegraf tiene funciones flexibles de procesamiento y conversión de datos. Puede filtrar, procesar, convertir y agregar los datos del indicador recopilados a través de la cadena de complementos (Plugin Chain), proporcionando así un análisis de datos más preciso y avanzado.

Implementar Telegraf

1. Instalar Telegraf

sudo apt-get update && sudo apt-get install telegraf

2. Cambie al directorio /etc/telegraf donde se encuentra el archivo de configuración predeterminado de Telegraf.

3. Agregue el complemento de salida de destino en el archivo de configuración telegraf.config

[[outputs.http]]
  url = "http://127.0.0.1:8902/api/v1/write?db=telegraf"
  timeout = "5s"
  method = "POST"
  username = "root"
  password = ""
  data_format = "influx"
  use_batch_format = true
  content_encoding = "identity"
  idle_conn_timeout = 10

Parámetros para modificar según sea necesario:

url：CnosDB 地址和端口
username：连接 CnosDB 的用户名
password：连接 CnosDB 的用户名对应的密码

Nota: Los parámetros restantes pueden seguir siendo los mismos que en el ejemplo de configuración anterior.

4. Libere los siguientes comentarios de configuración en el archivo de configuración y modifíquelos según sea necesario.

[[inputs.kafka_consumer]]
brokers = ["127.0.0.1:9092"]
topics = ["oceanic"]
data_format = "json"

parámetro:

brokers：Kafka 的 broker list 
topics：指定写入 Kafka 目标的 topic
data_format：写入数据的格式

Nota: Los parámetros restantes pueden seguir siendo los mismos que en el ejemplo de configuración anterior.

5. Inicie Telegraf

telegraf -config /etc/telegraf/telegraf.conf

CnosDB

Implementar CnosDB

Para operaciones detalladas, consulte: Instalación de CnosDB

【https://docs.cnosdb.com/zh/latest/start/install.html】

Integrar

Kafka crea tema

1. Ingrese a la carpeta bin de kafka.

2. Ejecute el comando y cree el tema.

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

Python simula escribir datos en Kakfa

1.Escribir código:

import time
import json
import random


from kafka import KafkaProducer


def random_pressure():
    return round(random.uniform(0, 10), 1)


def random_tempreture():
    return round(random.uniform(0, 100), 1)


def random_visibility():
    return round(random.uniform(0, 100), 1)


def get_json_data():
    data = {}


    data["pressure"] = random_pressure()
    data["temperature"] = random_temp_cels()
    data["visibility"] = random_visibility()


    return json.dumps(data) 


def main():
    producer = KafkaProducer(bootstrap_servers=['ip:9092'])


    for _ in rang(2000):
        json_data = get_json_data()
        producer.send('oceanic', bytes(f'{json_data}','UTF-8'))
        print(f"Sensor data is sent: {json_data}")
        time.sleep(5)




if __name__ == "__main__":
    main()

2. Ejecute el script de Python

python3 test.py

Ver datos en el tema Kafka

1. Ejecute el siguiente comando para ver los datos del tema especificado.

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

imagen

Ver los datos sincronizados con CnosDB

1. Utilice herramientas para conectarse a CnosDB

cnosdb-cli

2. Cambie a la biblioteca especificada

\c public

3. Ver datos

select * from kafka_consumer;

imagen

Lectura adicional

1. Utilice Telegraf para recopilar datos y escribirlos en CnosDB:

https://docs.cnosdb.com/zh/latest/versatility/collect/telegraf.html

2.Conector Python:

https://docs.cnosdb.com/zh/latest/reference/connector/python.html

3. Inicio rápido de CnosDB:

https://docs.cnosdb.com/zh/latest/start/quick_start.html