Estás curioso sobre lo que hace Apache Kafka y cómo funciona, pero entre la terminología y las explicaciones que parecen comenzar a un nivel complejo, ha sido difícil embarcarse. Esta sesión es diferente. Hablaremos de lo que es Kafka, lo que hace y cómo funciona en términos simples con ejemplos fáciles de entender y divertidos que puedes compartir más tarde en una cena con tu familia.
Esta sesión es para mentes curiosas, que quizás nunca hayan trabajado con sistemas de transmisión distribuidos antes, o que sean principiantes en aplicaciones de transmisión de eventos.
Pero que la simplicidad no te engañe - al final de la sesión estarás equipado para crear tu propio flujo de eventos de Apache Kafka!
This talk has been presented at JSNation 2023, check out the latest edition of this JavaScript Conference.
FAQ
Apache Kafka simplifica la gestión de datos en tiempo real desenredando flujos de datos y proporcionando herramientas para el monitoreo en tiempo real, procesamiento e informes. Esto permite a los usuarios y desarrolladores trabajar con datos de manera más eficiente y responder a eventos en tiempo real.
Una arquitectura orientada a eventos se basa en el tratamiento de los datos como eventos continuos en lugar de estados finales almacenados. Apache Kafka facilita esta visión al permitir el manejo de flujos de datos como eventos, que se pueden consumir y procesar continuamente desde y hacia un clúster de Kafka distribuido y escalable.
Los eventos en Apache Kafka se almacenan de manera persistente y no se eliminan automáticamente después de ser consumidos. Los eventos pueden ser eliminados basándose en políticas de retención configurables, como un tiempo de vida máximo (TTL) o un tamaño máximo del tema, donde los eventos más antiguos se eliminan para dar espacio a los nuevos.
En Apache Kafka, un 'tema' es una categoría o canal de datos, similar a una tabla en una base de datos. Cada tema puede dividirse en 'particiones', que son segmentos que permiten la distribución de datos a través de diferentes servidores o 'brokers' dentro del clúster de Kafka. Esto ayuda a balancear la carga y a mejorar el rendimiento del sistema.
Apache Kafka es una plataforma de transmisión de eventos distribuida, escalable, de alto rendimiento y baja latencia. Está diseñada para manejar el transporte de mensajes a través de múltiples sistemas como microservicios, dispositivos IoT, entre otros. Sus características incluyen un ecosistema amplio, capacidad para manejar billones de mensajes al día y almacenamiento persistente de petabytes de datos.
En Apache Kafka, los productores son aplicaciones que envían datos al clúster, mientras que los consumidores son aquellos que leen estos datos. Kafka utiliza un modelo de empuje-tirón que permite a los productores y consumidores operar de manera independiente y manejar datos en paralelo, mejorando la eficiencia y la escalabilidad del sistema.
Apache Kafka es una plataforma de transmisión de eventos distribuida, escalable y de alto rendimiento que juega un papel clave en la arquitectura basada en eventos. Permite la división de aplicaciones monolíticas en microservicios independientes para la escalabilidad y el mantenimiento. Los productores y los consumidores son los componentes clave en Kafka, permitiendo un sistema desacoplado. Las capacidades de replicación y almacenamiento persistente de Kafka lo diferencian de alternativas como Redis y RabbitMQ. Kafka proporciona un fácil acceso a los datos en tiempo real y simplifica el manejo de datos en tiempo real.
Hola a todos. Hoy quería hablarles sobre Apache Kafka, un increíble proyecto que se ha convertido en el estándar por defecto para la transmisión de datos. Permítanme darles un ejemplo de cómo Apache Kafka puede marcar una diferencia significativa en un proyecto. Imaginen construir un producto de comercio electrónico basado en la película Zootopia, llamado Shoputopia. A medida que el proyecto crece, es importante evitar poner todo en un solo monolito. En cambio, deberíamos considerar dividir el monolito en microservicios independientes para garantizar la escalabilidad y la mantenibilidad.
Hola a todos. Mi nombre es Elena. Trabajo en Ivan donde apoyamos y contribuimos mucho a proyectos de código abierto. Hoy quería hablarles sobre uno de esos increíbles proyectos que ya existe desde hace más de una década y se ha convertido en el estándar por defecto para la transmisión de data.
Esto es obviamente Apache Kafka. Pero antes de dar una definición para Apache Kafka, quería darles un ejemplo de un proyecto donde Apache Kafka hace una diferencia significativa tanto para los usuarios del sistema como para los desarrolladores. Y mi ingeniosa idea de proyecto se basa en una película de animation que quizás hayan visto, Zootopia. Si no la han visto, no se preocupen. Sin embargo, si la han visto, reconocerán algunos de nuestros personajes porque hoy, ustedes y yo, vamos a construir el primer producto de e-commerce de Zootopia y lo llamaremos Shoputopia. Y como en cualquier proyecto de e-commerce, queremos tener algún inventario de productos. Vamos a vender una simple user interface para empezar donde nuestros encantadores clientes podrán buscar productos, seleccionar lo que necesitan, hacer un pedido y esperar la entrega.
Y al principio, quizás durante la etapa de MVP, podrías estar tentado a poner todo en un solo monolito donde tu frontend y tu backend estarán uno al lado del otro. Tendrás alguna fuente de data allí también, y no hay nada malo en los monolitos per se. Sin embargo, una vez que tengas más clientes y tu tienda se vuelva más popular y empieces a agregar más y más modules a este monolito, muy pronto el flujo de la architecture y el flujo de información del sistema corren el riesgo de convertirse en un desastre. Un desastre que es difícil de soportar y difícil de expandir. Y asumiendo que nuestro equipo de desarrollo está creciendo, ningún individuo será capaz de mantenerse al día con el flujo de información del sistema. Y podrías haber estado en esos zapatos cuando te unes a un proyecto y te traen la architecture, y estás como, Dios mío, ¿cómo navego por ella? ¿A quién debo hablar para entender todo este sistema? En este punto, tendremos que tener una conversación difícil sobre cómo podemos dividir nuestro monolito en un conjunto de microservices independientes con interfaces de comunicación claras.
2. Importancia de los datos en tiempo real y Apache Kafka
Short description:
Nuestra arquitectura necesita depender de eventos en tiempo real para obtener recomendaciones significativas. También queremos un fácil acceso a los datos en tiempo real sin complicar nuestras vidas. Ahí es donde entra Apache Kafka, desenredando flujos de datos y simplificando el manejo de datos en tiempo real.
Lo que es aún más crucial, nuestra architecture debe estar lo más cerca posible de la comunicación en tiempo real para depender de eventos en tiempo real, de modo que nuestros usuarios no tengan que esperar hasta mañana para obtener recommendations significativas basadas en sus compras realizadas hoy o ayer. Lo que también es importante sería realmente genial tener soporte para monitoreo en tiempo real, procesamiento e informes que vienen como un paquete de funcionalidad.
También como ingenieros, queremos trabajar con data en tiempo real de una manera fácil, que realmente no complique nuestra vida. Y esto es mucho pedir, sin embargo, es por eso que tenemos Apache Kafka y Apache Kafka es excelente para desenredar flujos de data y simplificar
3. Introducción a Apache Kafka
Short description:
Apache Kafka es una plataforma de transmisión de eventos que es distribuida, escalable, de alto rendimiento, baja latencia y tiene un ecosistema y comunidad increíbles. Puede manejar el transporte de mensajes a través de múltiples sistemas, incluyendo microservicios, dispositivos IoT y más. Apache Kafka se ocupa de entidades descritas por eventos que llegan continuamente, permitiendo un flujo de eventos y la capacidad de abordar los datos desde diferentes ángulos. Juega un papel clave en la arquitectura orientada a eventos, coordinando el movimiento de datos y utilizando un modelo de push-pull para manejar los mensajes entrantes.
la forma en que manejamos los datos en tiempo real. Así que con esto quería pasar a una definición de Apache Kafka, y sé que las definiciones son realmente aburridas, sin embargo, quería que estuviéramos en la misma línea para que podamos entendernos. Así que Apache Kafka es una plataforma de transmisión de eventos que es distribuida, escalable, de alto rendimiento, baja latencia y tiene un increíble ecosistema y comunidad. O simplemente, es una plataforma para manejar el transporte de mensajes a través de tus múltiples sistemas. Puede ser microservicios, puede ser dispositivos IoT, puede ser una tetera en tu cocina enviando información sobre el agua a tu teléfono móvil, así que cualquier cosa. La plataforma Apache Kafka es distribuida, lo que significa que se basa en múltiples servidores con datos que se replican en múltiples ubicaciones, asegurando que si alguno de esos servidores se cae, todavía estamos bien. Nuestros usuarios todavía pueden usar el sistema. También es escalable, por lo que puedes tener tantos servidores como necesites y pueden manejar billones de mensajes por día, terminando en petabytes de datos persistentemente, y esa es la palabra que es importante, persistentemente almacenados en los discos. Y también lo que es impresionante acerca de Apache Kafka es su comunidad y también un amplio ecosistema, incluyendo las bibliotecas, verás JavaScript más tarde en acción, y también el conector para que realmente no tengas que reinventar. Ya existe desde hace décadas, por lo que hay muchos conectores que ya están construidos facilitando la conexión de Apache Kafka con tus sistemas también.
Así que, para entender cómo funciona Apache Kafka y más importante, cómo podemos trabajar eficazmente con Apache Kafka, necesitamos hablar sobre la forma de pensar de Kafka acerca de los datos. Y el enfoque que Kafka toma es simple, pero también bastante inteligente. En lugar de trabajar con datos en términos de objetos estáticos o hechos finales, un conjunto final de datos que se almacena en una tabla, en una base de datos, Apache Kafka se ocupa de entidades descritas por eventos que llegan continuamente.
Así que en nuestro ejemplo, para nuestra tienda en línea, tenemos algunos productos que estamos vendiendo. Y la información sobre los productos y sus estados, pueden almacenar en una tabla, en una base de datos. Y esto nos da información valiosa, algunos resultados finales comprimidos. Sin embargo, si después de almacenar los datos te surgen más preguntas sobre, no sé, las tendencias de búsqueda, los momentos de mayor actividad para algunos productos, no puedes realmente detectar esa información de los datos que almacenaste a menos que lo hayas planeado con antelación. Así que, podemos ver esos datos en la tabla como una instantánea comprimida y una vista unidimensional o un solo punto en una línea de tiempo infinita de los datos.
¿Y si en lugar de eso puedes ver estos datos como un flujo de eventos. Por ejemplo, un cliente ordenó una corbata. Otro cliente buscó un donut. Luego enviamos la corbata al primer cliente y el segundo decidió comprar el donut. Y así sucesivamente, tenemos más eventos llegando al sistema. Así que, en lugar de ver el único punto de datos, vemos todo el ciclo de vida de la compra de un producto. Lo que es más, podemos reemplazar esos eventos. Realmente no podemos cambiar los eventos pasados, ya sucedieron, pero podemos ir y reemplazarlos una y otra vez, y abordar los datos desde diferentes ángulos, y responder todas las preguntas que podamos tener en nuestra mente incluso más tarde. Y esto se llama una arquitectura orientada a eventos, y estoy bastante seguro de que muchos de ustedes están familiarizados con eso. Pero veamos cómo juega Apache Kafka con la arquitectura orientada a eventos. Así que aquí en el centro puse el clúster, y a la izquierda y a la derecha veremos aplicaciones que interactúan con el clúster. Así que Apache Kafka coordina el movimiento de datos y se encarga de los mensajes entrantes. Utiliza un modelo de push-pull para trabajar con los datos, lo que significa que por un lado tenemos algunas estructuras que crearán y empujarán los datos al clúster.
4. Productores, Consumidores y Temas
Short description:
Los productores y consumidores son los componentes clave en Apache Kafka. Los productores son las aplicaciones que los ingenieros escriben y controlan para enviar datos, mientras que los consumidores extraen y leen los datos. Pueden estar escritos en diferentes lenguajes y plataformas, permitiendo un sistema desacoplado. En el clúster, los eventos de varias fuentes se organizan en temas, que pueden verse como tablas en una base de datos. Los mensajes dentro de un tema están ordenados y tienen números de desplazamiento. A diferencia de los sistemas de cola tradicionales, los mensajes consumidos en Apache Kafka no se eliminan ni se destruyen, lo que permite que varias aplicaciones lean los datos repetidamente. Los datos también son inmutables, lo que garantiza la integridad de los datos pasados.
Y esas son aplicaciones que nosotros, los ingenieros, escribimos y controlamos y se llaman productores. Por otro lado, tenemos otras estructuras que empujarán los data, extraerán los data, leerán los data y harán lo que necesiten hacer con los data. Se llaman consumidores. Y puedes tener tantos productores y consumidores como necesites. Además, esos consumidores estarán leyendo data del clúster en paralelo. Es un sistema distribuido. Y lo que es increíble es que aquí en esta imagen los productores y consumidores pueden estar escritos en diferentes lenguajes. Quiero decir, no todo el mundo es fan de Javascript. Así que realmente puedes mezclar diferentes aplicaciones en diferentes lenguajes y plataformas. Y así es como Apache Kafka ayuda a desacoplar el sistema. También cuando envías data con tus productores y algo sucede con tus productores, los consumidores realmente no dependen directamente de los productores. No hay sincronización que se espera. No fui yo. ¿Puedes oírme? Sí. Adelante. Y sí. Puedes pausar técnicamente a los productores, puedes, por ejemplo, tus consumidores se caen, está bien, el consumidor se reiniciará y comenzará desde el momento en que se detuvo. Así que, como almacenamos los data de forma persistente en los discos, podemos hacer ese tipo de interacciones sin comunicación directa entre productores y consumidores. Así que ahora sabemos un poco sobre productores, consumidores, veamos qué sucede dentro del clúster. Veamos la estructura de data que tenemos allí. Así que un conjunto de eventos que proviene de uno o algunos tipos de fuentes se llama un tema. Un tema es en realidad un término abstracto, llegaremos a esto más tarde, pero digamos que es cómo hablamos de las cosas, no exactamente cómo se almacena en el disco. Y puedes ver un tema como una tabla en una database, así que puedes tener múltiples temas diferentes dentro de tu sistema. Y los mensajes en el tema están ordenados. Esto es en realidad un poco más complejo, lo tocaremos más tarde, pero todos tienen su número de desplazamiento. Puedes ver un tema como una cola, pero aquí hay un giro. En Apache Kafka, a diferencia de muchos otros sistemas de cola, los mensajes consumidos no se eliminan de la cola y no se destruyen. Puedes leer los data una y otra vez por múltiples aplicaciones diferentes o la misma aplicación si necesitas procesar estos data una vez más. Además, los data son inmutables.
5. Demostración de Productores y Consumidores en Apache Kafka
Short description:
Quería mostrar una demostración rápida utilizando Apache Kafka. Demostraré productores y consumidores y proporcionaré más experimentos en el repositorio. Podemos crear un productor que se comunique de manera segura con el clúster de Kafka utilizando SSL. Una vez que el productor esté listo, podemos generar y enviar datos al clúster. Para verificar los datos, podemos crear un consumidor utilizando Node-RD Kafka y comenzar a leer los datos.
Entonces, lo que sea que llegue allí, realmente no puedes cambiar los datos del pasado. Y es algo obvio si alguien compró una dona. Realmente no puedes ir al pasado y cambiar ese hecho, a menos que, por supuesto, seas Michael J. Fox y tengas un DeLorean, pero de lo contrario, si no te gusta la dona, tendrás que tirarla. Genial. Con esto, quería mostrar una demostración rápida. De hecho, preparé un repositorio de GitHub donde puedes revisar más cosas más tarde. Mostraré productores y consumidores, pero hay más experimentos en el repositorio que puedes reproducir. Necesitarás un clúster de Apache Kafka. Apache Kafka es un proyecto de código abierto. Puedes configurar el servidor localmente en tu máquina o usando Docker o usando una de las versiones administradas disponibles para Apache Kafka. Como trabajo en Ivan, necesito mencionar que tenemos Ivan para Apache Kafka, que en realidad puedes probar con una prueba gratuita de Ivan. Creemos un productor. Un productor puede ser como una función lambda o algo más. Por eso necesita saber dónde está ubicado el clúster. Además, cómo comunicarse con ese clúster de manera segura para que nadie pueda escuchar qué tipo de información estamos intercambiando. Y por eso estamos usando SSL. Hay diferentes formas en realidad para autenticar. Creo que la más común es en realidad usando TLS o SSL. Entonces, una vez que creamos el productor, podemos iniciarlo, y una vez que está en marcha, hay diferentes eventos a los que puedes suscribirte. El más probablemente útil es cuando está listo. Es como una vez que el productor está listo, podemos generar datos y comenzar a enviarlos al clúster. Entonces especificamos el nombre del tema, los datos en sí, algunos parámetros adicionales que son menos importantes, y también intento hacer que sea un flujo continuo de eventos, así que espero que los dioses de JavaScript no se ofendan de que estoy usando el bucle while true aquí. Y si te preguntas qué tengo en los datos, son solo datos generados para los clientes. Y también en el repositorio encontrarás muchos tipos diferentes de scripts que puedes ejecutar. Entonces aquí si ejecuto npm run produce y puedes clonar el repositorio y verlo, comenzamos a enviar los datos. Para verificar que los datos llegan al clúster podemos crear el consumidor que es algo similar. Entonces aquí, por cierto estoy usando Node-RD Kafka que es un envoltorio alrededor de la biblioteca libRD Kafka. Esa es mi biblioteca favorita de JavaScript para eso. Y sí, aquí simplemente hacemos de manera similar. Nos
6. Brokers, Particiones, Replicación y Conclusión
Short description:
Agreguemos un par de conceptos más a la historia: brokers y particiones. Cada partición tiene su propia enumeración para el registro, lo que dificulta mantener el orden. Las claves se pueden utilizar para garantizar el orden de los mensajes. La replicación es otro concepto importante, con cada broker conteniendo réplicas. No dudes en probar Ivan para Apache Kafka con nuestra prueba gratuita.
conectarse al flujo y comenzar a leer los data. Así que esto es bastante sencillo para la configuración mínima, técnicamente eso es lo que necesitas, no mucho más. Pero agreguemos un par de otros conceptos a la historia. Brokers y particiones. Ya mencioné que los clústeres de Kafka consisten en múltiples servidores. Entonces, esos servidores en el mundo de Kafka, los llamamos brokers. Cuando almacenamos los data en los múltiples servidores, es como un sistema distribuido, por lo que necesitamos de alguna manera cortar nuestro tema en trozos. Y lo que haremos, lo dividiremos y llamaremos a esos trozos particiones. Y esta es la parte complicada aquí, como la enumeración ahora en la diapositiva se ve súper bien, pero en realidad es una mentira. Porque todas las particiones son entidades independientes. Así que técnicamente, realmente no puedes tener estos números de desplazamiento a lo largo. Así que cada una de las particiones tendrá su propia enumeración para el registro. Y esto dificulta cuando almacenas data en diferentes servidores y luego lees los data. ¿Cómo mantienes el orden de los registros y te aseguras de que el orden en el que llegaron será el mismo que el que se van. Entonces para esto, estamos usando claves. Y nosotros, por ejemplo, podemos usar un ID de cliente como la clave y esto asegura que podemos garantizar el orden de los mensajes. También para mencionar otro concepto importante, replicación. Entonces, sistemas distribuidos. Así que cada uno de los brokers contendrá no solo los data de la partición, sino también algunas réplicas. Así que este es un factor de replicación de dos. Usualmente, en realidad, preferimos tres para que también puedas cuidar las ventanas de mantenimiento. Pero en general, sí, tienes data replicados. Creo que ya me estoy quedando sin tiempo. Aquí está el enlace, de nuevo, al repositorio. Hay más ejemplos allí con los que puedes jugar con las claves y simplemente clonarlo y funcionará. Y también puedes conectarte conmigo más tarde si quieres, si tienes alguna pregunta más tarde. Y no dudes en probar Ivan para Apache Kafka. Tenemos una prueba gratuita para Ivan para Apache Kafka y no necesitas tener detalles de tarjeta de crédito ni nada más. Con esto, muchas gracias por escucharme.
7. Introducción a Kafka y GDPR
Short description:
He oído hablar de Kafka antes, pero eso realmente reforzó muchos de los conceptos. Nuestra primera pregunta tiene que ver con el GDPR. ¿Puedes explicar cómo funciona la persistencia de los datos con el GDPR? Técnicamente, puedes mantener los datos en Apache Kafka todo el tiempo que necesites, pero es más común consumir y almacenar los datos en otros almacenes de datos. El GDPR realmente no entra en juego aquí, ya que puedes establecer un TTL para eliminar los datos más tarde o comprimirlos por la clave.
En primer lugar, excelente charla. Me encantan las animations. Esas fueron, como, he oído hablar de Kafka antes, pero eso realmente reforzó muchos de los conceptos. Así que sí, eso fue increíble.
Nuestra primera pregunta tiene que ver con el GDPR. Así que hablaste de cómo los data son inmutables o los data permanecen durante mucho tiempo. Entonces, ¿cuál es la historia de los data que persisten con el GDPR? Así que técnicamente hablando, y esto probablemente no sea un gran secreto, puedes mantener los data en Apache Kafka todo el tiempo que necesites. Sin embargo, normalmente no los mantendrías allí durante demasiado tiempo, porque también, probablemente consumirás los data y los almacenarás tal vez en algunos data stores, como, no sé, data lakes, si tienes muchos data. Así que por eso con el GDPR, realmente no entra en juego. También puedes poner un TTL, así que realmente puedes eliminar los data más tarde. También puedes comprimir los data, si lo haces por la clave, solo puedes mantener el ítem
8. Eliminación de Eventos en la Cola de Kafka
Short description:
Los eventos en la cola de Kafka se almacenan de forma persistente y pueden eliminarse en función del tiempo, tamaño o compresión por clave. La opción predeterminada es almacenar los datos durante un período especificado, como dos semanas. Alternativamente, se puede establecer el tamaño máximo del tema y, cuando se excede, se eliminan los mensajes más antiguos. Otra opción es comprimir los datos por una clave específica, como la ID del cliente, lo que resulta en la eliminación de mensajes más antiguos. Sin embargo, no es posible indicar selectivamente qué eventos eliminar.
con la clave más reciente. Así que sí. Genial. La siguiente pregunta es, ¿cómo y cuándo se destruyen los eventos en la cola de Kafka, ya que no se eliminan después del consumo? ¿No sé si tenías un ejemplo de eso? ¿Podrías repetir? ¿Cómo se eliminan los eventos? ¿Cómo salen de la cola? Se almacenan de forma persistente. Se eliminan ya sea cuando llega el tiempo, por lo que puedes decir, quiero tener los data almacenados durante dos semanas. De hecho, hay un valor predeterminado allí. O puedes decir que quiero mantener el tamaño máximo del tema, y una vez que el tamaño aumenta, los mensajes más antiguos comienzan a eliminarse. O quiero comprimir por la clave, por ejemplo, ID del cliente, por lo que luego se eliminan los mensajes más antiguos. Realmente no puedes ir e indicar
9. Offset del Consumidor y Esquema de Datos en Kafka
Short description:
Para los consumidores individuales, el offset realiza un seguimiento de los datos consumidos. Kafka permite almacenar cualquier tipo de datos, pero se recomienda restringirlo. Las diferentes formas de restringir los datos incluyen el uso de versionado y evitar formatos de texto o JSON.
cuál eliminar. Eso sería ineficiente. De acuerdo. Supongo que para un consumidor individual, ¿cómo hacen un seguimiento de lo que ya han consumido? Sí. El offset, que probablemente era un escenario más complejo, el offset, así que lo tenemos por partición, y los consumidores saben cómo trabajar con múltiples particiones. Así que seguirán con qué data fue consumida. Y por ejemplo, los consumidores se apagan, se detienen, y luego necesitan reiniciar. Así que recuerda los últimos elementos consumidos. De acuerdo. Sí, así es como funciona. ¡Genial! Y hay una pregunta sobre el esquema. Entonces, los data que estás almacenando en los eventos, ¿Kafka requiere, o eres capaz de restringir los data que almacenas en un esquema, o es algo libre? Así que a Kafka realmente no le importa qué data tú, quiero decir que no deberías almacenar allí películas en streaming, pero cuando se trata de objetos de data normales puedes almacenar lo que quieras. Estaba usando json solo por mi amor al json. Pero en realidad puedes y deberías restringir. Y hay diferentes formas de cómo puedes hacerlo, porque técnicamente el esquema evoluciona, así que quieres tener un versionado en eso, así que realmente no deberías intentar usar el formato de texto o incluso
10. Biblioteca RD Kafka y Soporte TypeScript
Short description:
La biblioteca RD Kafka es una elección poderosa para JavaScript con su amplia gama de características y alto rendimiento. Aunque puede que no sea la más fácil de usar, proporciona un buen soporte TypeScript y te permite asegurar la adhesión de eventos a propiedades específicas.
json. Sí, está bien. Esta pregunta es, ¿qué es mejor acerca de la biblioteca RD Kafka? Supongo, ¿existen otras? Hay tres o incluso más. Depende de tu caso de uso. Esta es probablemente la decisión más importante que tendrás que tomar si la usas para JavaScript. Me gusta esta biblioteca, porque envuelve la biblioteca Java completa, por lo que técnicamente soporta la gama más amplia de características, y también es la más eficiente, al menos hasta donde yo sé. Sin embargo, podría no ser la más fácil de usar, para ser honesto. Y supongo que el soporte de TypeScript varía entre ellas, pero la que mostraste, ¿tiene un buen soporte de TypeScript? Puedes pasar un tipo para asegurarte de que los eventos se adhieran a esas propiedades? Noté algunas cosas que realmente no me gustaron. Yo estaba como, no, no lo soportas, pero está bien. Diría que es mejor que nada.
11. Alternativas a Kafka y Consistencia
Short description:
Al considerar alternativas a Kafka, depende de tus necesidades de almacenamiento de datos y fiabilidad. Si no requieres almacenamiento de datos o no te importa perder datos, un sistema de colas puede ser suficiente. Redis y RabbitMQ se comparan a menudo con Kafka, pero la clave está en las capacidades de replicación y almacenamiento persistente de Kafka. Los productores y consumidores en Kafka son entidades separadas, garantizando la consistencia al permitir que los datos se envíen rápidamente y se almacenen. La velocidad y eficiencia del procesamiento de datos pueden variar entre productores y consumidores, pero existen técnicas para optimizar el rendimiento. En comparación, RabbitMQ requiere un desarrollo adicional para garantizar conexiones estables y retención de datos.
Genial, entonces alguien está preguntando, ¿existen alternativas a Kafka o algo que usarías o recomendarías aparte de Kafka? Creo que depende porque puedes usar, si realmente no necesitas almacenar los data o te da igual perder data, entonces puedes usar simplemente un sistema de colas porque Kafka es, quiero decir, Kafka es increíble. Creo que puede hacer tantas cosas diferentes, pero también con ello, viene la responsabilidad de mantener el clúster y cuidar de eso. Si realmente no necesitas todas esas réplicas y sistema distribuido, puedes simplemente elegir una cola. Vale. Y esto lleva a una pregunta similar. Entonces, ¿cómo es diferente a algo como Redis? Porque sé que con Redis, puedes hacer un sistema de colas o de mensajería. Creo que con Redis es completamente diferente. Existe RebitMQ. Eso es donde realmente usualmente se compara. Así que Redis es un almacenamiento de data y Kafka es una solución de transmisión. Pero también como, a menudo la pregunta que escucho es como, ¿cómo es diferente de RebitMQ, por ejemplo? Y la diferencia es esa replicación de data, ese almacenamiento persistente de los data. Así que si realmente no tienes que mantener los data dentro por ti mismo, Kafka lo hace, y también tus productores, consumidores pueden dejar de funcionar aleatoriamente porque está vivo cuando tus servidores se caen y realmente, es como el escenario totalmente normal para Apache Kafka. Así que esa es la mayor diferencia porque soporta todo el ecosystem de asegurarte de que no estás perdiendo data en absoluto.
Y eso lleva a la siguiente pregunta, que es, ¿cómo garantizas la consistencia entre productores y consumidores? Vale. Así que entre productores y consumidores, son entidades separadas. Nosotros separamos esos. Realmente no tienes ese problema. Estoy pensando ahora mismo, realmente no creo que tengas ese problema. Así que estás en un lado, envías los data. Así que tu productor solo es responsable de enviar data rápidamente. Y luego los data llegan y se almacenan en el medio, los tienes ahí. Y luego los consumidores, realmente no saben nada sobre los productores en absoluto. Realmente no necesitan saber. Ellos realmente saben sobre este tipo de tema, y luego leen los data uno por uno. Así que, pero quizás la consistencia es la cosa es que cuánto se atrasa tu productor, porque lleva tiempo, ¿verdad? Y a veces algunos de tus consumidores pueden ser lentos. Así que quizás la diferencia entre cuánto se atrasan tus consumidores en procesar los data, que fueron producidos por los productores. Quiero decir, probablemente eso es muy complejo también, pero es solo como cuánto tiempo lleva, cuán eficiente es el sistema. Así que puedes medir eso. Y hay diferentes trucos para hacerlo más rápido. Vale. Y una última pregunta para ti, ¿cómo son las colas de mensajes fiables en RabbitMQ, o dices que puedes hacer colas de mensajes fiables en RabbitMQ, es eso diferente de Kafka? Es bastante diferente. Para ser honesto, puede que no entre en tanto detalle con RabbitMQ, pero con RabbitMQ, tendrás que construir mucho encima para asegurarte de que tienes una conexión estable entre... Así que si algo se cae, que no estás perdiendo data. Versus, creo, Kafka está construido de... Esa es la parte principal, estos data replicados y no perderlos. Vale, genial. Bueno, ¿podemos darle a Elena otra ronda de aplausos? Muchas gracias, Elena. Gracias. Muchas gracias.
Today's Talk focuses on React's best types and JSX. It covers the types of JSX and React components, including React.fc and React.reactnode. The discussion also explores JSX intrinsic elements and react.component props, highlighting their differences and use cases. The Talk concludes with insights on using React.componentType and passing components, as well as utilizing the react.element ref type for external libraries like React-Select.
React and TypeScript have a strong relationship, with TypeScript offering benefits like better type checking and contract enforcement. Failing early and failing hard is important in software development to catch errors and debug effectively. TypeScript provides early detection of errors and ensures data accuracy in components and hooks. It offers superior type safety but can become complex as the codebase grows. Using union types in props can resolve errors and address dependencies. Dynamic communication and type contracts can be achieved through generics. Understanding React's built-in types and hooks like useState and useRef is crucial for leveraging their functionality.
Daniel Rowe discusses building a TypeScript-first framework at TypeScript Congress and shares his involvement in various projects. Nuxt is a progressive framework built on Vue.js, aiming to reduce friction and distraction for developers. It leverages TypeScript for inference and aims to be the source of truth for projects. Nuxt provides type safety and extensibility through integration with TypeScript. Migrating to TypeScript offers long-term maintenance benefits and can uncover hidden bugs. Nuxt focuses on improving existing tools and finds inspiration in frameworks like TRPC.
Designing APIs is a challenge, and it's important to consider the language used and different versions of the API. API ergonomics focus on ease of use and trade-offs. Routing is a misunderstood aspect of API design, and file-based routing can simplify it. Unplugging View Router provides typed routes and eliminates the need to pass routes when creating the router. Data loading and handling can be improved with data loaders and predictable routes. Handling protected routes and index and ID files are also discussed.
This talk discusses the performance issues in TypeScript builds and introduces a new feature called isolated declarations. By running the compiler in parallel and using isolated modules, significant performance gains can be achieved. Isolated declarations improve build speed, compatibility with other tools, and require developers to write types in code. This feature has the potential to further increase performance and may be available in TypeScript soon.
Alex introduces tRPC, a toolkit for making end-to-end type-safe APIs easily, with auto-completion of API endpoints and inferred data from backend to frontend. tRPC works the same way in React Native and can be adopted incrementally. The example showcases backend communication with a database using queries and validators, with types inferred to the frontend and data retrieval done using Prisma ORM.
ReactJS es extremadamente popular y, por lo tanto, ampliamente soportado. TypeScript está ganando popularidad y, por lo tanto, cada vez más soportado.
¿Los dos juntos? No tanto. Dado que ambos cambian rápidamente, es difícil encontrar materiales de aprendizaje precisos.
¿React+TypeScript, con los IDEs de JetBrains? Esa combinación de tres partes es el tema de esta serie. Mostraremos un poco sobre mucho. Es decir, los pasos clave para ser productivo, en el IDE, para proyectos de React utilizando TypeScript. En el camino, mostraremos el desarrollo guiado por pruebas y enfatizaremos consejos y trucos en el IDE.
TypeScript no es solo tipos e interfaces. Únete a esta masterclass para dominar características más avanzadas de TypeScript que harán tu código a prueba de balas. Cubriremos tipos condicionales y notación de inferencia, cadenas de plantillas y cómo mapear sobre tipos de unión y propiedades de objetos/arrays. Cada tema se demostrará en una aplicación de muestra que se escribió con tipos básicos o sin tipos en absoluto y juntos mejoraremos el código para que te familiarices más con cada característica y puedas llevar este nuevo conocimiento directamente a tus proyectos. Aprenderás:- - ¿Qué son los tipos condicionales y la notación de inferencia?- ¿Qué son las cadenas de plantillas?- Cómo mapear sobre tipos de unión y propiedades de objetos/arrays.
TypeScript tiene un sistema de tipos poderoso con todo tipo de características sofisticadas para representar estados de JavaScript salvajes y extravagantes. Pero la sintaxis para hacerlo no siempre es sencilla, y los mensajes de error no siempre son precisos al decirte qué está mal. Vamos a profundizar en cómo funcionan muchas de las características más poderosas de TypeScript, qué tipos de problemas del mundo real resuelven, y cómo dominar el sistema de tipos para que puedas escribir código TypeScript verdaderamente excelente.
¿Eres un desarrollador de React tratando de obtener los máximos beneficios de TypeScript? Entonces esta es la masterclass para ti.En esta masterclass interactiva, comenzaremos desde lo básico y examinaremos los pros y contras de las diferentes formas en que puedes declarar componentes de React usando TypeScript. Después de eso, pasaremos a conceptos más avanzados donde iremos más allá de la configuración estricta de TypeScript. Aprenderás cuándo usar tipos como any, unknown y never. Exploraremos el uso de predicados de tipo, guardias y comprobación exhaustiva. Aprenderás sobre los tipos mapeados incorporados, así como cómo crear tus propias utilidades de mapa de tipo nuevo. Y comenzaremos a programar en el sistema de tipos de TypeScript usando tipos condicionales e inferencia de tipos.
Imagina desarrollar donde el frontend y el backend cantan en armonía, los tipos bailan en perfecta sincronía y los errores se convierten en un recuerdo lejano. ¡Eso es la magia de TypeScript Nirvana! Únete a mí en un viaje para descubrir los secretos de las definiciones de tipos unificadas, la clave para desbloquear un desarrollo sin fricciones. Nos sumergiremos en: - Lenguaje compartido, amor compartido: Define los tipos una vez y compártelos en todas partes. La consistencia se convierte en tu mejor amiga, los errores en tu peor pesadilla (uno que rara vez verás).- Codificación sin esfuerzo: Olvídate de la tediosa tarea de comprobar tipos manualmente. TypeScript te respalda, liberándote para centrarte en construir cosas increíbles.- Magia de mantenibilidad: Con tipos claros que guían tu código, mantenerlo se convierte en un paseo por el parque. Más tiempo para innovar, menos tiempo para depurar.- Fortaleza de seguridad: El sistema de tipos de TypeScript protege tu aplicación de vulnerabilidades comunes, convirtiéndola en una fortaleza contra amenazas de seguridad.
Comments