Arquitectura Event-Driven: Asincronía Robusta con RabbitMQ y Kafka
Arquitectura Event-Driven: Mensajería Asíncrona con RabbitMQ y Apache Kafka
En el vertiginoso mundo del desarrollo de software, la capacidad de construir sistemas que sean escalables, resilientes y desacoplados es fundamental. Las arquitecturas monolíticas y la comunicación síncrona, si bien son sencillas de implementar inicialmente, a menudo se convierten en cuellos de botella y puntos únicos de falla a medida que las aplicaciones crecen en complejidad y volumen de usuarios. Es aquí donde la Arquitectura Event-Driven (EDA) emerge como un patrón transformador.
1. Introducción al Desafío del Acoplamiento y la Escalabilidad
Imagina un escenario común en el comercio electrónico: un usuario realiza un pedido. Tras la confirmación, se deben realizar múltiples acciones: actualizar el inventario, procesar el pago, enviar una notificación al cliente, alertar al almacén para el envío y actualizar el historial de compras del usuario. En una arquitectura monolítica síncrona, todas estas operaciones podrían estar encadenadas, haciendo que el proceso sea lento, propenso a fallos (si una de las operaciones falla, todo el pedido podría revertirse) y difícil de escalar de forma independiente. Cada nueva funcionalidad que requiere reaccionar a la creación de un pedido añade complejidad y acoplamiento directo al servicio de pedidos.
Este enfoque presenta desafíos significativos:
- Acoplamiento Fuerte: Los servicios están intrínsecamente ligados; un cambio en un servicio puede requerir cambios en muchos otros.
- Escalabilidad Limitada: El escalado vertical puede ser costoso y los cuellos de botella en un solo componente afectan a todo el sistema.
- Resiliencia Baja: Un fallo en cualquier parte de la cadena síncrona puede detener toda la transacción.
- Dificultad en la Mantenibilidad: La base de código se vuelve compleja y difícil de entender y modificar.
La EDA, mediante el uso de mensajería asíncrona, resuelve estos problemas al permitir que los componentes de software se comuniquen de forma indirecta, reaccionando a eventos que ocurren en el sistema.
2. Conceptos Clave y Arquitectura de Eventos
La EDA se basa en la producción, detección, consumo y reacción a eventos. Un evento es un hecho significativo que ha ocurrido en el sistema (ej. PedidoRealizado, ProductoActualizado). Los eventos son inmutables y no implican una acción específica; simplemente anuncian que algo pasó.
2.1. Componentes Fundamentales de EDA
- Productores de Eventos (Publishers): Entidades que detectan cambios de estado o sucesos y los publican como eventos. No tienen conocimiento de quién consumirá el evento.
- Consumidores de Eventos (Subscribers): Entidades interesadas en ciertos tipos de eventos. Escuchan los eventos y reaccionan de forma independiente.
- Broker de Mensajes / Plataforma de Streaming: Componente central que recibe los eventos de los productores y los entrega a los consumidores interesados. Garantiza la fiabilidad y el desacoplamiento.
2.2. Flujo Básico de Mensajería Asíncrona
- Un servicio (
ServicioPedidos) realiza una acción (ej. un pedido se completa). - El
ServicioPedidospublica un evento (PedidoRealizado) al broker de mensajes. - El
ServicioPedidoscontinúa su procesamiento sin esperar una respuesta. - El broker de mensajes recibe el evento y lo distribuye a todos los servicios suscritos.
ServicioInventarioconsume el eventoPedidoRealizadoy actualiza el stock.ServicioNotificacionesconsume el mismo eventoPedidoRealizadoy envía un email al cliente.ServicioAnalíticasconsume el mismo eventoPedidoRealizadoy actualiza las métricas.
Este flujo permite que los servicios operen de forma autónoma y que nuevos servicios puedan “reaccionar” a eventos existentes sin modificar a los productores.
2.3. RabbitMQ: Mensajería Basada en Queues (AMQP)
RabbitMQ es un broker de mensajes de código abierto que implementa el protocolo Advanced Message Queuing Protocol (AMQP) 0.9.1. Es excelente para escenarios de mensajería con garantías de entrega sólidas, enrutamiento complejo y procesamiento de tareas.
- Paradigma: Principalmente “message queue” y “publish/subscribe”.
- Características clave:
- Queues (Colas): Donde los mensajes esperan a ser procesados por los consumidores.
- Exchanges (Intercambios): Reciben mensajes de los productores y los enrutan a las colas basándose en reglas (binding keys, routing keys). Tipos:
direct,topic,fanout,headers. - Bindings: Conexiones entre exchanges y queues, especificando las reglas de enrutamiento.
- Ack/Nack: Confirmación positiva o negativa de procesamiento de mensajes por parte del consumidor, garantizando la entrega y el reintento.
- Persistencia: Puede almacenar mensajes en disco para sobrevivir a reinicios.
RabbitMQ es ideal para:
- Procesamiento de tareas asíncronas (work queues).
- Comunicación punto a punto o uno-a-muchos cuando el orden y la entrega garantizada por consumidor son críticos.
- Enrutamiento complejo de mensajes basado en reglas.
- Microservicios que necesitan comunicar comandos o eventos con garantía de entrega.
2.4. Apache Kafka: Plataforma de Streaming de Eventos Distribuida
Apache Kafka es una plataforma de streaming de eventos distribuida, escalable y persistente. Se diferencia de los brokers de mensajes tradicionales al tratar los eventos como un “log” inmutable y replicado.
- Paradigma: “Distributed Commit Log” o “Event Streaming Platform”.
- Características clave:
- Topics: Categorías a las que los productores publican eventos y de las que los consumidores leen. Son logs de eventos particionados.
- Partitions (Particiones): Un topic se divide en particiones, permitiendo el escalado horizontal y el procesamiento paralelo. El orden de los eventos se garantiza dentro de una partición.
- Offsets: Cada evento en una partición tiene un ID secuencial (offset). Los consumidores mantienen su propio offset, permitiendo relecturas y flexibilidad.
- Brokers: Servidores que almacenan los logs de eventos (particiones). Un clúster de Kafka consiste en múltiples brokers.
- Zookeeper (o KRaft para versiones recientes): Coordina los brokers y mantiene metadatos del clúster. KRaft (Kafka Raft) es el nuevo mecanismo de consenso integrado que elimina la dependencia de Zookeeper en versiones modernas de Kafka (a partir de 2.8, GA en 3.x).
- Persistencia: Los eventos se almacenan en disco por un período configurable, permitiendo a los consumidores procesarlos a su propio ritmo o incluso volver a procesar eventos pasados.
Kafka es ideal para:
- Flujos de datos en tiempo real y alto volumen (ingesta de logs, métricas).
- Event Sourcing: Reconstruir el estado de una aplicación a partir de un log de eventos.
- Procesamiento de streams de eventos (Kafka Streams, ksqlDB).
- Comunicación entre microservicios donde el alto rendimiento, la durabilidad y la capacidad de relectura son cruciales.
3. Ejemplos de Código Real o Configuración Práctica
Utilizaremos Python por su claridad y facilidad de uso con ambas tecnologías. Asegúrate de tener RabbitMQ y Kafka (y Zookeeper, si no usas KRaft) corriendo localmente o en un entorno de desarrollo.
3.1. RabbitMQ: Publicador y Consumidor
Instalación:
pip install pika
Productor (producer.py):
Este ejemplo envía un mensaje a un exchange de tipo fanout, lo que significa que lo envía a todas las colas vinculadas.
import pika
import json
import time
def publish_order_event(order_id, user_id, items, total_amount):
"""
Publica un evento de Pedido Realizado en RabbitMQ.
"""
connection = None
try:
# Establecer conexión con RabbitMQ (usando el host por defecto)
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# Declarar un exchange de tipo 'fanout'
# 'fanout' significa que todos los mensajes enviados a este exchange
# serán enviados a todas las colas vinculadas a él.
exchange_name = 'order_events_exchange'
channel.exchange_declare(exchange=exchange_name, exchange_type='fanout')
event_data = {
"order_id": order_id,
"user_id": user_id,
"items": items,
"total_amount": total_amount,
"timestamp": time.time()
}
message = json.dumps(event_data)
# Publicar el mensaje al exchange
# La routing_key es ignorada por exchanges de tipo 'fanout'
channel.basic_publish(
exchange=exchange_name,
routing_key='',
body=message,
properties=pika.BasicProperties(
delivery_mode=pika.spec.PERSISTENT_DELIVERY_MODE # Hacer el mensaje persistente
)
)
print(f" [x] Publicado evento de pedido: {event_data}")
except pika.exceptions.AMQPConnectionError as e:
print(f"Error al conectar con RabbitMQ: {e}")
finally:
if connection and not connection.is_closed:
connection.close()
if __name__ == '__main__':
print("Iniciando Productor de Pedidos RabbitMQ...")
# Ejemplo de uso
publish_order_event("ORD-001", "USER-123", ["itemA", "itemB"], 150.75)
publish_order_event("ORD-002", "USER-456", ["itemC"], 75.20)
time.sleep(1) # Dar tiempo para que el mensaje se publique
Consumidor de Inventario (inventory_consumer.py):
Este consumidor escucha eventos de order_events_exchange y simula la actualización de inventario.
import pika
import json
import time
def inventory_callback(ch, method, properties, body):
"""
Callback para procesar eventos de pedido y actualizar inventario.
"""
try:
event_data = json.loads(body)
print(f" [x] [Inventario] Recibido evento de pedido: {event_data['order_id']}")
# Simular lógica de actualización de inventario
print(f" Actualizando inventario para los ítems: {event_data['items']}")
time.sleep(0.5) # Simular trabajo
ch.basic_ack(delivery_tag=method.delivery_tag) # Confirmar procesamiento exitoso
print(f" [Inventario] Inventario actualizado para pedido {event_data['order_id']}")
except json.JSONDecodeError:
print(f" [x] [Inventario] Error al decodificar JSON: {body}")
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True) # Reencolar si hay error de formato
except Exception as e:
print(f" [x] [Inventario] Error inesperado: {e}, mensaje: {body}")
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True) # Reencolar en caso de otros errores
def start_inventory_consumer():
connection = None
try:
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
exchange_name = 'order_events_exchange'
channel.exchange_declare(exchange=exchange_name, exchange_type='fanout')
# Declarar una cola exclusiva para este consumidor, que se borrará al desconectar
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue
# Vincular la cola al exchange
channel.queue_bind(exchange=exchange_name, queue=queue_name)
print(f" [*] [Inventario] Esperando eventos de pedidos en cola: {queue_name}. Para salir, CTRL+C")
# Empezar a consumir mensajes de la cola
channel.basic_consume(
queue=queue_name,
on_message_callback=inventory_callback,
auto_ack=False # Deshabilitar auto-ack para control manual
)
channel.start_consuming()
except pika.exceptions.AMQPConnectionError as e:
print(f"Error al conectar con RabbitMQ: {e}")
except KeyboardInterrupt:
print(" [x] [Inventario] Consumidor detenido.")
finally:
if connection and not connection.is_closed:
connection.close()
if __name__ == '__main__':
start_inventory_consumer()
Consumidor de Notificaciones (notification_consumer.py): Otro consumidor que reacciona al mismo evento, simulando el envío de notificaciones.
import pika
import json
import time
def notification_callback(ch, method, properties, body):
"""
Callback para procesar eventos de pedido y enviar notificaciones.
"""
try:
event_data = json.loads(body)
print(f" [x] [Notificaciones] Recibido evento de pedido: {event_data['order_id']}")
# Simular lógica de envío de notificación
print(f" Enviando notificación al usuario: {event_data['user_id']} para pedido {event_data['order_id']}")
time.sleep(0.3) # Simular trabajo
ch.basic_ack(delivery_tag=method.delivery_tag) # Confirmar procesamiento exitoso
print(f" [Notificaciones] Notificación enviada para pedido {event_data['order_id']}")
except json.JSONDecodeError:
print(f" [x] [Notificaciones] Error al decodificar JSON: {body}")
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
except Exception as e:
print(f" [x] [Notificaciones] Error inesperado: {e}, mensaje: {body}")
ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
def start_notification_consumer():
connection = None
try:
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
exchange_name = 'order_events_exchange'
channel.exchange_declare(exchange=exchange_name, exchange_type='fanout')
# Declarar una cola exclusiva para este consumidor
result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue
# Vincular la cola al exchange
channel.queue_bind(exchange=exchange_name, queue=queue_name)
print(f" [*] [Notificaciones] Esperando eventos de pedidos en cola: {queue_name}. Para salir, CTRL+C")
channel.basic_consume(
queue=queue_name,
on_message_callback=notification_callback,
auto_ack=False
)
channel.start_consuming()
except pika.exceptions.AMQPConnectionError as e:
print(f"Error al conectar con RabbitMQ: {e}")
except KeyboardInterrupt:
print(" [x] [Notificaciones] Consumidor detenido.")
finally:
if connection and not connection.is_closed:
connection.close()
if __name__ == '__main__':
start_notification_consumer()
Para probarlo:
- Inicia RabbitMQ.
- Ejecuta
python inventory_consumer.pyen una terminal. - Ejecuta
python notification_consumer.pyen otra terminal. - Ejecuta
python producer.pyen una tercera terminal. Verás cómo ambos consumidores reciben el mismo evento.
3.2. Apache Kafka: Publicador y Consumidor
Para Kafka, utilizaremos confluent-kafka-python, un wrapper eficiente para librdkafka.
Instalación:
pip install confluent-kafka
Productor (kafka_producer.py):
from confluent_kafka import Producer
import json
import time
import socket
def produce_order_event_kafka(order_id, user_id, items, total_amount):
"""
Publica un evento de Pedido Realizado en Apache Kafka.
"""
# Configuración del productor de Kafka
# Se recomienda usar la versión más reciente de Kafka, por ejemplo, 3.x
conf = {
'bootstrap.servers': 'localhost:9092', # Brokers de Kafka
'client.id': socket.gethostname()
}
producer = Producer(conf)
topic_name = 'order_events'
event_data = {
"order_id": order_id,
"user_id": user_id,
"items": items,
"total_amount": total_amount,
"timestamp": time.time()
}
message = json.dumps(event_data).encode('utf-8')
def delivery_report(err, msg):
""" Callback para reportar el resultado de la entrega """
if err is not None:
print(f"Fallo en la entrega del mensaje: {err}")
else:
print(f"Mensaje entregado al tópico {msg.topic()} [{msg.partition()}] @ {msg.offset()}")
try:
# Enviar el mensaje de forma asíncrona
# La clave del mensaje (order_id) es importante para garantizar el orden dentro de una partición.
producer.produce(topic_name, key=str(order_id).encode('utf-8'), value=message, callback=delivery_report)
producer.poll(0) # Permite que el callback se ejecute de forma asíncrona
print(f" [x] Publicado evento de pedido a Kafka: {event_data['order_id']}")
except Exception as e:
print(f"Error al producir mensaje en Kafka: {e}")
finally:
# Esperar a que todos los mensajes pendientes sean entregados
producer.flush()
if __name__ == '__main__':
print("Iniciando Productor de Pedidos Kafka...")
produce_order_event_kafka("KORD-001", "KUSER-101", ["itemX", "itemY"], 200.00)
produce_order_event_kafka("KORD-002", "KUSER-102", ["itemZ"], 120.50)
time.sleep(1)
Consumidor de Inventario (kafka_inventory_consumer.py):
from confluent_kafka import Consumer, KafkaException, OFFSET_BEGINNING
import json
import sys
import time
def consume_order_events_kafka_inventory():
"""
Consume eventos de pedido de Kafka y simula la actualización de inventario.
"""
# Configuración del consumidor de Kafka
conf = {
'bootstrap.servers': 'localhost:9092',
'group.id': 'inventory_service_group', # ID del grupo de consumidores
'auto.offset.reset': 'earliest', # Empieza a leer desde el inicio si no hay offset guardado
'enable.auto.commit': False # Deshabilitar auto-commit para control manual
}
consumer = Consumer(conf)
topic_name = 'order_events'
try:
consumer.subscribe([topic_name]) # Suscribirse al topic
print(f" [*] [Inventario Kafka] Esperando eventos de pedidos en tópico '{topic_name}'. Para salir, CTRL+C")
while True:
msg = consumer.poll(timeout=1.0) # Esperar hasta 1 segundo por un mensaje
if msg is None:
continue
if msg.error():
if msg.error().code() == KafkaException._PARTITION_EOF:
# Fin de la partición, no es un error real, solo informativo
sys.stderr.write(f"%% {msg.topic()} [{msg.partition()}] reached end at offset {msg.offset()}\n")
elif msg.error():
raise KafkaException(msg.error())
else:
# Mensaje válido recibido
event_data = json.loads(msg.value().decode('utf-8'))
print(f" [x] [Inventario Kafka] Recibido evento de pedido: {event_data['order_id']} "
f"(Partition: {msg.partition()}, Offset: {msg.offset()})")
# Simular lógica de actualización de inventario
print(f" Actualizando inventario para ítems: {event_data['items']}")
time.sleep(0.5) # Simular trabajo
print(f" [Inventario Kafka] Inventario actualizado para pedido {event_data['order_id']}")
consumer.commit(message=msg) # Confirmar manualmente el offset del mensaje procesado
except KeyboardInterrupt:
print(" [x] [Inventario Kafka] Consumidor detenido.")
except KafkaException as e:
print(f"Error en Kafka: {e}")
finally:
consumer.close()
if __name__ == '__main__':
consume_order_events_kafka_inventory()
Para probarlo:
- Inicia Kafka y Zookeeper (o tu clúster Kafka con KRaft).
- Crea el topic
order_events(ej:kafka-topics --create --topic order_events --bootstrap-server localhost:9092 --partitions 3 --replication-factor 1). - Ejecuta
python kafka_inventory_consumer.pyen una terminal. - Ejecuta
python kafka_producer.pyen otra terminal. Verás cómo el consumidor procesa los eventos. Puedes iniciar múltiples instancias del consumidor de inventario (con el mismogroup.id) y Kafka distribuirá las particiones entre ellas para escalar el procesamiento.
4. Ventajas, Desafíos y Trade-offs Técnicos
4.1. Ventajas de la Arquitectura Event-Driven
- Desacoplamiento Robusto: Los servicios no necesitan conocerse entre sí. Solo necesitan saber cómo producir o consumir un tipo de evento específico. Esto facilita el desarrollo y el mantenimiento.
- Escalabilidad Superior: Los productores y consumidores pueden escalar de forma independiente. Si un servicio se vuelve lento, no detiene a los demás; los eventos simplemente se acumulan en el broker hasta que el servicio pueda procesarlos.
- Resiliencia Mejorada: Los fallos en un consumidor no afectan al productor, y los mensajes pueden reintentarse. Los brokers garantizan la persistencia de los mensajes.
- Flexibilidad y Agilidad: Es más fácil añadir nuevas funcionalidades. Simplemente se añade un nuevo consumidor que reacciona a eventos existentes, sin modificar a los productores.
- Observabilidad y Auditoría: Los eventos actúan como un registro inmutable de lo que ha sucedido en el sistema, lo que facilita la depuración, auditoría y análisis de datos históricos (especialmente con Kafka).
4.2. Desafíos y Consideraciones Técnicas
- Complejidad Operacional y de Desarrollo: Introducir un broker de mensajes añade una capa más al sistema, requiriendo su gestión, monitoreo y mantenimiento. El modelo mental de EDA es diferente al síncrono.
- Consistencia Eventual: Los sistemas EDA son inherentemente eventualmente consistentes. Esto significa que, después de que un evento es publicado, puede haber un retraso antes de que todos los consumidores lo procesen y los datos se vuelvan consistentes en todo el sistema. Esto requiere un diseño cuidadoso de la UX y la lógica de negocio.
- Manejo de Errores y Retries: Los consumidores deben ser robustos ante fallos. El manejo de mensajes fallidos (que pueden ir a “dead-letter queues” o reintentarse) es crucial.
- Idempotencia: Los consumidores deben ser capaces de procesar el mismo evento múltiples veces sin causar efectos secundarios no deseados, ya que los reintentos o fallos pueden generar duplicados.
- Orden de Eventos: Garantizar el orden global de los eventos es difícil en un sistema distribuido. Kafka garantiza el orden dentro de una partición, lo que a menudo es suficiente si la clave de partición se elige cuidadosamente. RabbitMQ garantiza el orden por cola.
- Depuración: Seguir el flujo de un evento a través de múltiples servicios asíncronos puede ser más complejo que en una llamada síncrona. La correlación de IDs (
correlation_id) es esencial.
4.3. Trade-offs: ¿RabbitMQ o Apache Kafka?
La elección entre RabbitMQ y Kafka depende en gran medida de los requisitos específicos del proyecto:
| Característica | RabbitMQ (ej. 3.x) | Apache Kafka (ej. 3.x) |
|---|---|---|
| Modelo Principal | Message Queue, Enrutamiento complejo | Distributed Commit Log, Event Streaming |
| Tipo de Mensajería | Principalmente Punto-a-Punto o Pub/Sub con enrutamiento | Pub/Sub persistente con capacidad de relectura |
| Rendimiento | Bueno para alto volumen, optimizado para bajo TTL | Excelente para alto volumen y alto throughput, baja latencia |
| Persistencia | Mensajes almacenados hasta que son consumidos/ACK | Todos los eventos persisten por un período configurable |
| Orden de Mensajes | Garantizado por cola | Garantizado dentro de una partición |
| Patrones Ideales | Work Queues, RPC asíncrono, enrutamiento complejo | Event Sourcing, Data Pipelines, Stream Processing, Microservicios |
| Escalabilidad | Puede escalar horizontalmente (exchanges/queues) | Diseñado para escalar horizontalmente (brokers, particiones) |
| Manejo de Consumidores | Consumidores individuales por cola, comparten mensajes | Grupos de consumidores, cada grupo lee su propio offset |
| Complejidad | Relativamente más simple de configurar y operar para casos básicos | Mayor complejidad inicial debido a su naturaleza distribuida y log-based |
Cuándo usar RabbitMQ:
- Necesitas un enrutamiento de mensajes muy flexible y complejo.
- Procesamiento de tareas con
work queuesdonde un mensaje es procesado por un único consumidor. - RPC asíncrono o comunicación comando-respuesta.
- Garantías de entrega “at most once”, “at least once” o “exactly once” (con transacciones y idempotencia del consumidor).
- Proyectos con requisitos de baja latencia para un número limitado de consumidores y un menor volumen total de datos.
Cuándo usar Apache Kafka:
- Necesitas gestionar grandes volúmenes de eventos en tiempo real (
big data streams). - Tu arquitectura se beneficia del Event Sourcing, donde el historial de eventos es la fuente de verdad.
- Quieres la capacidad de re-procesar eventos históricos.
- Necesitas alta disponibilidad y durabilidad de los datos.
- Tienes múltiples grupos de consumidores que necesitan leer los mismos eventos de forma independiente.
- Integración de sistemas o microservicios que requieren compartir un flujo continuo de datos.
5. Conclusión y Perspectivas Futuras
La Arquitectura Event-Driven es un pilar fundamental en la construcción de sistemas distribuidos modernos. Permite a los desarrolladores diseñar soluciones que no solo cumplen con los requisitos actuales de escalabilidad y resiliencia, sino que también se adaptan con gracia a las necesidades futuras. Al desacoplar servicios y fomentar la comunicación asíncrona, EDA reduce la complejidad incidental y acelera la entrega de valor.
La elección entre RabbitMQ y Apache Kafka no es de “uno mejor que el otro”, sino de “cuál es el más adecuado para el problema en cuestión”. Ambos son herramientas potentes con fortalezas distintivas, y a menudo, en arquitecturas empresariales complejas, pueden coexistir, utilizándose para diferentes propósitos.
Mirando hacia el futuro, la EDA continúa evolucionando. La aparición de conceptos como Event Mesh (una capa para interconectar brokers y flujos de eventos a través de diferentes entornos), la madurez de serverless EDA (con servicios como AWS EventBridge o Azure Event Grid) y el avance en el procesamiento de streams con inteligencia artificial integrada, prometen llevar la capacidad de reacción y análisis en tiempo real a niveles sin precedentes. Dominar la EDA y sus herramientas como RabbitMQ y Kafka es, sin duda, una habilidad esencial para cualquier arquitecto o desarrollador de software que aspire a construir sistemas preparados para el futuro.