Tutorial de Node.js: Cómo crear una aplicación sencilla basada en eventos con Kafka

¿Alguna vez te has preguntado cómo manejan algunas de tus aplicaciones favoritas las actualizaciones en tiempo real? Resultados deportivos en vivo, tickers del mercado de valores o incluso notificaciones de redes sociales: todos ellos dependen de la arquitectura basada en eventos (EDA) para procesar datos al instante. EDA es como tener una conversación en la que cada nueva información desencadena una respuesta inmediata. Es lo que hace que una aplicación sea más interactiva y receptiva. En este tutorial, lo guiaremos en la creación de una aplicación sencilla basada en eventos utilizando Apache Kafka en Heroku. Cubriremos: Configurar un clúster Kafka en Heroku Creación de una aplicación Node.js que produce y consume eventos Implementando su aplicación en Heroku es una poderosa herramienta para construir sistemas EDA. Es una plataforma de código abierto diseñada para manejar fuentes de datos en tiempo real. es un complemento de Heroku que proporciona Kafka como servicio. Heroku hace que sea bastante fácil implementar y administrar aplicaciones, y últimamente lo he estado usando más en mis proyectos. La combinación de Kafka con Heroku simplifica el proceso de configuración cuando desea ejecutar una aplicación basada en eventos. Apache Kafka Apache Kafka en Heroku Al final de esta guía, tendrá una aplicación en ejecución que demuestra el poder de EDA con Apache Kafka en Heroku. ¡Empecemos! Empezando Antes de profundizar en el código, repasemos rápidamente algunos conceptos básicos. Una vez que los comprenda, será más fácil seguirlos. son datos que indican algún suceso en el sistema, como una lectura de temperatura de un sensor. Los eventos son categorías o canales donde se publican eventos. Piense en ellos como los temas a los que se suscribe en un boletín. Los temas son las entidades que crean y envían eventos a los temas. En nuestra aplicación de demostración EDA, nuestros productores serán un conjunto de sensores meteorológicos. Los productores son las entidades que leen y procesan eventos de temas. Nuestra aplicación tendrá un consumidor que escuchará los eventos de datos meteorológicos y los registrará. Los consumidores Introducción a nuestra aplicación Construiremos una aplicación Node.js usando la biblioteca . Aquí hay una descripción general rápida de cómo funcionará nuestra aplicación: KafkaJS Nuestros sensores meteorológicos (los productores) generarán datos periódicamente, como temperatura, humedad y presión barométrica, y enviarán estos eventos a Apache Kafka. Para fines de demostración, los datos se generarán aleatoriamente. Tendremos un consumidor escuchando los temas. Cuando se recibe un nuevo evento, escribirá los datos en un registro. Implementaremos toda la configuración en Heroku y usaremos los registros de Heroku para monitorear los eventos a medida que ocurren. Requisitos previos Antes de comenzar, asegúrese de tener lo siguiente: Una cuenta Heroku: si no tienes una, en Heroku. regístrate CLI de Heroku: la CLI de Heroku. descargue e instale Node.js instalado en su máquina local para el desarrollo. En mi máquina, estoy usando Node (v.20.9.0) y npm (10.4.0). El código base para todo este proyecto está disponible en este . Siéntete libre de clonar el código y seguir esta publicación. repositorio de GitHub Ahora que hemos cubierto los conceptos básicos, configuremos nuestro clúster Kafka en Heroku y comencemos a construir. Configurar un clúster Kafka en Heroku Configuremos todo en Heroku. Es un proceso bastante rápido y sencillo. Paso 1: inicie sesión a través de Heroku CLI ~/project$ heroku login Paso 2: crea una aplicación Heroku ~/project$ heroku create weather-eda (Le puse el nombre a mi aplicación Heroku , pero puedes elegir un nombre único para tu aplicación). weather-eda Paso 3: agregue Apache Kafka en el complemento Heroku ~/project$ heroku addons:create heroku-kafka:basic-0 Creating heroku-kafka:basic-0 on ⬢ weather-eda... ~$0.139/hour (max $100/month) The cluster should be available in a few minutes. Run `heroku kafka:wait` to wait until the cluster is ready. You can read more about managing Kafka at https://devcenter.heroku.com/articles/kafka-on-heroku#managing-kafka kafka-adjacent-07560 is being created in the background. The app will restart when complete... Use heroku addons:info kafka-adjacent-07560 to check creation progress Use heroku addons:docs heroku-kafka to view documentation Puede encontrar más información sobre el complemento Apache Kafka en Heroku . Para nuestra demostración, agregaré el nivel Básico 0 del complemento. El costo del complemento es $0.139/hora. Mientras creaba esta aplicación de demostración, usé el complemento durante menos de una hora y luego lo dejé de usar. aquí Heroku tarda unos minutos en hacer girar a Kafka y prepararlo para ti. Muy pronto, esto es lo que verás: ~/project$ heroku addons:info kafka-adjacent-07560 === kafka-adjacent-07560 Attachments: weather-eda::KAFKA Installed at: Mon May 27 2024 11:44:37 GMT-0700 (Mountain Standard Time) Max Price: $100/month Owning app: weather-eda Plan: heroku-kafka:basic-0 Price: ~$0.139/hour State: created Paso 4: Obtenga las credenciales y configuraciones de Kafka Con nuestro clúster Kafka en funcionamiento, necesitaremos obtener credenciales y otras configuraciones. Heroku crea varias variables de configuración para nuestra aplicación y las completa con información del clúster Kafka que se acaba de crear. Podemos ver todas estas variables de configuración ejecutando lo siguiente: ~/project$ heroku config === weather-eda Config Vars KAFKA_CLIENT_CERT: -----BEGIN CERTIFICATE----- MIIDQzCCAiugAwIBAgIBADANBgkqhkiG9w0BAQsFADAyMTAwLgYDVQQDDCdjYS1h ... -----END CERTIFICATE----- KAFKA_CLIENT_CERT_KEY: -----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEAsgv1oBiF4Az/IQsepHSh5pceL0XLy0uEAokD7ety9J0PTjj3 ... -----END RSA PRIVATE KEY----- KAFKA_PREFIX: columbia-68051. KAFKA_TRUSTED_CERT: -----BEGIN CERTIFICATE----- MIIDfzCCAmegAwIBAgIBADANBgkqhkiG9w0BAQsFADAyMTAwLgYDVQQDDCdjYS1h ... F+f3juViDqm4eLCZBAdoK/DnI4fFrNH3YzhAPdhoHOa8wi4= -----END CERTIFICATE----- KAFKA_URL: kafka+ssl://ec2-18-233-140-74.compute-1.amazonaws.com:9096,kafka+ssl://ec2-18-208-61-56.compute-1.amazonaws.com:9096...kafka+ssl://ec2-34-203-24-91.compute-1.amazonaws.com:9096 Como puede ver, tenemos varias variables de configuración. Querremos un archivo en la carpeta raíz de nuestro proyecto llamado con todos estos valores de configuración var. Para ello simplemente ejecutamos el siguiente comando: .env ~/project$ heroku config --shell > .env Nuestro archivo se ve así: .env KAFKA_CLIENT_CERT="-----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----" KAFKA_CLIENT_CERT_KEY="-----BEGIN RSA PRIVATE KEY----- ... -----END RSA PRIVATE KEY-----" KAFKA_PREFIX="columbia-68051." KAFKA_TRUSTED_CERT="-----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----" KAFKA_URL="kafka+ssl://ec2-18-233-140-74.compute-1.amazonaws.com:9096,kafka+ssl://ec2-18-208-61-56.compute-1.amazonaws.com:9096...kafka+ssl://ec2-34-203-24-91.compute-1.amazonaws.com:9096" Además, nos aseguramos de agregar .env a nuestro archivo .gitignore. No queremos enviar estos datos confidenciales a nuestro repositorio. Paso 5: instale el complemento Kafka en la CLI de Heroku La CLI de Heroku no viene con comandos relacionados con Kafka listos para usar. Como usamos Kafka, necesitaremos . instalar el complemento CLI ~/project$ heroku plugins:install heroku-kafka Installing plugin heroku-kafka... installed v2.12.0 Ahora podemos administrar nuestro clúster Kafka desde la CLI. ~/project$ heroku kafka:info === KAFKA_URL Plan: heroku-kafka:basic-0 Status: available Version: 2.8.2 Created: 2024-05-27T18:44:38.023+00:00 Topics: [··········] 0 / 40 topics, see heroku kafka:topics Prefix: columbia-68051. Partitions: [··········] 0 / 240 partition replicas (partitions × replication factor) Messages: 0 messages/s Traffic: 0 bytes/s in / 0 bytes/s out Data Size: [··········] 0 bytes / 4.00 GB (0.00%) Add-on: kafka-adjacent-07560 ~/project$ heroku kafka:topics === Kafka Topics on KAFKA_URL No topics found on this Kafka cluster. Use heroku kafka:topics:create to create a topic (limit 40) Paso 6: Pruebe la interacción con el clúster Solo como control de cordura, juguemos con nuestro clúster Kafka. Empezamos creando un tema. ~/project$ heroku kafka:topics:create test-topic-01 Creating topic test-topic-01 with compaction disabled and retention time 1 day on kafka-adjacent-07560... done Use `heroku kafka:topics:info test-topic-01` to monitor your topic. Your topic is using the prefix columbia-68051.. ~/project$ heroku kafka:topics:info test-topic-01 ▸ topic test-topic-01 is not available yet En aproximadamente un minuto, nuestro tema estará disponible. ~/project$ heroku kafka:topics:info test-topic-01 === kafka-adjacent-07560 :: test-topic-01 Topic Prefix: columbia-68051. Producers: 0 messages/second (0 bytes/second) total Consumers: 0 bytes/second total Partitions: 8 partitions Replication Factor: 3 Compaction: Compaction is disabled for test-topic-01 Retention: 24 hours A continuación, en esta ventana de terminal, actuaremos como consumidores y escucharemos este tema siguiéndolo. ~/project$ heroku kafka:topics:tail test-topic-01 Desde aquí, el terminal simplemente espera cualquier evento publicado sobre el tema. En una ventana de terminal separada, actuaremos como productores y publicaremos algunos mensajes sobre el tema. ~/project$ heroku kafka:topics:write test-topic-01 "hello world!" De vuelta en la ventana de terminal de nuestro consumidor, esto es lo que vemos: ~/project$ heroku kafka:topics:tail test-topic-01 test-topic-01 0 0 12 hello world! ¡Excelente! Hemos producido y consumido con éxito un evento sobre un tema en nuestro clúster Kafka. Estamos listos para pasar a nuestra aplicación Node.js. Destruyamos este tema de prueba para mantener ordenado nuestro patio de recreo. ~/project$ heroku kafka:topics:destroy test-topic-01 ▸ This command will affect the cluster: kafka-adjacent-07560, which is on weather-eda ▸ To proceed, type weather-eda or re-run this command with --confirm weather-eda > weather-eda Deleting topic test-topic-01... done Your topic has been marked for deletion, and will be removed from the cluster shortly ~/project$ heroku kafka:topics === Kafka Topics on KAFKA_URL No topics found on this Kafka cluster. Use heroku kafka:topics:create to create a topic (limit 40). Paso 7: preparar a Kafka para nuestra aplicación Para prepararnos para que nuestra aplicación utilice Kafka, necesitaremos crear dos cosas: un tema y un grupo de consumidores. Creemos el tema que utilizará nuestra aplicación. ~/project$ heroku kafka:topics:create weather-data A continuación, crearemos el grupo de consumidores del que formará parte el consumidor de nuestra aplicación: ~/project$ heroku kafka:consumer-groups:create weather-consumers ¡Estamos listos para construir nuestra aplicación Node.js! Construya la aplicación Inicialicemos un nuevo proyecto e instalemos nuestras dependencias. ~/project$ npm init -y ~/project$ npm install kafkajs dotenv @faker-js/faker pino pino-pretty Nuestro proyecto tendrá dos procesos en ejecución: , que está suscrito al tema y registra cualquier evento que se publique. consumer.js , que publicará algunos datos meteorológicos aleatorios sobre el tema cada pocos segundos. producer.js Ambos procesos necesitarán usar KafkaJS para conectarse a nuestro clúster Kafka, por lo que modularizaremos nuestro código para hacerlo reutilizable. Trabajar con el cliente Kafka En la carpeta del proyecto, creamos un archivo llamado . Se parece a esto: src kafka.js const { Kafka } = require('kafkajs'); const BROKER_URLS = process.env.KAFKA_URL.split(',').map(uri => uri.replace('kafka+ssl://','' )) const TOPIC = `${process.env.KAFKA_PREFIX}weather-data` const CONSUMER_GROUP = `${process.env.KAFKA_PREFIX}weather-consumers` const kafka = new Kafka({ clientId: 'weather-eda-app-nodejs-client', brokers: BROKER_URLS, ssl: { rejectUnauthorized: false, ca: process.env.KAFKA_TRUSTED_CERT, key: process.env.KAFKA_CLIENT_CERT_KEY, cert: process.env.KAFKA_CLIENT_CERT, }, }) const producer = async () => { const p = kafka.producer() await p.connect() return p; } const consumer = async () => { const c = kafka.consumer({ groupId: CONSUMER_GROUP, sessionTimeout: 30000 }) await c.connect() await c.subscribe({ topics: [TOPIC] }); return c; } module.exports = { producer, consumer, topic: TOPIC, groupId: CONSUMER_GROUP }; En este archivo, comenzamos creando un nuevo cliente Kafka. Esto requiere URL para los corredores de Kafka, que podemos analizar a partir de la variable en nuestro archivo (que originalmente surgió al llamar a heroku config). Para autenticar el intento de conexión, debemos proporcionar , y . KAFKA_URL .env KAFKA_TRUSTED_CERT KAFKA_CLIENT_CERT_KEY KAFKA_CLIENT_CERT Luego, desde nuestro cliente Kafka, creamos un y un , asegurándonos de suscribir a nuestros consumidores al tema . producer consumer weather-data Aclaración sobre el prefijo Kafka Observe que en anteponemos a nuestro tema y nombre de grupo de consumidores. Estamos usando el plan Básico 0 para Apache Kafka en Heroku, que es un plan Kafka multiinquilino. Esto significa que . Aunque nombramos a nuestro tema y a nuestro grupo de consumidores , sus nombres reales en nuestro clúster Kafka multiinquilino deben tener antepuesto (para garantizar que sean únicos). kafka.js KAFKA_PREFIX trabajamos con un KAFKA_PREFIX weather-data weather-consumers KAFKA_PREFIX Entonces, técnicamente, para nuestra demostración, el nombre real del tema es , no . (Lo mismo ocurre con el nombre del grupo de consumidores). columbia-68051.weather-data weather-data El proceso del productor Ahora, creemos nuestro proceso en segundo plano que actuará como nuestros productores de sensores meteorológicos. En la carpeta raíz de nuestro proyecto, tenemos un archivo llamado . Se parece a esto: producer.js require('dotenv').config(); const kafka = require('./src/kafka.js'); const { faker } = require('@faker-js/faker'); const SENSORS = ['sensor01','sensor02','sensor03','sensor04','sensor05']; const MAX_DELAY_MS = 20000; const READINGS = ['temperature','humidity','barometric_pressure']; const MAX_TEMP = 130; const MIN_PRESSURE = 2910; const PRESSURE_RANGE = 160; const getRandom = (arr) => arr[faker.number.int(arr.length - 1)]; const getRandomReading = { temperature: () => faker.number.int(MAX_TEMP) + (faker.number.int(100) / 100), humidity: () => faker.number.int(100) / 100, barometric_pressure: () => (MIN_PRESSURE + faker.number.int(PRESSURE_RANGE)) / 100 }; const sleep = (ms) => { return new Promise((resolve) => { setTimeout(resolve, ms); }); }; (async () => { const producer = await kafka.producer() while(true) { const sensor = getRandom(SENSORS) const reading = getRandom(READINGS) const value = getRandomReading[reading]() const data = { reading, value } await producer.send({ topic: kafka.topic, messages: [{ key: sensor, value: JSON.stringify(data) }] }) await sleep(faker.number.int(MAX_DELAY_MS)) } })() Gran parte del código del archivo tiene que ver con la generación de valores aleatorios. Destacaré las partes importantes: Simularemos tener cinco sensores meteorológicos diferentes. Sus nombres se encuentran en . SENSORS Un sensor emitirá (publicará) un valor para una de tres lecturas posibles: , o . El objeto tiene una función para cada una de estas lecturas, para generar un valor correspondiente razonable. temperature humidity barometric_pressure getRandomReading Todo el proceso se ejecuta como una función con un bucle infinito. async while Dentro del ciclo , nosotros: while Elija un al azar. sensor Elija una al azar. reading Genere un aleatorio para esa lectura. value Llame a para publicar estos datos en el tema. El sirve como para el evento, mientras que la y formarán el mensaje del evento. producer.send sensor key reading value Luego, esperamos hasta 20 segundos antes de nuestra siguiente iteración del ciclo. El proceso del consumidor El proceso en segundo plano en es considerablemente más sencillo. consumer.js require('dotenv').config(); const logger = require('./src/logger.js'); const kafka = require('./src/kafka.js'); (async () => { const consumer = await kafka.consumer() await consumer.run({ eachMessage: async ({ topic, partition, message }) => { const sensorId = message.key.toString() const messageObj = JSON.parse(message.value.toString()) const logMessage = { sensorId } logMessage[messageObj.reading] = messageObj.value logger.info(logMessage) } }) })() Nuestro ya está suscrito al tema . Llamamos y luego configuramos un controlador para . Cada vez que Kafka notifica al sobre un mensaje, lo registra. Eso es todo al respecto. consumer weather-data consumer.run eachMessage consumer Procesos y el Procfile En el archivo , necesitamos agregar algunos que inician nuestros procesos en segundo plano de productor y consumidor. El archivo ahora debería incluir lo siguiente: package.json scripts ... "scripts": { "start": "echo 'do nothing'", "start:consumer": "node consumer.js", "start:producer": "node producer.js" }, ... Los importantes son y . Pero mantenemos en nuestro archivo (aunque no hace nada significativo) porque el constructor Heroku espera que esté allí. start:consumer start:producer start A continuación, creamos un que le indicará a Heroku cómo iniciar los distintos trabajadores que necesitamos para nuestra aplicación Heroku. En la carpeta raíz de nuestro proyecto, el debería verse así: Procfile Procfile consumer_worker: npm run start:consumer producer_worker: npm run start:producer Bastante simple, ¿verdad? Tendremos un trabajador de proceso en segundo plano llamado y otro llamado . Notarás que no tenemos un trabajador , que es lo que normalmente verías en para una aplicación web. Para nuestra aplicación Heroku, solo necesitamos los dos trabajadores en segundo plano. No necesitamos . consumer_worker producer_worker web Procfile web Implementar y probar la aplicación Con eso, todo nuestro código está configurado. Hemos enviado todo nuestro código al repositorio y estamos listos para implementarlo. ~/project$ git push heroku main … remote: -----> Build succeeded! … remote: -----> Compressing... remote: Done: 48.6M remote: -----> Launching... … remote: Verifying deploy... done Después de haberlo implementado, queremos asegurarnos de escalar nuestros dinamómetros correctamente. No necesitamos un banco de pruebas para un proceso web, pero necesitaremos uno tanto para como . Ejecutamos el siguiente comando para configurar estos procesos según nuestras necesidades. consumer_worker producer_worker ~/project$ heroku ps:scale web=0 consumer_worker=1 producer_worker=1 Scaling dynos... done, now running producer_worker at 1:Eco, consumer_worker at 1:Eco, web at 0:Eco Ahora todo debería estar en funcionamiento. Detrás de escena, nuestro debería conectarse al clúster de Kafka y luego comenzar a publicar datos de los sensores meteorológicos cada pocos segundos. Luego, nuestro debe conectarse al clúster de Kafka y registrar cualquier mensaje que reciba del tema al que está suscrito. producer_worker consumer_worker Para ver qué está haciendo nuestro , podemos consultar nuestros registros de Heroku. consumer_worker ~/project$ heroku logs --tail … heroku[producer_worker.1]: Starting process with command `npm run start:producer` heroku[producer_worker.1]: State changed from starting to up app[producer_worker.1]: app[producer_worker.1]: > weather-eda-kafka-heroku-node@1.0.0 start:producer app[producer_worker.1]: > node producer.js app[producer_worker.1]: … heroku[consumer_worker.1]: Starting process with command `npm run start:consumer` heroku[consumer_worker.1]: State changed from starting to up app[consumer_worker.1]: app[consumer_worker.1]: > weather-eda-kafka-heroku-node@1.0.0 start:consumer app[consumer_worker.1]: > node consumer.js app[consumer_worker.1]: app[consumer_worker.1]: {"level":"INFO","timestamp":"2024-05-28T02:31:20.660Z","logger":"kafkajs","message":"[Consumer] Starting","groupId":"columbia-68051.weather-consumers"} app[consumer_worker.1]: {"level":"INFO","timestamp":"2024-05-28T02:31:23.702Z","logger":"kafkajs","message":"[ConsumerGroup] Consumer has joined the group","groupId":"columbia-68051.weather-consumers","memberId":"weather-eda-app-nodejs-client-3ee5d1fa-eba9-4b59-826c-d3b924a6e4e4","leaderId":"weather-eda-app-nodejs-client-3ee5d1fa-eba9-4b59-826c-d3b924a6e4e4","isLeader":true,"memberAssignment":{"columbia-68051.test-topic-1":[0,1,2,3,4,5,6,7]},"groupProtocol":"RoundRobinAssigner","duration":3041} app[consumer_worker.1]: [2024-05-28 02:31:23.755 +0000] INFO (21): {"sensorId":"sensor01","temperature":87.84} app[consumer_worker.1]: [2024-05-28 02:31:23.764 +0000] INFO (21): {"sensorId":"sensor01","humidity":0.3} app[consumer_worker.1]: [2024-05-28 02:31:23.777 +0000] INFO (21): {"sensorId":"sensor03","temperature":22.11} app[consumer_worker.1]: [2024-05-28 02:31:37.773 +0000] INFO (21): {"sensorId":"sensor01","barometric_pressure":29.71} app[consumer_worker.1]: [2024-05-28 02:31:54.495 +0000] INFO (21): {"sensorId":"sensor05","barometric_pressure":29.55} app[consumer_worker.1]: [2024-05-28 02:32:02.629 +0000] INFO (21): {"sensorId":"sensor04","temperature":90.58} app[consumer_worker.1]: [2024-05-28 02:32:03.995 +0000] INFO (21): {"sensorId":"sensor02","barometric_pressure":29.25} app[consumer_worker.1]: [2024-05-28 02:32:12.688 +0000] INFO (21): {"sensorId":"sensor04","humidity":0.1} app[consumer_worker.1]: [2024-05-28 02:32:32.127 +0000] INFO (21): {"sensorId":"sensor01","humidity":0.34} app[consumer_worker.1]: [2024-05-28 02:32:32.851 +0000] INFO (21): {"sensorId":"sensor02","humidity":0.61} app[consumer_worker.1]: [2024-05-28 02:32:37.200 +0000] INFO (21): {"sensorId":"sensor01","barometric_pressure":30.36} app[consumer_worker.1]: [2024-05-28 02:32:50.388 +0000] INFO (21): {"sensorId":"sensor03","temperature":104.55} Sabemos que nuestro productor publica mensajes periódicamente en Kafka porque nuestro consumidor los recibe y luego los registra. ¡Funciona! Por supuesto, en una aplicación EDA más grande, cada sensor es un productor. Es posible que publiquen sobre varios temas para diversos fines o que todos publiquen sobre el mismo tema. Y su consumidor puede estar suscrito a múltiples temas. Además, en nuestra aplicación de demostración, nuestros consumidores simplemente emitieron mucho en ; pero en una aplicación EDA, un consumidor podría responder llamando a una API de terceros, enviando una notificación por SMS o consultando una base de datos. eachMessage Ahora que tiene un conocimiento básico de eventos, temas, productores y consumidores, y sabe cómo trabajar con Kafka, puede comenzar a diseñar y crear sus propias aplicaciones EDA para satisfacer casos de uso empresarial más complejos. Conclusión EDA es bastante poderoso: puede desacoplar sus sistemas mientras disfruta de funciones clave como una fácil escalabilidad y procesamiento de datos en tiempo real. Para EDA, Kafka es una herramienta clave que le ayuda a manejar flujos de datos de alto rendimiento con facilidad. Usar Apache Kafka en Heroku le ayuda a empezar rápidamente. Dado que es un servicio administrado, no necesita preocuparse por las partes complejas de la administración del clúster Kafka. Puedes concentrarte simplemente en crear tus aplicaciones. A partir de aquí, es hora de que experimentes y crees prototipos. Identifique qué casos de uso encajan bien con EDA. Sumérgete, pruébalo en Heroku y construye algo increíble. ¡Feliz codificación!

Tutorial de Node.js: Cómo crear una aplicación sencilla basada en eventos con Kafka

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Telegram: el puente de Crypto Island hacia el continente

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Telegram: el puente de Crypto Island hacia el continente

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps