Curso de Mulesoft

Comprender el enfoque API-led connectivity como patrón de diseño reutilizable.

Diferenciar System APIs, Process APIs y Experience APIs por responsabilidad, audiencia y nivel de abstracción.

Diseñar System APIs para encapsular sistemas de registro como Salesforce, SAP, ERP, bases SQL o legacy.

Diseñar Process APIs para orquestar lógica de negocio, composición de datos y procesos transversales.

Diseñar Experience APIs para adaptar información a web, móvil, portal, partner, agente o consumidor concreto.

Evitar APIs monolíticas que mezclan persistencia, proceso, presentación y reglas de negocio.

Crear mapas de reutilización para detectar qué APIs pueden servir a varios canales.

Definir ownership, versionado, SLA, seguridad y documentación por tipo de API.

Diseñar una arquitectura de integración escalable antes de abrir Anypoint Studio.

Realizar ejercicio de descomposición API-led para un caso empresarial.

Navegar por Anypoint Platform y comprender sus áreas principales.

Diferenciar organización, business group, environment, user, role, permission y connected app.

Gestionar entornos como sandbox, development, test, staging, production y disaster recovery.

Entender el papel de Design Center, API Designer, Exchange, API Manager, Runtime Manager y Monitoring.

Relacionar control plane, runtime plane, gateways, aplicaciones, APIs y activos reutilizables.

Crear estructura de gobierno para equipos distribuidos y múltiples proyectos.

Definir roles mínimos para desarrolladores, administradores, operadores, arquitectos y responsables API.

Evitar permisos excesivos que permiten publicar, desplegar o securizar sin control.

Documentar configuración inicial de plataforma para un cliente o proyecto enterprise.

Realizar ejercicio de revisión de estructura Anypoint para una organización simulada.

Comprender el diseño API-first como práctica para acordar contratos antes de implementar.

Crear especificaciones RAML y OpenAPI con recursos, métodos, tipos, ejemplos, errores y seguridad.

Definir modelos de datos reutilizables para clientes, pedidos, productos, contratos o entidades de negocio.

Diseñar respuestas consistentes con status codes, headers, paginación, filtros y errores normalizados.

Crear ejemplos realistas para consumidores, QA, documentación y mocks.

Incorporar versionado, naming conventions, resource modeling y criterios REST.

Evitar especificaciones incompletas que luego obligan a improvisar en implementación.

Publicar especificaciones como activos reutilizables.

Validar contrato API antes de desarrollar flujos Mule.

Realizar ejercicio de diseño completo de una API REST con RAML u OpenAPI.

Publicar APIs, conectores, plantillas, ejemplos, políticas, assets y documentación en Exchange.

Gestionar versiones, categorías, tags, descripciones, owners y visibilidad de activos.

Crear documentación útil para consumidores: descripción, ejemplos, contratos, SLA, seguridad y uso esperado.

Reutilizar assets existentes desde Anypoint Studio, Code Builder, API Manager o Runtime Manager.

Diferenciar asset interno, asset público, asset de cliente, plantilla reutilizable y API productizada.

Diseñar gobierno de Exchange para evitar duplicidades y APIs sin owner.

Crear lifecycle de activo: draft, review, published, deprecated, retired.

Gestionar dependencias entre APIs, fragmentos RAML, librerías DataWeave y templates.

Evitar que Exchange sea solo un repositorio técnico sin valor para consumidores.

Realizar ejercicio de publicación de una API reutilizable con documentación completa.

Crear proyectos Mule con Anypoint Studio y revisar estructura Maven.

Crear proyectos con Anypoint Code Builder y entender su enfoque basado en desarrollo moderno.

Comparar experiencia de Studio, Code Builder, XML, canvas visual y edición asistida.

Gestionar dependencias, conectores, módulos, configuración y archivos Mule XML.

Entender estructura de carpetas: `src/main/mule`, `src/main/resources`, `src/test`, `pom.xml` y configuración.

Ejecutar aplicaciones localmente y probar endpoints desde cliente HTTP.

Depurar flujos con logs, breakpoints, payloads, variables y mensajes intermedios.

Gestionar credenciales y properties por entorno sin hardcodear secretos.

Evitar proyectos creados sin estándar de nombres, paquetes, carpetas y configuración.

Realizar ejercicio de creación de primera API Mule con endpoint, transformación y respuesta.

Comprender Mule 4 como motor de ejecución de aplicaciones e integraciones.

Diferenciar flow, subflow, private flow, event, message, payload, attributes y variables.

Entender cómo circula un evento Mule por conectores, scopes, transformaciones y handlers.

Diseñar flujos legibles, pequeños y orientados a responsabilidades claras.

Usar flow references para reutilizar lógica sin duplicar bloques.

Gestionar variables para datos temporales sin contaminar payload innecesariamente.

Leer y modificar atributos HTTP, metadatos de ficheros, resultados SQL o respuestas externas.

Evitar flujos gigantes difíciles de probar, depurar y mantener.

Documentar flujos críticos con nombres claros, comments útiles y estructura coherente.

Realizar ejercicio de flujo Mule completo con entrada HTTP, transformación y llamada externa.

Usar conectores estándar para HTTP, Database, File, SFTP, Salesforce, JMS, VM, Object Store y Web Service Consumer.

Configurar conectores con conexiones, operaciones, timeouts, reconexión, TLS y parámetros externos.

Integrar Salesforce con operaciones CRUD, queries, bulk, platform events o escenarios de sincronización.

Conectar bases de datos relacionales con SELECT, INSERT, UPDATE, stored procedures y transacciones.

Integrar ficheros locales, SFTP, CSV, XML, JSON y procesos batch.

Consumir APIs externas REST y servicios SOAP desde Mule.

Gestionar credenciales mediante secure properties y configuración por entorno.

Evitar crear conectores duplicados o configuraciones dispersas sin reutilización.

Diseñar pruebas con mocks cuando no se dispone de sistemas reales.

Realizar ejercicio de integración con Salesforce, SQL, HTTP y SFTP.

Comprender DataWeave como lenguaje central de transformación en MuleSoft.

Transformar JSON, XML, CSV, Java objects, arrays, maps, strings, fechas y estructuras anidadas.

Usar `map`, `filter`, `reduce`, `pluck`, `groupBy`, `orderBy`, `distinctBy` y funciones habituales.

Crear transformaciones entre modelos canónicos y formatos de sistemas origen/destino.

Trabajar con nulls, defaults, tipos, casting, fechas, zonas horarias y validaciones.

Separar transformaciones complejas en scripts reutilizables.

Usar módulos, funciones personalizadas y librerías DataWeave.

Evitar transformaciones ilegibles con lógica de negocio mezclada y sin comentarios.

Probar scripts DataWeave con casos reales, vacíos, incompletos y erróneos.

Realizar ejercicio de transformación de pedidos entre Salesforce, ERP y API pública.

Diseñar modelos canónicos para reducir acoplamiento entre sistemas.

Normalizar datos procedentes de múltiples fuentes con estructuras y nombres inconsistentes.

Crear mapeos condicionales según país, canal, tipo de cliente, estado de pedido o sistema destino.

Procesar documentos grandes evitando transformaciones ineficientes.

Crear funciones reutilizables para fechas, importes, identificadores, direcciones, estados y catálogos.

Gestionar errores de transformación con mensajes claros y trazabilidad.

Crear librerías DataWeave versionadas y publicables en Exchange.

Comparar transformación en Mule frente a transformación en sistemas origen o destino.

Optimizar scripts DataWeave por legibilidad, rendimiento y facilidad de prueba.

Realizar ejercicio de librería DataWeave corporativa para normalización de datos.

Diferenciar errores de conectividad, timeout, validación, transformación, negocio, seguridad y sistema destino.

Implementar error handlers globales y locales según criticidad y responsabilidad del flujo.

Usar On Error Continue y On Error Propagate con criterio.

Crear respuestas de error estandarizadas para APIs y consumidores.

Implementar reintentos, reconnection strategies, circuit breaking externo y fallback cuando procede.

Gestionar idempotencia para evitar duplicidades en reintentos de integración.

Registrar errores con correlationId, sistema afectado, payload seguro, causa y acción recomendada.

Evitar ocultar errores críticos devolviendo respuestas exitosas artificiales.

Diseñar dead-letter, reprocessing y soporte operativo para fallos recuperables.

Realizar ejercicio de integración con errores provocados y estrategia de recuperación.

Usar APIkit para generar estructuras de implementación desde especificaciones API.

Mapear recursos y métodos del contrato a flows Mule.

Validar requests contra contrato y gestionar errores de validación.

Mantener sincronización entre especificación publicada e implementación real.

Crear mocks, pruebas y validaciones tempranas para consumidores.

Evitar modificar implementación sin actualizar RAML/OpenAPI y Exchange.

Diseñar contratos compatibles con evolución, versionado y backwards compatibility.

Implementar respuestas de error coherentes con la especificación.

Crear rutas de API claras y separadas por recurso.

Realizar ejercicio de API contract-first implementada con APIkit.

Publicar APIs en API Manager y relacionarlas con implementación, proxy o gateway.

Gestionar API instances, versions, environments y endpoints.

Aplicar políticas sin modificar el código de la aplicación.

Configurar client ID enforcement, rate limiting, throttling, spike control, CORS y headers.

Aplicar políticas de autenticación y autorización según consumidor, entorno y criticidad.

Gestionar contratos de acceso, client applications, SLA tiers y aprobación de consumidores.

Revisar analíticas de consumo, errores, latencia y patrones de tráfico.

Evitar exponer APIs sin políticas mínimas de seguridad y trazabilidad.

Diseñar modelo de gobierno de APIs por dominio, área y criticidad.

Realizar ejercicio de publicación y securización de API en API Manager.

Diseñar seguridad por capas: red, gateway, policy, aplicación, backend y datos.

Implementar OAuth2, JWT validation, client credentials, scopes y claims relevantes.

Diferenciar autenticación de consumidores, autorización de operaciones y permisos de backend.

Configurar TLS, certificados, truststores, keystores y endpoints seguros.

Proteger APIs internas, externas, partner y públicas con políticas adecuadas.

Gestionar secrets, credentials, secure properties y rotación de claves.

Evitar registrar tokens, contraseñas, payloads sensibles o datos personales en logs.

Diseñar controles contra abuso: rate limits, quotas, spike control y client management.

Coordinar seguridad con IAM corporativo, API gateway, firewall, WAF y zero trust.

Realizar ejercicio de API protegida con OAuth2/JWT y políticas de consumo.

Comprender el papel de Omni Gateway, antes Flex Gateway, en arquitecturas híbridas y distribuidas.

Diferenciar Mule Gateway, Omni Gateway, gateways gestionados y gateways conectados.

Exponer y securizar APIs que viven en cloud, Kubernetes, on-premise o entornos externos.

Aplicar políticas desde API Manager sobre gateways conectados.

Diseñar despliegues de gateway en CloudHub 2.0, Runtime Fabric o infraestructura propia.

Integrar gateway con DevOps, CI/CD, service mesh, microservicios y APIs no Mule.

Controlar tráfico, seguridad, autenticación, cuotas, latencia y observabilidad desde la capa gateway.

Evitar desplegar gateways sin estrategia de ownership, certificados, logs y actualización.

Documentar arquitectura de entrada y salida para APIs gestionadas.

Realizar ejercicio de publicación de API protegida mediante gateway.

Comprender CloudHub 2.0 como plataforma gestionada y containerizada para APIs e integraciones.

Configurar aplicaciones, replicas, vCores, properties, secrets, networking y escalado.

Desplegar aplicaciones desde Runtime Manager, Maven o pipeline CI/CD.

Gestionar entornos, releases, logs, redeploys, runtime versions y actualizaciones.

Configurar private spaces, load balancers, inbound/outbound traffic y conectividad segura.

Revisar estrategias de alta disponibilidad, escalabilidad y resiliencia.

Gestionar despliegues blue/green o controlados cuando el proyecto lo requiere.

Evitar desplegar en producción sin healthchecks, logs, alertas y plan de rollback.

Medir impacto de configuración en coste, rendimiento y operación.

Realizar ejercicio de despliegue de aplicación Mule en CloudHub 2.0.

Comprender Runtime Fabric como forma de desplegar Mule apps y proxies sobre Kubernetes gestionado por la organización.

Identificar cuándo usar Runtime Fabric frente a CloudHub 2.0 o despliegues híbridos.

Revisar requisitos de cluster, namespaces, ingress, certificados, nodos, recursos y operación.

Desplegar aplicaciones Mule y gestionar recursos CPU, memoria, replicas y properties.

Integrar Runtime Fabric con Runtime Manager y control plane Anypoint.

Gestionar actualizaciones, redeploys, escalado, observabilidad y soporte.

Diseñar estrategias de red, seguridad, isolation, ingress/egress y conectividad a sistemas internos.

Coordinar responsabilidades entre equipo MuleSoft, plataforma Kubernetes, seguridad y operaciones.

Evitar trasladar complejidad Kubernetes al equipo de integración sin modelo operativo claro.

Realizar ejercicio de arquitectura Runtime Fabric para cliente enterprise.

Usar Runtime Manager para desplegar, gestionar y monitorizar aplicaciones Mule.

Revisar estado de aplicaciones, logs, alerts, properties, deployments y versiones.

Gestionar entornos sandbox, test, staging y production con configuración diferenciada.

Realizar restart, redeploy, rollback y cambios controlados.

Analizar fallos de arranque, errores de runtime, problemas de conectividad y consumo de recursos.

Configurar alertas por disponibilidad, errores, latencia o métricas relevantes.

Documentar runbooks para soporte N1, N2 y N3.

Evitar operación reactiva basada solo en revisar logs cuando ya hay incidencia.

Diseñar modelo de soporte con owners, SLAs, escalado y ventanas de mantenimiento.

Realizar ejercicio de operación de una app Mule con incidencia simulada.

Crear pruebas unitarias con MUnit para flows, subflows y transformaciones.

Mockear conectores externos como Salesforce, Database, HTTP, SFTP o servicios SOAP.

Validar payloads, variables, atributos, errores y llamadas esperadas.

Crear tests para casos normales, errores, timeouts, datos incompletos y transformaciones críticas.

Medir cobertura de pruebas sin perseguir porcentajes vacíos.

Integrar pruebas MUnit en Maven y pipelines CI/CD.

Crear datasets de test y datos simulados reutilizables.

Evitar pruebas que dependen de sistemas externos inestables o datos productivos.

Diseñar estrategia de testing por capa API-led: System, Process y Experience.

Realizar ejercicio de suite MUnit para API con conectores mockeados.

Comprender estructura Maven de proyectos Mule y gestión de dependencias.

Configurar Mule Maven Plugin para build, deploy y gestión de artefactos.

Versionar proyectos Mule en Git con ramas, pull requests y revisiones técnicas.

Crear pipelines en GitHub Actions, GitLab CI, Azure DevOps, Jenkins o herramientas equivalentes.

Ejecutar validación, build, MUnit, packaging y despliegue automático por entorno.

Gestionar credentials, connected apps, secrets y variables de pipeline de forma segura.

Publicar assets en Exchange y desplegar aplicaciones de forma controlada.

Implementar promociones entre entornos sin recompilar innecesariamente.

Evitar despliegues manuales no trazables en entornos productivos.

Realizar ejercicio de pipeline CI/CD completo para una aplicación Mule.

Diseñar procesos batch para importar, transformar, validar y cargar grandes volúmenes de datos.

Procesar CSV, XML, JSON, ficheros planos, directorios, SFTP y fuentes programadas.

Usar batch job, batch steps, aggregators, streaming y control de memoria con criterio.

Manejar errores por registro, errores de lote, reintentos, rechazos y reprocesos.

Crear informes de carga con totales, errores, registros aceptados y descartados.

Diseñar idempotencia para evitar duplicados en reejecuciones.

Integrar batch con bases de datos, Salesforce, ERP o sistemas externos.

Evitar cargar ficheros grandes en memoria sin estrategia de streaming o segmentación.

Monitorizar duración, throughput, errores y cuellos de botella.

Realizar ejercicio de carga masiva de datos con validación y reporte de errores.

Conectar MuleSoft con Salesforce mediante Salesforce Connector y patrones recomendados.

Ejecutar consultas SOQL, operaciones CRUD, upsert, composite, bulk y sincronización de objetos.

Integrar eventos de Salesforce, platform events o escenarios near real-time.

Diseñar System APIs para encapsular Salesforce sin exponer detalles internos.

Transformar datos entre Salesforce, ERP, e-commerce, data warehouse y APIs externas.

Gestionar límites de API, paginación, bulk operations, errores y reintentos.

Proteger datos sensibles de clientes, leads, oportunidades, contratos y casos.

Integrar Agentforce u otros escenarios Salesforce cuando la arquitectura lo requiere.

Evitar acoplar directamente cada consumidor a Salesforce sin capa API gobernada.

Realizar ejercicio de integración Salesforce con clientes, pedidos y casos.

Conectar MuleSoft con bases SQL para lectura, escritura, procedimientos y transacciones.

Diseñar APIs sobre sistemas legacy sin exponer modelos internos obsoletos.

Integrar ERP mediante APIs, bases intermedias, ficheros, colas, SOAP o conectores específicos.

Gestionar transacciones, consistencia, compensación y errores entre sistemas.

Crear modelos canónicos para desacoplar consumidores de estructuras legacy.

Manejar paginación, bloqueos, timeouts, conexiones y pooling.

Diseñar sincronizaciones incrementales con marcas de tiempo, IDs y estados.

Evitar cargas directas indiscriminadas contra bases de producción.

Documentar contratos de integración con ownership claro.

Realizar ejercicio de API de pedidos conectada a base SQL y ERP simulado.

Diferenciar integración síncrona, asíncrona, orientada a eventos y procesamiento diferido.

Usar conectores JMS, Anypoint MQ, VM, Kafka u opciones equivalentes según escenario.

Diseñar productores, consumidores, colas, topics, dead-letter queues y reintentos.

Gestionar idempotencia, orden, duplicados, backpressure y errores transitorios.

Crear flujos asíncronos para operaciones lentas, integración batch o desacoplamiento de sistemas.

Monitorizar mensajes, errores, latencia y acumulación en colas.

Diseñar patrones publish-subscribe, request-reply, event notification y event-carried state transfer.

Evitar usar integración síncrona cuando el proceso requiere resiliencia y desacoplamiento.

Documentar contratos de eventos y payloads versionados.

Realizar ejercicio de integración asíncrona con cola, retry y dead-letter.

Usar Anypoint Monitoring para revisar métricas, logs, dashboards y comportamiento de aplicaciones.

Crear correlation IDs para seguir una transacción entre Experience, Process y System APIs.

Analizar errores HTTP, fallos de conectividad, timeouts, transformaciones y problemas de backend.

Crear dashboards por aplicación, API, entorno, sistema destino y proceso de negocio.

Configurar alertas útiles por disponibilidad, errores, latencia, consumo o degradación.

Diseñar logging estructurado sin exponer datos sensibles.

Integrar logs y métricas con herramientas corporativas externas cuando procede.

Crear runbooks de troubleshooting para incidencias frecuentes.

Evitar logs ruidosos que no permiten diagnosticar la causa real.

Realizar ejercicio de investigación de incidencia end-to-end en integración Mule.

Medir latencia, throughput, concurrencia, consumo de memoria, CPU y tiempos de backend.

Optimizar DataWeave, conectores, streaming, batch, pooling y llamadas externas.

Diseñar timeouts, retries, circuit breaker externo y límites de consumo.

Evitar transformaciones innecesarias, payloads gigantes y llamadas secuenciales evitables.

Usar caché u Object Store cuando aporta valor y no rompe consistencia.

Dimensionar replicas, workers, vCores o recursos Kubernetes según carga real.

Realizar pruebas de carga sobre APIs críticas antes de producción.

Analizar cuellos de botella en sistemas destino y no solo en Mule.

Crear recomendaciones de performance por tipo de integración.

Realizar ejercicio de optimización de una integración lenta.

Definir modelo de gobierno de APIs e integraciones en una organización.

Crear Center for Enablement con roles, responsabilidades, estándares, plantillas y revisión.

Establecer guías de diseño API, naming, versionado, errores, seguridad, logging y documentación.

Crear plantillas Mule reutilizables para APIs, batch, integración Salesforce, errores y observabilidad.

Definir criterios de publicación en Exchange y lifecycle de APIs.

Establecer quality gates antes de diseño, desarrollo, despliegue y producción.

Medir reutilización, adopción, APIs activas, consumidores, errores, deuda y cobertura de gobierno.

Evitar que cada equipo construya integraciones con estilos, seguridad y errores diferentes.

Documentar modelo operativo para crecimiento sostenible de MuleSoft.

Realizar ejercicio de diseño de estándar MuleSoft para empresa.

Comprender cómo MuleSoft se posiciona en integración y gobierno de APIs para escenarios de IA y agentes.

Exponer APIs y servicios empresariales como activos reutilizables para agentes y asistentes.

Integrar MuleSoft con Agentforce y otras plataformas de agentes cuando el caso lo requiere.

Revisar MCP Server de MuleSoft como vía para automatizar tareas sobre Anypoint Platform desde asistentes compatibles.

Diseñar controles para agentes que consumen APIs empresariales: scopes, límites, trazabilidad y aprobación.

Evitar que agentes accedan a sistemas críticos sin API Management ni gobierno de seguridad.

Preparar APIs orientadas a agentes con contratos claros, errores explícitos y permisos granulares.

Medir consumo de APIs por agentes, usuarios, aplicaciones y sistemas automatizados.

Diseñar arquitectura donde MuleSoft actúa como capa segura entre agentes, APIs y sistemas de negocio.

Realizar ejercicio de diseño de integración MuleSoft para un asistente corporativo controlado.

Identificar datos personales, financieros, contractuales, comerciales y sensibles que circulan por flujos Mule.

Aplicar minimización, masking, cifrado, tokenización y control de logs.

Diseñar políticas de retención para logs, payloads, trazas, errores y ficheros temporales.

Revisar cumplimiento de RGPD, auditoría, segregación de funciones y acceso mínimo.

Gestionar secretos con secure properties, secrets manager o mecanismos corporativos.

Aplicar controles de seguridad en APIs internas, externas, partner y públicas.

Crear evidencias de auditoría sobre despliegues, cambios, accesos y políticas aplicadas.

Evitar credenciales embebidas, usuarios compartidos y conexiones sin rotación.

Coordinar MuleSoft con IAM, SIEM, DLP, WAF, API gateway y seguridad cloud.

Realizar ejercicio de revisión de seguridad de una integración crítica.

Diseñar una arquitectura API-led completa para integrar CRM, ERP, inventario, pedidos y canales digitales.

Definir System APIs, Process APIs y Experience APIs con ownership, consumidores, seguridad y versionado.

Crear especificaciones RAML/OpenAPI para las APIs principales con ejemplos, errores y modelos reutilizables.

Publicar activos en Anypoint Exchange con documentación, versión, tags, owner y criterios de consumo.

Implementar una System API conectada a Salesforce, base de datos o servicio mock empresarial.

Implementar una Process API que orquesta datos, aplica reglas y transforma estructuras con DataWeave.

Implementar una Experience API adaptada a portal web, app móvil, partner o agente corporativo.

Crear transformaciones DataWeave reutilizables para normalizar clientes, pedidos, productos y estados.

Implementar manejo de errores estandarizado con correlationId, códigos, mensajes y logs seguros.

Añadir políticas en API Manager: client ID enforcement, rate limit, CORS, OAuth2/JWT o SLA según escenario.

Crear pruebas MUnit para flujos críticos, conectores mockeados, errores y transformaciones.

Configurar Maven, Git y pipeline CI/CD con build, tests, package y despliegue a entorno controlado.

Desplegar la solución en CloudHub 2.0 o diseñar despliegue equivalente para Runtime Fabric.

Configurar properties por entorno, secure properties, secrets, logs y variables necesarias.

Crear dashboard de monitorización con métricas, errores, latencia, consumo y salud de la integración.

Simular una incidencia de backend, analizar logs, corregir error y documentar runbook de soporte.

Preparar documentación técnica: arquitectura, APIs, contratos, seguridad, despliegue, operación y troubleshooting.

Crear modelo de gobierno: estándares, versionado, lifecycle, approvals, ownership y publicación en Exchange.

Diseñar extensión opcional para exponer APIs seguras a un asistente, agente o flujo automatizado.

Presentar la solución final defendiendo arquitectura, reutilización, seguridad, operación, rendimiento y valor de negocio.