Forma a tu equipo sin coste para tu empresa. Este curso de Microservicios en .Net es hasta 100% bonificable a través de FUNDAE.
Potencia las competencias clave de tus profesionales.
Accede a una formación práctica, actualizada y orientada a resultados.
Prepara a tu equipo para los retos del entorno laboral actual.
Nos ocupamos de la gestión con FUNDAE si tu empresa lo necesita.
A medida
Formación en Microservicios en .Net a medida
Descubre el mejor curso de Microservicios en .Net para empresas con nuestra Aula Virtual Personalizada:
Sesiones en vivo por videoconferencia.
Temario totalmente personalizado.
Fechas y horarios adaptados a tu empresa.
Acceso a grabaciones.
Aprende practicando
Totalmente Práctico y Aplicable
Formación diseñada para que apliques cada concepto en situaciones reales de tu trabajo, con enfoque práctico y útil desde el primer momento.
Aprendizaje 100% práctico, enfocado en lo que realmente necesitas.
Casos reales y ejercicios adaptados a tu entorno profesional.
Aplica cada conocimiento directamente en tus tareas diarias.
Mejora tu rendimiento y el de tu equipo desde el primer día.
¿Por qué un curso en Microservicios en .Net?
Alinea arquitectura, DevOps y negocio
Diseñamos formación A Medida en Microservicios con C# y .Net para equipos, arquitectura limpia y despliegue, bonificable FUNDAE. Solicita propuesta a medida.
Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.
Correccion magica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
¿A quién va dirigida esta formación en Microservicios en .Net?
Pensado para quienes deben dominar Microservicios en .Net en su día a día
Desarrolladores backend .NET
Este curso encaja con desarrolladores que ya trabajan con C#, ASP.NET Core, APIs, Entity Framework Core, SQL, servicios internos o aplicaciones empresariales y quieren dar el salto a arquitecturas distribuidas. Aprenderán a diseñar microservicios con criterio, separar responsabilidades, comunicar servicios, gestionar datos distribuidos y evitar errores típicos de sistemas demasiado fragmentados.
Desarrolladores full stack con foco backend
Los perfiles full stack que participan en APIs, frontends, integraciones y despliegues podrán entender cómo organizar servicios, contratos, autenticación, composición de datos y comunicación entre equipos. La formación les ayuda a construir backends desacoplados sin perder coherencia con las necesidades reales de producto y experiencia de usuario.
Tech leads y desarrolladores senior
Los perfiles con responsabilidad técnica podrán usar el curso para definir estándares internos de microservicios, revisar diseños, guiar migraciones, controlar deuda técnica, mejorar calidad de APIs y establecer patrones comunes. El valor está en tomar mejores decisiones de arquitectura, no en aplicar microservicios por moda.
Equipos que mantienen monolitos .NET
Los equipos que trabajan con monolitos grandes, aplicaciones legacy, Web APIs acopladas o soluciones difíciles de desplegar podrán aprender estrategias de modernización gradual. El curso trabaja monolito modular, Strangler Fig, extracción de servicios, pruebas de caracterización y convivencia entre sistemas nuevos y existentes.
Equipos DevOps y plataforma .NET
Los perfiles DevOps podrán profundizar en contenedores, Kubernetes, Aspire, CI/CD, observabilidad, configuración, secretos, despliegues, health checks y operación de servicios. La formación conecta desarrollo de microservicios con prácticas reales de entrega y mantenimiento en producción.
Equipos de arquitectura, calidad y seguridad
Los perfiles de arquitectura, QA y AppSec podrán utilizar el curso para revisar boundaries, contratos, testing, resiliencia, autorización, trazabilidad, seguridad de servicios y calidad operativa. Esto permite que los microservicios se diseñen con control desde el inicio y no como una colección de APIs inconexas.
Proveedor con 16 años de experiencia en formación empresarial
Sobre
En Imagina Formación llevamos más de 16 años ayudando a profesionales y empresas a mejorar sus habilidades con formación práctica y totalmente adaptada a sus necesidades. Durante este tiempo, hemos formado a más de 480.000 personas y colaborado con más de 3.500 empresas, convirtiéndonos en un referente en el sector.
16
Años de liderazgo
+480.000
Alumnos formados en Imagina
¿Tienes dudas?
Resolvemos todas tus dudas sobre nuestra formación en Microservicios en .Net
Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.
Explica los fundamentos, pero está pensado para desarrolladores .NET con experiencia backend. No es un curso básico de C#; el foco está en arquitectura, implementación, testing, despliegue y operación de microservicios reales.
Sí. El curso está actualizado a .NET 10 como referencia actual LTS para el ecosistema .NET. Microsoft indica que .NET 10 es una versión de soporte a largo plazo con tres años de soporte.
Sí. ASP.NET Core es la base del curso para construir APIs, endpoints, validación, seguridad, health checks, OpenAPI, observabilidad y servicios backend.
Sí. El curso incluye gRPC para comunicación de alto rendimiento entre servicios. Microsoft documenta gRPC en .NET como un framework RPC de alto rendimiento e independiente del lenguaje.
Sí. Aspire se usa para orquestación local, desarrollo distribuido y observabilidad durante el desarrollo. Microsoft lo define como una capa de orquestación y observabilidad para aplicaciones distribuidas.
Sí. Se incluye Dapr como opción para service invocation, pub/sub, estado, secretos y otros building blocks. Dapr expone building blocks mediante APIs HTTP o gRPC y usa un runtime sidecar por servicio.
Sí. El curso trabaja API Gateway, BFF y YARP. Microsoft describe YARP como una librería de reverse proxy para .NET altamente personalizable y orientada a escenarios flexibles.
Sí. Hay un bloque específico sobre despliegue y operación de microservicios .NET en Kubernetes, incluyendo probes, recursos, escalado, configuración, secretos, logs, métricas y troubleshooting.
Sí. Se trabajan pruebas unitarias, integración, contrato, componente, resiliencia y end-to-end controladas, además de Testcontainers, brokers de prueba, mocks HTTP y validación en CI/CD.
Sí. El curso incluye modernización desde monolitos .NET, estrategia Strangler Fig, monolito modular, anti-corruption layers, pruebas de caracterización, extracción progresiva y migraciones de datos.
No. Es un curso corporativo práctico para equipos de desarrollo .NET. Puede ayudar a reforzar conocimientos útiles para arquitectura cloud o DevOps, pero no sustituye una preparación oficial de certificación.
Sí. Al tratarse de una formación corporativa en desarrollo .NET, arquitectura, DevOps, cloud, seguridad, testing y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.
Explica los fundamentos, pero está pensado para desarrolladores .NET con experiencia backend. No es un curso básico de C#; el foco está en arquitectura, implementación, testing, despliegue y operación de microservicios reales.
Sí. El curso está actualizado a .NET 10 como referencia actual LTS para el ecosistema .NET. Microsoft indica que .NET 10 es una versión de soporte a largo plazo con tres años de soporte.
Sí. ASP.NET Core es la base del curso para construir APIs, endpoints, validación, seguridad, health checks, OpenAPI, observabilidad y servicios backend.
Sí. El curso incluye gRPC para comunicación de alto rendimiento entre servicios. Microsoft documenta gRPC en .NET como un framework RPC de alto rendimiento e independiente del lenguaje.
Sí. Aspire se usa para orquestación local, desarrollo distribuido y observabilidad durante el desarrollo. Microsoft lo define como una capa de orquestación y observabilidad para aplicaciones distribuidas.
Sí. Se incluye Dapr como opción para service invocation, pub/sub, estado, secretos y otros building blocks. Dapr expone building blocks mediante APIs HTTP o gRPC y usa un runtime sidecar por servicio.
Sí. El curso trabaja API Gateway, BFF y YARP. Microsoft describe YARP como una librería de reverse proxy para .NET altamente personalizable y orientada a escenarios flexibles.
Sí. Hay un bloque específico sobre despliegue y operación de microservicios .NET en Kubernetes, incluyendo probes, recursos, escalado, configuración, secretos, logs, métricas y troubleshooting.
Sí. Se trabajan pruebas unitarias, integración, contrato, componente, resiliencia y end-to-end controladas, además de Testcontainers, brokers de prueba, mocks HTTP y validación en CI/CD.
Sí. El curso incluye modernización desde monolitos .NET, estrategia Strangler Fig, monolito modular, anti-corruption layers, pruebas de caracterización, extracción progresiva y migraciones de datos.
No. Es un curso corporativo práctico para equipos de desarrollo .NET. Puede ayudar a reforzar conocimientos útiles para arquitectura cloud o DevOps, pero no sustituye una preparación oficial de certificación.
Sí. Al tratarse de una formación corporativa en desarrollo .NET, arquitectura, DevOps, cloud, seguridad, testing y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.
Analizar qué problema resuelve una arquitectura de microservicios y qué problemas nuevos introduce cuando se aplica sin madurez técnica suficiente.
Diferenciar microservicios, monolito modular, SOA, APIs independientes, servicios internos y arquitectura distribuida para no mezclar conceptos.
Revisar escenarios donde microservicios aportan valor: escalado por dominio, ownership de equipos, despliegue independiente y evolución diferenciada.
Identificar casos donde un monolito modular sigue siendo mejor opción por simplicidad, coste operativo, tamaño del equipo o baja complejidad de dominio.
Entender que dividir código no equivale a desacoplar negocio, datos, despliegues ni responsabilidades de equipo.
Relacionar microservicios con .NET 10, ASP.NET Core, contenedores, APIs, workers, mensajería, observabilidad y CI/CD.
Revisar la guía de arquitectura de microservicios de Microsoft como base conceptual para aplicaciones .NET containerizadas.
Identificar anti-patrones frecuentes: nano-servicios, base de datos compartida, acoplamiento por DTOs, llamadas síncronas en cascada y despliegues coordinados.
Crear una matriz inicial para decidir si una capacidad debe ser módulo interno, librería compartida, API, microservicio o proceso asíncrono.
Definir criterios de éxito para una arquitectura distribuida: autonomía, resiliencia, observabilidad, seguridad, testabilidad y valor de negocio.
Analizar qué problema resuelve una arquitectura de microservicios y qué problemas nuevos introduce cuando se aplica sin madurez técnica suficiente.
Diferenciar microservicios, monolito modular, SOA, APIs independientes, servicios internos y arquitectura distribuida para no mezclar conceptos.
Revisar escenarios donde microservicios aportan valor: escalado por dominio, ownership de equipos, despliegue independiente y evolución diferenciada.
Identificar casos donde un monolito modular sigue siendo mejor opción por simplicidad, coste operativo, tamaño del equipo o baja complejidad de dominio.
Entender que dividir código no equivale a desacoplar negocio, datos, despliegues ni responsabilidades de equipo.
Relacionar microservicios con .NET 10, ASP.NET Core, contenedores, APIs, workers, mensajería, observabilidad y CI/CD.
Revisar la guía de arquitectura de microservicios de Microsoft como base conceptual para aplicaciones .NET containerizadas.
Identificar anti-patrones frecuentes: nano-servicios, base de datos compartida, acoplamiento por DTOs, llamadas síncronas en cascada y despliegues coordinados.
Crear una matriz inicial para decidir si una capacidad debe ser módulo interno, librería compartida, API, microservicio o proceso asíncrono.
Definir criterios de éxito para una arquitectura distribuida: autonomía, resiliencia, observabilidad, seguridad, testabilidad y valor de negocio.
Tema 1: Fundamentos reales de microservicios en .NET
Analizar qué problema resuelve una arquitectura de microservicios y qué problemas nuevos introduce cuando se aplica sin madurez técnica suficiente.
Diferenciar microservicios, monolito modular, SOA, APIs independientes, servicios internos y arquitectura distribuida para no mezclar conceptos.
Revisar escenarios donde microservicios aportan valor: escalado por dominio, ownership de equipos, despliegue independiente y evolución diferenciada.
Identificar casos donde un monolito modular sigue siendo mejor opción por simplicidad, coste operativo, tamaño del equipo o baja complejidad de dominio.
Entender que dividir código no equivale a desacoplar negocio, datos, despliegues ni responsabilidades de equipo.
Relacionar microservicios con .NET 10, ASP.NET Core, contenedores, APIs, workers, mensajería, observabilidad y CI/CD.
Revisar la guía de arquitectura de microservicios de Microsoft como base conceptual para aplicaciones .NET containerizadas.
Identificar anti-patrones frecuentes: nano-servicios, base de datos compartida, acoplamiento por DTOs, llamadas síncronas en cascada y despliegues coordinados.
Crear una matriz inicial para decidir si una capacidad debe ser módulo interno, librería compartida, API, microservicio o proceso asíncrono.
Definir criterios de éxito para una arquitectura distribuida: autonomía, resiliencia, observabilidad, seguridad, testabilidad y valor de negocio.
Tema 2: Diseño de dominios, bounded contexts y ownership
Aplicar pensamiento DDD para descubrir dominios, subdominios, bounded contexts, reglas de negocio y responsabilidades naturales.
Separar capacidades de negocio en servicios que tengan sentido funcional, no solo en entidades técnicas como “clientes”, “pedidos” o “facturas”.
Identificar límites incorrectos cuando varios servicios necesitan cambiar juntos, compartir datos internos o coordinar despliegues constantemente.
Diseñar mapas de contexto con relaciones upstream, downstream, customer-supplier, conformist, shared kernel y anti-corruption layer.
Definir ownership de servicio: equipo responsable, repositorio, base de datos, SLO, backlog, documentación, incidentes y decisiones de evolución.
Evitar que los microservicios repliquen la estructura organizativa de forma ciega cuando esa organización ya genera silos o fricción.
Revisar cómo el lenguaje ubicuo ayuda a que contratos, eventos, endpoints y nombres de servicios sean comprensibles para negocio y desarrollo.
Separar dominios core, supporting y generic para decidir dónde invertir más diseño, calidad y autonomía.
Preparar workshops de modelado con Event Storming, mapas de capacidades y análisis de flujos de negocio.
Documentar boundaries mediante ADRs, diagramas C4, ejemplos de contratos, reglas de datos y decisiones de ownership.
Tema 3: Arquitectura base de una solución de microservicios .NET
Diseñar una solución inicial con varios servicios ASP.NET Core, workers, librerías compartidas controladas, contratos y pruebas independientes.
Organizar repositorios según estrategia: monorepo, multirepo o repositorios híbridos, evaluando ownership, CI/CD, visibilidad y complejidad.
Separar proyectos por API, aplicación, dominio, infraestructura, contratos, tests y adaptadores externos cuando el servicio lo justifique.
Definir convenciones de naming para servicios, namespaces, endpoints, eventos, colas, bases de datos, imágenes y despliegues.
Crear servicios con plantillas corporativas que incluyan logging, health checks, OpenAPI, autenticación, configuración y testing base.
Evitar librerías compartidas que introducen acoplamiento oculto entre servicios y bloquean despliegues independientes.
Diseñar librerías transversales pequeñas para concerns realmente comunes: observabilidad, errores, seguridad, configuración o contracts.
Preparar una estructura de solución que permita crecimiento sin convertir cada servicio en una copia desordenada del anterior.
Definir documentación mínima por servicio: propósito, owner, contratos, dependencias, datos, runbooks, SLOs y despliegue.
Crear un estándar técnico de microservicio .NET que sirva como referencia para nuevos equipos y revisiones de arquitectura.
Tema 4: ASP.NET Core APIs para microservicios
Construir APIs con ASP.NET Core usando controllers o minimal APIs según complejidad, estilo del equipo y necesidades de mantenibilidad.
Diseñar endpoints con contratos claros, códigos HTTP correctos, validación, errores coherentes y semántica estable.
Usar OpenAPI para documentar contratos, facilitar consumo, generar clientes y apoyar contract testing.
Separar DTOs públicos, modelos de dominio, entidades de persistencia y eventos para evitar fugas de implementación.
Implementar validación de entrada con reglas explícitas, mensajes seguros y respuesta consistente ante errores de negocio.
Diseñar APIs idempotentes cuando la operación puede repetirse por reintentos, fallos de red o integración con otros sistemas.
Aplicar versionado de APIs cuando existen consumidores externos, frontends desacoplados o contratos con ciclo de vida propio.
Preparar endpoints administrativos internos para health, metrics, readiness, diagnóstico y mantenimiento controlado.
Evitar APIs demasiado genéricas que exponen operaciones internas en lugar de capacidades de negocio claras.
Crear una guía de diseño de APIs .NET para microservicios con ejemplos correctos, anti-patrones y criterios de revisión.
Tema 5: gRPC y comunicación de alto rendimiento entre servicios
Comprender gRPC como framework RPC de alto rendimiento e independiente del lenguaje, soportado en .NET para comunicación entre servicios.
Diseñar contratos `.proto` claros, versionables y estables, evitando filtrar modelos internos del dominio.
Crear servicios gRPC con ASP.NET Core y clientes .NET preparados para entornos distribuidos.
Comparar REST y gRPC según latencia, streaming, compatibilidad, tooling, consumo externo, depuración y necesidades de interoperabilidad.
Implementar unary calls, server streaming, client streaming y bidirectional streaming cuando el caso de negocio lo justifique.
Gestionar errores gRPC con status codes, metadata, detalles seguros y traducción adecuada hacia consumidores.
Configurar autenticación, autorización, TLS, deadlines, cancellation tokens, retries y circuit breakers en clientes gRPC.
Incorporar gRPC client factory para gestionar clientes, configuración, resiliencia y dependencias de forma mantenible.
Probar contratos gRPC con escenarios de compatibilidad, cambios de schema, mensajes obligatorios y consumidores simulados.
Definir criterios corporativos para decidir cuándo un microservicio debe exponer REST, gRPC, eventos o una combinación controlada.
Tema 6: Comunicación síncrona entre servicios y sus riesgos
Diseñar llamadas HTTP entre servicios con `HttpClientFactory`, clientes tipados, timeouts explícitos y manejo de errores.
Evitar cadenas de llamadas síncronas donde un endpoint depende de varios servicios y multiplica latencia, errores y acoplamiento.
Aplicar patrones de resiliencia como retries limitados, circuit breakers, bulkheads, fallback y políticas diferenciadas por dependencia.
Propagar correlation IDs y trace context para seguir una petición entre varios servicios durante diagnóstico e incidentes.
Gestionar errores parciales cuando un servicio dependiente no responde, responde tarde o devuelve información incompleta.
Diseñar respuestas degradadas cuando el usuario puede continuar con funcionalidad limitada sin caída completa del sistema.
Evitar compartir modelos internos entre cliente y servidor cuando eso convierte cualquier cambio en una ruptura distribuida.
Crear clientes de servicio encapsulados, testables y con configuración centralizada.
Medir latencia, tasa de error, saturación, timeouts y retries por dependencia para detectar degradaciones.
Documentar dependencias síncronas con owner, SLO esperado, contrato, timeout, fallback y estrategia de recuperación.
Tema 7: Mensajería, eventos y comunicación asíncrona
Diseñar comunicación asíncrona para desacoplar servicios, absorber picos, mejorar resiliencia y evitar bloqueos innecesarios.
Diferenciar comandos, eventos de dominio, eventos de integración, mensajes técnicos, notificaciones y tareas diferidas.
Comparar RabbitMQ, Apache Kafka, Azure Service Bus, AWS SQS/SNS y otros brokers según caso, escala, orden, retención y operación.
Crear publicadores y consumidores en .NET con manejo de errores, reintentos, dead letter queues y observabilidad.
Diseñar eventos con semántica clara, versión, idempotencia, correlation ID, causation ID y datos suficientes para consumidores.
Evitar eventos gigantes, ambiguos o demasiado acoplados al modelo interno de un servicio.
Gestionar mensajes duplicados, desordenados, tardíos o incompletos sin romper reglas de negocio.
Definir ownership de topics, exchanges, colas, subscriptions, schemas y consumidores.
Medir lag, throughput, errores, reintentos, DLQ, tiempo de procesamiento y frescura de datos.
Crear una estrategia de mensajería empresarial con estándares de naming, versionado, seguridad, trazabilidad y soporte.
Tema 8: Dapr como capa de building blocks para microservicios
Evaluar Dapr como runtime distribuido que expone building blocks mediante APIs HTTP o gRPC para resolver retos comunes de microservicios.
Comprender el modelo sidecar de Dapr, donde cada servicio se comunica con su runtime local para usar componentes de infraestructura.
Aplicar service invocation para llamadas entre servicios sin acoplar el código a direcciones físicas concretas.
Usar pub/sub de Dapr para publicar y consumir eventos con abstracción sobre brokers como Redis, RabbitMQ, Kafka o servicios cloud.
Evaluar state management, bindings, secrets, actors, workflows y configuration según necesidades reales del sistema.
Comparar Dapr frente a librerías nativas, SDKs cloud y patrones implementados directamente en .NET.
Diseñar componentes Dapr por entorno, separando desarrollo local, integración, staging y producción.
Gestionar resiliencia, observabilidad, seguridad y configuración dentro del modelo Dapr.
Evitar usar Dapr como solución mágica cuando el equipo no entiende los patrones distribuidos que encapsula.
Crear un laboratorio con varios microservicios .NET comunicados mediante Dapr, pub/sub y estado externo.
Tema 9: .NET Aspire para desarrollo local y observabilidad distribuida
Utilizar Aspire como herramienta de orquestación local y observabilidad para modelar, ejecutar, depurar y conectar aplicaciones distribuidas.
Crear un AppHost que describa servicios .NET, bases de datos, caches, colas, dependencias y relaciones entre recursos.
Ejecutar varios microservicios en local con configuración coherente, variables, endpoints, dependencias y trazabilidad.
Usar el dashboard de Aspire para revisar logs, trazas, métricas, dependencias y estado de recursos durante desarrollo.
Comprender que Aspire no sustituye al framework de aplicación, al cloud provider ni al runtime de producción, según la propia documentación.
Integrar servicios ASP.NET Core, workers, PostgreSQL, Redis, RabbitMQ, SQL Server u otros recursos en un entorno local reproducible.
Diseñar proyectos para que el onboarding de nuevos desarrolladores sea más rápido y con menos configuración manual.
Comparar Aspire con docker compose, Kubernetes local y scripts propios de desarrollo.
Evitar dependencias ocultas entre servicios gracias a la visibilidad de la topología local.
Crear una plantilla de solución distribuida con Aspire, observabilidad base y buenas prácticas de configuración.
Tema 10: API Gateway, BFF y YARP en .NET
Diseñar un API Gateway como punto de entrada para routing, autenticación, agregación, rate limiting, observabilidad y control de tráfico.
Evaluar cuándo usar API Gateway, Backend for Frontend, reverse proxy, service mesh o acceso directo a servicios.
Usar YARP como reverse proxy altamente personalizable para .NET, diseñado para crear soluciones de proxy flexibles y escalables.
Configurar rutas, clusters, destinos, transforms, health checks y políticas de proxy con YARP.
Diseñar BFFs para frontends web, móviles o backoffice, evitando que los clientes conozcan la topología interna de microservicios.
Gestionar autenticación, autorización, tokens, cookies, CORS, cabeceras y propagación de identidad en el gateway.
Evitar gateways que acumulan lógica de negocio y se convierten en un nuevo monolito central.
Añadir rate limiting, circuit breaking, caching, logging y trazabilidad en el borde de la arquitectura.
Crear pruebas para rutas, autorización, transforms, errores y degradación del gateway.
Definir criterios para decidir qué debe vivir en gateway, BFF, servicio de dominio o frontend.
Tema 11: Persistencia por servicio y bases de datos distribuidas
Aplicar el principio de base de datos por servicio para mantener autonomía, ownership y evolución independiente.
Evitar compartir tablas entre microservicios, aunque parezca más cómodo para reporting, joins o integraciones rápidas.
Diseñar persistencia según necesidades de cada servicio: relacional, documental, clave-valor, búsqueda, cache o event store.
Gestionar cambios de schema con migraciones versionadas, despliegues compatibles y rollback planificado.
Separar modelo de dominio, modelo de persistencia, DTOs, eventos y modelos de lectura.
Crear estrategias de sincronización entre servicios mediante eventos, proyecciones, materialized views o APIs controladas.
Gestionar datos duplicados de forma intencionada, documentada y reconciliable, no como copia accidental.
Diseñar ownership de datos con criterios de escritura, lectura, historificación, retención y privacidad.
Medir salud de bases de datos por latencia, locks, errores, conexiones, crecimiento, saturación y consultas críticas.
Documentar decisiones de persistencia mediante ADRs, incluyendo trade-offs de consistencia, rendimiento, coste y operación.
Tema 12: Consistencia eventual, Outbox, Inbox y Saga
Comprender por qué las transacciones distribuidas suelen ser problemáticas en microservicios y cuándo deben evitarse.
Diseñar consistencia eventual explicando claramente qué ve el usuario, qué estados intermedios existen y cómo se recuperan errores.
Implementar patrón Outbox para publicar eventos de forma fiable después de cambios de base de datos locales.
Aplicar patrón Inbox para deduplicar mensajes recibidos y proteger consumidores frente a reentregas.
Diseñar Sagas coreografiadas u orquestadas para procesos largos como pedidos, pagos, reservas, aprovisionamiento o facturación.
Crear compensaciones de negocio cuando un paso posterior falla y no existe rollback técnico simple.
Gestionar estados intermedios, timeouts, reintentos, cancelaciones y reconciliación manual.
Evitar sagas demasiado opacas donde nadie entiende quién coordina, qué estados existen o cómo se recuperan fallos.
Probar procesos distribuidos con escenarios de fallo en cada paso, duplicados, mensajes tardíos y dependencias caídas.
Documentar flujos de consistencia con diagramas de secuencia, eventos, estados, compensaciones y responsabilidades.
Tema 13: Idempotencia, duplicados y diseño de operaciones seguras
Diseñar endpoints y consumidores capaces de procesar peticiones repetidas sin crear efectos secundarios duplicados.
Usar idempotency keys para operaciones críticas como pagos, pedidos, reservas, altas, importaciones o cambios de estado.
Gestionar duplicados de mensajes mediante claves, tablas de procesamiento, ventanas temporales y control de estado.
Diferenciar entre idempotencia técnica y reglas de negocio que determinan si una operación puede repetirse.
Controlar concurrencia con optimistic concurrency, locks razonables, versiones de agregado o restricciones de base de datos.
Crear respuestas consistentes cuando una operación ya se ejecutó pero el cliente no recibió confirmación.
Diseñar reintentos seguros para APIs, workers y consumidores de eventos.
Preparar métricas de duplicados, reintentos, conflictos, compensaciones y operaciones parcialmente completadas.
Probar idempotencia con fallos simulados de red, timeouts, reentregas y ejecución concurrente.
Documentar operaciones críticas con sus invariantes, riesgos, estrategias de recuperación y criterios de auditoría.
Tema 14: Seguridad entre microservicios
Diseñar autenticación y autorización entre servicios usando OAuth2, OpenID Connect, JWT, mTLS o identidades gestionadas según entorno.
Separar autenticación de usuario final, identidad de servicio, permisos internos y autorización por recurso.
Propagar contexto de usuario solo cuando sea necesario, evitando exponer información sensible en cabeceras o eventos.
Aplicar mínimos privilegios en APIs internas, colas, bases de datos, secretos, observabilidad y herramientas de despliegue.
Gestionar secretos con vaults, variables protegidas, rotación, scopes y prohibición de credenciales en repositorios.
Diseñar políticas de autorización por servicio, operación, tenant, entorno y sensibilidad del dato.
Revisar riesgos de seguridad típicos: SSRF, exposición de endpoints internos, tokens largos, logs sensibles y permisos amplios.
Proteger comunicación mediante TLS, certificados, gateways, service mesh o controles equivalentes cuando la arquitectura lo requiera.
Crear auditoría de acciones críticas entre servicios, especialmente en cambios de permisos, pagos, datos personales o administración.
Integrar seguridad en CI/CD, code review, threat modeling y pruebas de integración.
Tema 15: Configuración, secretos y feature flags
Gestionar configuración por entorno sin duplicar valores manualmente ni mezclar settings de desarrollo, staging y producción.
Separar configuración técnica, configuración de negocio, secretos, flags, límites de resiliencia y parámetros operativos.
Usar `IOptions`, configuración tipada, validación al arranque y fallos tempranos cuando falta configuración crítica.
Proteger secretos mediante Azure Key Vault, AWS Secrets Manager, HashiCorp Vault, Kubernetes Secrets u opciones corporativas.
Diseñar feature flags para separar despliegue de activación funcional y reducir riesgo en releases.
Controlar flags por entorno, usuario, tenant, porcentaje, grupo o criterio de negocio.
Evitar flags permanentes que se convierten en deuda y multiplican ramas lógicas dentro del código.
Registrar cambios de configuración sensibles con auditoría, owner, motivo y fecha.
Probar configuración en CI/CD para detectar errores antes de desplegar.
Crear una estrategia de configuración distribuida con seguridad, trazabilidad, rollback y documentación.
Tema 16: Observabilidad con OpenTelemetry, logs, métricas y trazas
Instrumentar microservicios .NET con logs estructurados, métricas, trazas distribuidas y correlation IDs.
Usar OpenTelemetry para recoger señales estándar y exportarlas a herramientas como Prometheus, Grafana, Jaeger, Tempo, Azure Monitor o equivalentes.
Comprender que .NET integra APIs de logging, métricas y Activity que sirven como base para OpenTelemetry.
Diseñar convenciones de nombres para spans, métricas, atributos, eventos y dimensiones de negocio.
Propagar contexto de traza entre HTTP, gRPC, colas, eventos, workers y dependencias externas.
Evitar cardinalidad excesiva en métricas por IDs únicos, usuarios, payloads o valores demasiado variables.
Crear dashboards por servicio, journey, dependencia, cola, base de datos y SLO.
Detectar problemas de latencia, errores, saturación, timeouts, retries, colas acumuladas y dependencias degradadas.
Proteger datos sensibles en logs y trazas, evitando payloads completos, tokens, cookies, datos personales o secretos.
Definir una plantilla de observabilidad obligatoria para cada microservicio antes de pasar a producción.
Tema 17: Health checks, readiness, liveness y diagnóstico operativo
Implementar health checks en ASP.NET Core para reportar estado de aplicación, base de datos, colas, cache y dependencias.
Diferenciar liveness, readiness y startup checks para evitar reinicios innecesarios o tráfico hacia servicios no preparados.
Crear checks rápidos, seguros y útiles, sin sobrecargar dependencias críticas con pruebas demasiado costosas.
Exponer endpoints internos de salud con información suficiente para orquestadores y limitada para públicos externos.
Integrar health checks con Kubernetes, balanceadores, gateways, monitorización y pipelines postdeploy.
Diseñar estados degradados cuando una dependencia no crítica falla pero el servicio puede operar parcialmente.
Añadir información de build, versión, commit, entorno y configuración no sensible para facilitar soporte.
Crear runbooks asociados a fallos de health check para que el equipo sepa qué revisar y cómo mitigar.
Evitar health checks que devuelven OK aunque el servicio no pueda cumplir su función principal.
Definir criterios de producción: ningún servicio crítico se despliega sin health checks, métricas, logs, trazas y owner.
Tema 18: Resiliencia, tolerancia a fallos y degradación controlada
Diseñar servicios preparados para fallos de red, latencia alta, dependencias caídas, timeouts, saturación y errores parciales.
Aplicar retries con backoff y jitter para evitar tormentas de reintentos ante dependencias degradadas.
Usar circuit breakers para cortar llamadas temporalmente cuando una dependencia falla de forma sostenida.
Aplicar bulkheads para aislar recursos y evitar que una operación lenta bloquee todo el servicio.
Diseñar fallbacks que permitan devolver datos parciales, cacheados o mensajes claros sin romper la experiencia completa.
Establecer timeouts explícitos y coherentes entre cliente, gateway, servicio, base de datos y mensajería.
Medir retries, timeouts, circuit breaker state, fallbacks y degradaciones como señales operativas.
Evitar resiliencia mal configurada que oculta fallos reales o aumenta presión sobre sistemas ya saturados.
Probar resiliencia con fallos simulados de dependencias, colas, bases de datos y servicios externos.
Documentar políticas de resiliencia por dependencia con owner, parámetros, motivo y límites.
Tema 19: Testing de microservicios .NET
Diseñar una estrategia de pruebas que combine unitarias, integración, contrato, componente, end-to-end y pruebas de resiliencia.
Crear tests unitarios para dominio, servicios de aplicación, validadores, mappers, políticas y reglas de negocio.
Usar tests de integración con bases reales en contenedores, APIs de prueba y configuración aislada.
Aplicar contract testing para validar compatibilidad entre consumidores y proveedores sin desplegar todo el sistema.
Crear pruebas de componente que levanten un servicio con dependencias simuladas o contenedores controlados.
Evitar end-to-end excesivos que se vuelven lentos, frágiles y difíciles de diagnosticar.
Forma a tu equipo sin coste para tu empresa. Este curso de Microservicios en .Net es hasta 100% bonificable a través de FUNDAE.
Potencia las competencias clave de tus profesionales.
Accede a una formación práctica, actualizada y orientada a resultados.
Prepara a tu equipo para los retos del entorno laboral actual.
Nos ocupamos de la gestión con FUNDAE si tu empresa lo necesita.
A medida
Formación en Microservicios en .Net a medida
Descubre el mejor curso de Microservicios en .Net para empresas con nuestra Aula Virtual Personalizada:
Sesiones en vivo por videoconferencia.
Temario totalmente personalizado.
Fechas y horarios adaptados a tu empresa.
Acceso a grabaciones.
Aprende practicando
Totalmente Práctico y Aplicable
Formación diseñada para que apliques cada concepto en situaciones reales de tu trabajo, con enfoque práctico y útil desde el primer momento.
Aprendizaje 100% práctico, enfocado en lo que realmente necesitas.
Casos reales y ejercicios adaptados a tu entorno profesional.
Aplica cada conocimiento directamente en tus tareas diarias.
Mejora tu rendimiento y el de tu equipo desde el primer día.
¿Por qué un curso en Microservicios en .Net?
Alinea arquitectura, DevOps y negocio
Diseñamos formación A Medida en Microservicios con C# y .Net para equipos, arquitectura limpia y despliegue, bonificable FUNDAE. Solicita propuesta a medida.
Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.
Correccion magica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
Analizar qué problema resuelve una arquitectura de microservicios y qué problemas nuevos introduce cuando se aplica sin madurez técnica suficiente.
Diferenciar microservicios, monolito modular, SOA, APIs independientes, servicios internos y arquitectura distribuida para no mezclar conceptos.
Revisar escenarios donde microservicios aportan valor: escalado por dominio, ownership de equipos, despliegue independiente y evolución diferenciada.
Identificar casos donde un monolito modular sigue siendo mejor opción por simplicidad, coste operativo, tamaño del equipo o baja complejidad de dominio.
Entender que dividir código no equivale a desacoplar negocio, datos, despliegues ni responsabilidades de equipo.
Relacionar microservicios con .NET 10, ASP.NET Core, contenedores, APIs, workers, mensajería, observabilidad y CI/CD.
Revisar la guía de arquitectura de microservicios de Microsoft como base conceptual para aplicaciones .NET containerizadas.
Identificar anti-patrones frecuentes: nano-servicios, base de datos compartida, acoplamiento por DTOs, llamadas síncronas en cascada y despliegues coordinados.
Crear una matriz inicial para decidir si una capacidad debe ser módulo interno, librería compartida, API, microservicio o proceso asíncrono.
Definir criterios de éxito para una arquitectura distribuida: autonomía, resiliencia, observabilidad, seguridad, testabilidad y valor de negocio.
Analizar qué problema resuelve una arquitectura de microservicios y qué problemas nuevos introduce cuando se aplica sin madurez técnica suficiente.
Diferenciar microservicios, monolito modular, SOA, APIs independientes, servicios internos y arquitectura distribuida para no mezclar conceptos.
Revisar escenarios donde microservicios aportan valor: escalado por dominio, ownership de equipos, despliegue independiente y evolución diferenciada.
Identificar casos donde un monolito modular sigue siendo mejor opción por simplicidad, coste operativo, tamaño del equipo o baja complejidad de dominio.
Entender que dividir código no equivale a desacoplar negocio, datos, despliegues ni responsabilidades de equipo.
Relacionar microservicios con .NET 10, ASP.NET Core, contenedores, APIs, workers, mensajería, observabilidad y CI/CD.
Revisar la guía de arquitectura de microservicios de Microsoft como base conceptual para aplicaciones .NET containerizadas.
Identificar anti-patrones frecuentes: nano-servicios, base de datos compartida, acoplamiento por DTOs, llamadas síncronas en cascada y despliegues coordinados.
Crear una matriz inicial para decidir si una capacidad debe ser módulo interno, librería compartida, API, microservicio o proceso asíncrono.
Definir criterios de éxito para una arquitectura distribuida: autonomía, resiliencia, observabilidad, seguridad, testabilidad y valor de negocio.
Tema 1: Fundamentos reales de microservicios en .NET
Analizar qué problema resuelve una arquitectura de microservicios y qué problemas nuevos introduce cuando se aplica sin madurez técnica suficiente.
Diferenciar microservicios, monolito modular, SOA, APIs independientes, servicios internos y arquitectura distribuida para no mezclar conceptos.
Revisar escenarios donde microservicios aportan valor: escalado por dominio, ownership de equipos, despliegue independiente y evolución diferenciada.
Identificar casos donde un monolito modular sigue siendo mejor opción por simplicidad, coste operativo, tamaño del equipo o baja complejidad de dominio.
Entender que dividir código no equivale a desacoplar negocio, datos, despliegues ni responsabilidades de equipo.
Relacionar microservicios con .NET 10, ASP.NET Core, contenedores, APIs, workers, mensajería, observabilidad y CI/CD.
Revisar la guía de arquitectura de microservicios de Microsoft como base conceptual para aplicaciones .NET containerizadas.
Identificar anti-patrones frecuentes: nano-servicios, base de datos compartida, acoplamiento por DTOs, llamadas síncronas en cascada y despliegues coordinados.
Crear una matriz inicial para decidir si una capacidad debe ser módulo interno, librería compartida, API, microservicio o proceso asíncrono.
Definir criterios de éxito para una arquitectura distribuida: autonomía, resiliencia, observabilidad, seguridad, testabilidad y valor de negocio.
Tema 2: Diseño de dominios, bounded contexts y ownership
Aplicar pensamiento DDD para descubrir dominios, subdominios, bounded contexts, reglas de negocio y responsabilidades naturales.
Separar capacidades de negocio en servicios que tengan sentido funcional, no solo en entidades técnicas como “clientes”, “pedidos” o “facturas”.
Identificar límites incorrectos cuando varios servicios necesitan cambiar juntos, compartir datos internos o coordinar despliegues constantemente.
Diseñar mapas de contexto con relaciones upstream, downstream, customer-supplier, conformist, shared kernel y anti-corruption layer.
Definir ownership de servicio: equipo responsable, repositorio, base de datos, SLO, backlog, documentación, incidentes y decisiones de evolución.
Evitar que los microservicios repliquen la estructura organizativa de forma ciega cuando esa organización ya genera silos o fricción.
Revisar cómo el lenguaje ubicuo ayuda a que contratos, eventos, endpoints y nombres de servicios sean comprensibles para negocio y desarrollo.
Separar dominios core, supporting y generic para decidir dónde invertir más diseño, calidad y autonomía.
Preparar workshops de modelado con Event Storming, mapas de capacidades y análisis de flujos de negocio.
Documentar boundaries mediante ADRs, diagramas C4, ejemplos de contratos, reglas de datos y decisiones de ownership.
Tema 3: Arquitectura base de una solución de microservicios .NET
Diseñar una solución inicial con varios servicios ASP.NET Core, workers, librerías compartidas controladas, contratos y pruebas independientes.
Organizar repositorios según estrategia: monorepo, multirepo o repositorios híbridos, evaluando ownership, CI/CD, visibilidad y complejidad.
Separar proyectos por API, aplicación, dominio, infraestructura, contratos, tests y adaptadores externos cuando el servicio lo justifique.
Definir convenciones de naming para servicios, namespaces, endpoints, eventos, colas, bases de datos, imágenes y despliegues.
Crear servicios con plantillas corporativas que incluyan logging, health checks, OpenAPI, autenticación, configuración y testing base.
Evitar librerías compartidas que introducen acoplamiento oculto entre servicios y bloquean despliegues independientes.
Diseñar librerías transversales pequeñas para concerns realmente comunes: observabilidad, errores, seguridad, configuración o contracts.
Preparar una estructura de solución que permita crecimiento sin convertir cada servicio en una copia desordenada del anterior.
Definir documentación mínima por servicio: propósito, owner, contratos, dependencias, datos, runbooks, SLOs y despliegue.
Crear un estándar técnico de microservicio .NET que sirva como referencia para nuevos equipos y revisiones de arquitectura.
Tema 4: ASP.NET Core APIs para microservicios
Construir APIs con ASP.NET Core usando controllers o minimal APIs según complejidad, estilo del equipo y necesidades de mantenibilidad.
Diseñar endpoints con contratos claros, códigos HTTP correctos, validación, errores coherentes y semántica estable.
Usar OpenAPI para documentar contratos, facilitar consumo, generar clientes y apoyar contract testing.
Separar DTOs públicos, modelos de dominio, entidades de persistencia y eventos para evitar fugas de implementación.
Implementar validación de entrada con reglas explícitas, mensajes seguros y respuesta consistente ante errores de negocio.
Diseñar APIs idempotentes cuando la operación puede repetirse por reintentos, fallos de red o integración con otros sistemas.
Aplicar versionado de APIs cuando existen consumidores externos, frontends desacoplados o contratos con ciclo de vida propio.
Preparar endpoints administrativos internos para health, metrics, readiness, diagnóstico y mantenimiento controlado.
Evitar APIs demasiado genéricas que exponen operaciones internas en lugar de capacidades de negocio claras.
Crear una guía de diseño de APIs .NET para microservicios con ejemplos correctos, anti-patrones y criterios de revisión.
Tema 5: gRPC y comunicación de alto rendimiento entre servicios
Comprender gRPC como framework RPC de alto rendimiento e independiente del lenguaje, soportado en .NET para comunicación entre servicios.
Diseñar contratos `.proto` claros, versionables y estables, evitando filtrar modelos internos del dominio.
Crear servicios gRPC con ASP.NET Core y clientes .NET preparados para entornos distribuidos.
Comparar REST y gRPC según latencia, streaming, compatibilidad, tooling, consumo externo, depuración y necesidades de interoperabilidad.
Implementar unary calls, server streaming, client streaming y bidirectional streaming cuando el caso de negocio lo justifique.
Gestionar errores gRPC con status codes, metadata, detalles seguros y traducción adecuada hacia consumidores.
Configurar autenticación, autorización, TLS, deadlines, cancellation tokens, retries y circuit breakers en clientes gRPC.
Incorporar gRPC client factory para gestionar clientes, configuración, resiliencia y dependencias de forma mantenible.
Probar contratos gRPC con escenarios de compatibilidad, cambios de schema, mensajes obligatorios y consumidores simulados.
Definir criterios corporativos para decidir cuándo un microservicio debe exponer REST, gRPC, eventos o una combinación controlada.
Tema 6: Comunicación síncrona entre servicios y sus riesgos
Diseñar llamadas HTTP entre servicios con `HttpClientFactory`, clientes tipados, timeouts explícitos y manejo de errores.
Evitar cadenas de llamadas síncronas donde un endpoint depende de varios servicios y multiplica latencia, errores y acoplamiento.
Aplicar patrones de resiliencia como retries limitados, circuit breakers, bulkheads, fallback y políticas diferenciadas por dependencia.
Propagar correlation IDs y trace context para seguir una petición entre varios servicios durante diagnóstico e incidentes.
Gestionar errores parciales cuando un servicio dependiente no responde, responde tarde o devuelve información incompleta.
Diseñar respuestas degradadas cuando el usuario puede continuar con funcionalidad limitada sin caída completa del sistema.
Evitar compartir modelos internos entre cliente y servidor cuando eso convierte cualquier cambio en una ruptura distribuida.
Crear clientes de servicio encapsulados, testables y con configuración centralizada.
Medir latencia, tasa de error, saturación, timeouts y retries por dependencia para detectar degradaciones.
Documentar dependencias síncronas con owner, SLO esperado, contrato, timeout, fallback y estrategia de recuperación.
Tema 7: Mensajería, eventos y comunicación asíncrona
Diseñar comunicación asíncrona para desacoplar servicios, absorber picos, mejorar resiliencia y evitar bloqueos innecesarios.
Diferenciar comandos, eventos de dominio, eventos de integración, mensajes técnicos, notificaciones y tareas diferidas.
Comparar RabbitMQ, Apache Kafka, Azure Service Bus, AWS SQS/SNS y otros brokers según caso, escala, orden, retención y operación.
Crear publicadores y consumidores en .NET con manejo de errores, reintentos, dead letter queues y observabilidad.
Diseñar eventos con semántica clara, versión, idempotencia, correlation ID, causation ID y datos suficientes para consumidores.
Evitar eventos gigantes, ambiguos o demasiado acoplados al modelo interno de un servicio.
Gestionar mensajes duplicados, desordenados, tardíos o incompletos sin romper reglas de negocio.
Definir ownership de topics, exchanges, colas, subscriptions, schemas y consumidores.
Medir lag, throughput, errores, reintentos, DLQ, tiempo de procesamiento y frescura de datos.
Crear una estrategia de mensajería empresarial con estándares de naming, versionado, seguridad, trazabilidad y soporte.
Tema 8: Dapr como capa de building blocks para microservicios
Evaluar Dapr como runtime distribuido que expone building blocks mediante APIs HTTP o gRPC para resolver retos comunes de microservicios.
Comprender el modelo sidecar de Dapr, donde cada servicio se comunica con su runtime local para usar componentes de infraestructura.
Aplicar service invocation para llamadas entre servicios sin acoplar el código a direcciones físicas concretas.
Usar pub/sub de Dapr para publicar y consumir eventos con abstracción sobre brokers como Redis, RabbitMQ, Kafka o servicios cloud.
Evaluar state management, bindings, secrets, actors, workflows y configuration según necesidades reales del sistema.
Comparar Dapr frente a librerías nativas, SDKs cloud y patrones implementados directamente en .NET.
Diseñar componentes Dapr por entorno, separando desarrollo local, integración, staging y producción.
Gestionar resiliencia, observabilidad, seguridad y configuración dentro del modelo Dapr.
Evitar usar Dapr como solución mágica cuando el equipo no entiende los patrones distribuidos que encapsula.
Crear un laboratorio con varios microservicios .NET comunicados mediante Dapr, pub/sub y estado externo.
Tema 9: .NET Aspire para desarrollo local y observabilidad distribuida
Utilizar Aspire como herramienta de orquestación local y observabilidad para modelar, ejecutar, depurar y conectar aplicaciones distribuidas.
Crear un AppHost que describa servicios .NET, bases de datos, caches, colas, dependencias y relaciones entre recursos.
Ejecutar varios microservicios en local con configuración coherente, variables, endpoints, dependencias y trazabilidad.
Usar el dashboard de Aspire para revisar logs, trazas, métricas, dependencias y estado de recursos durante desarrollo.
Comprender que Aspire no sustituye al framework de aplicación, al cloud provider ni al runtime de producción, según la propia documentación.
Integrar servicios ASP.NET Core, workers, PostgreSQL, Redis, RabbitMQ, SQL Server u otros recursos en un entorno local reproducible.
Diseñar proyectos para que el onboarding de nuevos desarrolladores sea más rápido y con menos configuración manual.
Comparar Aspire con docker compose, Kubernetes local y scripts propios de desarrollo.
Evitar dependencias ocultas entre servicios gracias a la visibilidad de la topología local.
Crear una plantilla de solución distribuida con Aspire, observabilidad base y buenas prácticas de configuración.
Tema 10: API Gateway, BFF y YARP en .NET
Diseñar un API Gateway como punto de entrada para routing, autenticación, agregación, rate limiting, observabilidad y control de tráfico.
Evaluar cuándo usar API Gateway, Backend for Frontend, reverse proxy, service mesh o acceso directo a servicios.
Usar YARP como reverse proxy altamente personalizable para .NET, diseñado para crear soluciones de proxy flexibles y escalables.
Configurar rutas, clusters, destinos, transforms, health checks y políticas de proxy con YARP.
Diseñar BFFs para frontends web, móviles o backoffice, evitando que los clientes conozcan la topología interna de microservicios.
Gestionar autenticación, autorización, tokens, cookies, CORS, cabeceras y propagación de identidad en el gateway.
Evitar gateways que acumulan lógica de negocio y se convierten en un nuevo monolito central.
Añadir rate limiting, circuit breaking, caching, logging y trazabilidad en el borde de la arquitectura.
Crear pruebas para rutas, autorización, transforms, errores y degradación del gateway.
Definir criterios para decidir qué debe vivir en gateway, BFF, servicio de dominio o frontend.
Tema 11: Persistencia por servicio y bases de datos distribuidas
Aplicar el principio de base de datos por servicio para mantener autonomía, ownership y evolución independiente.
Evitar compartir tablas entre microservicios, aunque parezca más cómodo para reporting, joins o integraciones rápidas.
Diseñar persistencia según necesidades de cada servicio: relacional, documental, clave-valor, búsqueda, cache o event store.
Gestionar cambios de schema con migraciones versionadas, despliegues compatibles y rollback planificado.
Separar modelo de dominio, modelo de persistencia, DTOs, eventos y modelos de lectura.
Crear estrategias de sincronización entre servicios mediante eventos, proyecciones, materialized views o APIs controladas.
Gestionar datos duplicados de forma intencionada, documentada y reconciliable, no como copia accidental.
Diseñar ownership de datos con criterios de escritura, lectura, historificación, retención y privacidad.
Medir salud de bases de datos por latencia, locks, errores, conexiones, crecimiento, saturación y consultas críticas.
Documentar decisiones de persistencia mediante ADRs, incluyendo trade-offs de consistencia, rendimiento, coste y operación.
Tema 12: Consistencia eventual, Outbox, Inbox y Saga
Comprender por qué las transacciones distribuidas suelen ser problemáticas en microservicios y cuándo deben evitarse.
Diseñar consistencia eventual explicando claramente qué ve el usuario, qué estados intermedios existen y cómo se recuperan errores.
Implementar patrón Outbox para publicar eventos de forma fiable después de cambios de base de datos locales.
Aplicar patrón Inbox para deduplicar mensajes recibidos y proteger consumidores frente a reentregas.
Diseñar Sagas coreografiadas u orquestadas para procesos largos como pedidos, pagos, reservas, aprovisionamiento o facturación.
Crear compensaciones de negocio cuando un paso posterior falla y no existe rollback técnico simple.
Gestionar estados intermedios, timeouts, reintentos, cancelaciones y reconciliación manual.
Evitar sagas demasiado opacas donde nadie entiende quién coordina, qué estados existen o cómo se recuperan fallos.
Probar procesos distribuidos con escenarios de fallo en cada paso, duplicados, mensajes tardíos y dependencias caídas.
Documentar flujos de consistencia con diagramas de secuencia, eventos, estados, compensaciones y responsabilidades.
Tema 13: Idempotencia, duplicados y diseño de operaciones seguras
Diseñar endpoints y consumidores capaces de procesar peticiones repetidas sin crear efectos secundarios duplicados.
Usar idempotency keys para operaciones críticas como pagos, pedidos, reservas, altas, importaciones o cambios de estado.
Gestionar duplicados de mensajes mediante claves, tablas de procesamiento, ventanas temporales y control de estado.
Diferenciar entre idempotencia técnica y reglas de negocio que determinan si una operación puede repetirse.
Controlar concurrencia con optimistic concurrency, locks razonables, versiones de agregado o restricciones de base de datos.
Crear respuestas consistentes cuando una operación ya se ejecutó pero el cliente no recibió confirmación.
Diseñar reintentos seguros para APIs, workers y consumidores de eventos.
Preparar métricas de duplicados, reintentos, conflictos, compensaciones y operaciones parcialmente completadas.
Probar idempotencia con fallos simulados de red, timeouts, reentregas y ejecución concurrente.
Documentar operaciones críticas con sus invariantes, riesgos, estrategias de recuperación y criterios de auditoría.
Tema 14: Seguridad entre microservicios
Diseñar autenticación y autorización entre servicios usando OAuth2, OpenID Connect, JWT, mTLS o identidades gestionadas según entorno.
Separar autenticación de usuario final, identidad de servicio, permisos internos y autorización por recurso.
Propagar contexto de usuario solo cuando sea necesario, evitando exponer información sensible en cabeceras o eventos.
Aplicar mínimos privilegios en APIs internas, colas, bases de datos, secretos, observabilidad y herramientas de despliegue.
Gestionar secretos con vaults, variables protegidas, rotación, scopes y prohibición de credenciales en repositorios.
Diseñar políticas de autorización por servicio, operación, tenant, entorno y sensibilidad del dato.
Revisar riesgos de seguridad típicos: SSRF, exposición de endpoints internos, tokens largos, logs sensibles y permisos amplios.
Proteger comunicación mediante TLS, certificados, gateways, service mesh o controles equivalentes cuando la arquitectura lo requiera.
Crear auditoría de acciones críticas entre servicios, especialmente en cambios de permisos, pagos, datos personales o administración.
Integrar seguridad en CI/CD, code review, threat modeling y pruebas de integración.
Tema 15: Configuración, secretos y feature flags
Gestionar configuración por entorno sin duplicar valores manualmente ni mezclar settings de desarrollo, staging y producción.
Separar configuración técnica, configuración de negocio, secretos, flags, límites de resiliencia y parámetros operativos.
Usar `IOptions`, configuración tipada, validación al arranque y fallos tempranos cuando falta configuración crítica.
Proteger secretos mediante Azure Key Vault, AWS Secrets Manager, HashiCorp Vault, Kubernetes Secrets u opciones corporativas.
Diseñar feature flags para separar despliegue de activación funcional y reducir riesgo en releases.
Controlar flags por entorno, usuario, tenant, porcentaje, grupo o criterio de negocio.
Evitar flags permanentes que se convierten en deuda y multiplican ramas lógicas dentro del código.
Registrar cambios de configuración sensibles con auditoría, owner, motivo y fecha.
Probar configuración en CI/CD para detectar errores antes de desplegar.
Crear una estrategia de configuración distribuida con seguridad, trazabilidad, rollback y documentación.
Tema 16: Observabilidad con OpenTelemetry, logs, métricas y trazas
Instrumentar microservicios .NET con logs estructurados, métricas, trazas distribuidas y correlation IDs.
Usar OpenTelemetry para recoger señales estándar y exportarlas a herramientas como Prometheus, Grafana, Jaeger, Tempo, Azure Monitor o equivalentes.
Comprender que .NET integra APIs de logging, métricas y Activity que sirven como base para OpenTelemetry.
Diseñar convenciones de nombres para spans, métricas, atributos, eventos y dimensiones de negocio.
Propagar contexto de traza entre HTTP, gRPC, colas, eventos, workers y dependencias externas.
Evitar cardinalidad excesiva en métricas por IDs únicos, usuarios, payloads o valores demasiado variables.
Crear dashboards por servicio, journey, dependencia, cola, base de datos y SLO.
Detectar problemas de latencia, errores, saturación, timeouts, retries, colas acumuladas y dependencias degradadas.
Proteger datos sensibles en logs y trazas, evitando payloads completos, tokens, cookies, datos personales o secretos.
Definir una plantilla de observabilidad obligatoria para cada microservicio antes de pasar a producción.
Tema 17: Health checks, readiness, liveness y diagnóstico operativo
Implementar health checks en ASP.NET Core para reportar estado de aplicación, base de datos, colas, cache y dependencias.
Diferenciar liveness, readiness y startup checks para evitar reinicios innecesarios o tráfico hacia servicios no preparados.
Crear checks rápidos, seguros y útiles, sin sobrecargar dependencias críticas con pruebas demasiado costosas.
Exponer endpoints internos de salud con información suficiente para orquestadores y limitada para públicos externos.
Integrar health checks con Kubernetes, balanceadores, gateways, monitorización y pipelines postdeploy.
Diseñar estados degradados cuando una dependencia no crítica falla pero el servicio puede operar parcialmente.
Añadir información de build, versión, commit, entorno y configuración no sensible para facilitar soporte.
Crear runbooks asociados a fallos de health check para que el equipo sepa qué revisar y cómo mitigar.
Evitar health checks que devuelven OK aunque el servicio no pueda cumplir su función principal.
Definir criterios de producción: ningún servicio crítico se despliega sin health checks, métricas, logs, trazas y owner.
Tema 18: Resiliencia, tolerancia a fallos y degradación controlada
Diseñar servicios preparados para fallos de red, latencia alta, dependencias caídas, timeouts, saturación y errores parciales.
Aplicar retries con backoff y jitter para evitar tormentas de reintentos ante dependencias degradadas.
Usar circuit breakers para cortar llamadas temporalmente cuando una dependencia falla de forma sostenida.
Aplicar bulkheads para aislar recursos y evitar que una operación lenta bloquee todo el servicio.
Diseñar fallbacks que permitan devolver datos parciales, cacheados o mensajes claros sin romper la experiencia completa.
Establecer timeouts explícitos y coherentes entre cliente, gateway, servicio, base de datos y mensajería.
Medir retries, timeouts, circuit breaker state, fallbacks y degradaciones como señales operativas.
Evitar resiliencia mal configurada que oculta fallos reales o aumenta presión sobre sistemas ya saturados.
Probar resiliencia con fallos simulados de dependencias, colas, bases de datos y servicios externos.
Documentar políticas de resiliencia por dependencia con owner, parámetros, motivo y límites.
Tema 19: Testing de microservicios .NET
Diseñar una estrategia de pruebas que combine unitarias, integración, contrato, componente, end-to-end y pruebas de resiliencia.
Crear tests unitarios para dominio, servicios de aplicación, validadores, mappers, políticas y reglas de negocio.
Usar tests de integración con bases reales en contenedores, APIs de prueba y configuración aislada.
Aplicar contract testing para validar compatibilidad entre consumidores y proveedores sin desplegar todo el sistema.
Crear pruebas de componente que levanten un servicio con dependencias simuladas o contenedores controlados.
Evitar end-to-end excesivos que se vuelven lentos, frágiles y difíciles de diagnosticar.
¿A quién va dirigida esta formación en Microservicios en .Net?
Pensado para quienes deben dominar Microservicios en .Net en su día a día
Desarrolladores backend .NET
Este curso encaja con desarrolladores que ya trabajan con C#, ASP.NET Core, APIs, Entity Framework Core, SQL, servicios internos o aplicaciones empresariales y quieren dar el salto a arquitecturas distribuidas. Aprenderán a diseñar microservicios con criterio, separar responsabilidades, comunicar servicios, gestionar datos distribuidos y evitar errores típicos de sistemas demasiado fragmentados.
Desarrolladores full stack con foco backend
Los perfiles full stack que participan en APIs, frontends, integraciones y despliegues podrán entender cómo organizar servicios, contratos, autenticación, composición de datos y comunicación entre equipos. La formación les ayuda a construir backends desacoplados sin perder coherencia con las necesidades reales de producto y experiencia de usuario.
Tech leads y desarrolladores senior
Los perfiles con responsabilidad técnica podrán usar el curso para definir estándares internos de microservicios, revisar diseños, guiar migraciones, controlar deuda técnica, mejorar calidad de APIs y establecer patrones comunes. El valor está en tomar mejores decisiones de arquitectura, no en aplicar microservicios por moda.
Equipos que mantienen monolitos .NET
Los equipos que trabajan con monolitos grandes, aplicaciones legacy, Web APIs acopladas o soluciones difíciles de desplegar podrán aprender estrategias de modernización gradual. El curso trabaja monolito modular, Strangler Fig, extracción de servicios, pruebas de caracterización y convivencia entre sistemas nuevos y existentes.
Equipos DevOps y plataforma .NET
Los perfiles DevOps podrán profundizar en contenedores, Kubernetes, Aspire, CI/CD, observabilidad, configuración, secretos, despliegues, health checks y operación de servicios. La formación conecta desarrollo de microservicios con prácticas reales de entrega y mantenimiento en producción.
Equipos de arquitectura, calidad y seguridad
Los perfiles de arquitectura, QA y AppSec podrán utilizar el curso para revisar boundaries, contratos, testing, resiliencia, autorización, trazabilidad, seguridad de servicios y calidad operativa. Esto permite que los microservicios se diseñen con control desde el inicio y no como una colección de APIs inconexas.
Proveedor con 16 años de experiencia en formación empresarial
Sobre
En Imagina Formación llevamos más de 16 años ayudando a profesionales y empresas a mejorar sus habilidades con formación práctica y totalmente adaptada a sus necesidades. Durante este tiempo, hemos formado a más de 480.000 personas y colaborado con más de 3.500 empresas, convirtiéndonos en un referente en el sector.
16
Años de liderazgo
+480.000
Alumnos formados en Imagina
¿Tienes dudas?
Resolvemos todas tus dudas sobre nuestra formación en Microservicios en .Net
Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.
Explica los fundamentos, pero está pensado para desarrolladores .NET con experiencia backend. No es un curso básico de C#; el foco está en arquitectura, implementación, testing, despliegue y operación de microservicios reales.
Sí. El curso está actualizado a .NET 10 como referencia actual LTS para el ecosistema .NET. Microsoft indica que .NET 10 es una versión de soporte a largo plazo con tres años de soporte.
Sí. ASP.NET Core es la base del curso para construir APIs, endpoints, validación, seguridad, health checks, OpenAPI, observabilidad y servicios backend.
Sí. El curso incluye gRPC para comunicación de alto rendimiento entre servicios. Microsoft documenta gRPC en .NET como un framework RPC de alto rendimiento e independiente del lenguaje.
Sí. Aspire se usa para orquestación local, desarrollo distribuido y observabilidad durante el desarrollo. Microsoft lo define como una capa de orquestación y observabilidad para aplicaciones distribuidas.
Sí. Se incluye Dapr como opción para service invocation, pub/sub, estado, secretos y otros building blocks. Dapr expone building blocks mediante APIs HTTP o gRPC y usa un runtime sidecar por servicio.
Sí. El curso trabaja API Gateway, BFF y YARP. Microsoft describe YARP como una librería de reverse proxy para .NET altamente personalizable y orientada a escenarios flexibles.
Sí. Hay un bloque específico sobre despliegue y operación de microservicios .NET en Kubernetes, incluyendo probes, recursos, escalado, configuración, secretos, logs, métricas y troubleshooting.
Sí. Se trabajan pruebas unitarias, integración, contrato, componente, resiliencia y end-to-end controladas, además de Testcontainers, brokers de prueba, mocks HTTP y validación en CI/CD.
Sí. El curso incluye modernización desde monolitos .NET, estrategia Strangler Fig, monolito modular, anti-corruption layers, pruebas de caracterización, extracción progresiva y migraciones de datos.
No. Es un curso corporativo práctico para equipos de desarrollo .NET. Puede ayudar a reforzar conocimientos útiles para arquitectura cloud o DevOps, pero no sustituye una preparación oficial de certificación.
Sí. Al tratarse de una formación corporativa en desarrollo .NET, arquitectura, DevOps, cloud, seguridad, testing y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.
Explica los fundamentos, pero está pensado para desarrolladores .NET con experiencia backend. No es un curso básico de C#; el foco está en arquitectura, implementación, testing, despliegue y operación de microservicios reales.
Sí. El curso está actualizado a .NET 10 como referencia actual LTS para el ecosistema .NET. Microsoft indica que .NET 10 es una versión de soporte a largo plazo con tres años de soporte.
Sí. ASP.NET Core es la base del curso para construir APIs, endpoints, validación, seguridad, health checks, OpenAPI, observabilidad y servicios backend.
Sí. El curso incluye gRPC para comunicación de alto rendimiento entre servicios. Microsoft documenta gRPC en .NET como un framework RPC de alto rendimiento e independiente del lenguaje.
Sí. Aspire se usa para orquestación local, desarrollo distribuido y observabilidad durante el desarrollo. Microsoft lo define como una capa de orquestación y observabilidad para aplicaciones distribuidas.
Sí. Se incluye Dapr como opción para service invocation, pub/sub, estado, secretos y otros building blocks. Dapr expone building blocks mediante APIs HTTP o gRPC y usa un runtime sidecar por servicio.
Sí. El curso trabaja API Gateway, BFF y YARP. Microsoft describe YARP como una librería de reverse proxy para .NET altamente personalizable y orientada a escenarios flexibles.
Sí. Hay un bloque específico sobre despliegue y operación de microservicios .NET en Kubernetes, incluyendo probes, recursos, escalado, configuración, secretos, logs, métricas y troubleshooting.
Sí. Se trabajan pruebas unitarias, integración, contrato, componente, resiliencia y end-to-end controladas, además de Testcontainers, brokers de prueba, mocks HTTP y validación en CI/CD.
Sí. El curso incluye modernización desde monolitos .NET, estrategia Strangler Fig, monolito modular, anti-corruption layers, pruebas de caracterización, extracción progresiva y migraciones de datos.
No. Es un curso corporativo práctico para equipos de desarrollo .NET. Puede ayudar a reforzar conocimientos útiles para arquitectura cloud o DevOps, pero no sustituye una preparación oficial de certificación.
Sí. Al tratarse de una formación corporativa en desarrollo .NET, arquitectura, DevOps, cloud, seguridad, testing y competencias digitales, puede plantearse como formación bonificable hasta el 100% a través de FUNDAE, según el crédito disponible y cumpliendo los requisitos administrativos aplicables.