MuleSoft Platform Integration Architect Course - MCIA

Identify stakeholders, gather functional and non-functional requirements and SLAs, and draft 4+1 views to design an integration solution for COVID case data from clients to UHO and WHO.

Architects define system architecture with the 4+1 view, covering logical, development, process, and physical views. Capture SLAs, non-functional requirements, API led connectivity, and data flows across UHO, WHO, and S3.

Document integration solutions using an API-led connectivity approach and a comprehensive template. Capture architectural views, lifecycle, performance, non-functional requirements, testing plans, logging, and recovery strategies.

Document technical design and use cases for integration solutions, create user stories with acceptance criteria, and prepare design and mapping documents for covid case services.

Explore the Anypoint platform capabilities, including design center for API design and publishing, management center with runtime manager, API management, analytics, exchange for artifacts, and the Mule runtime engine.

Learn how to create a master organization, multiple business groups, and environments (dev, test, uat, prod) in Anypoint Platform, distribute vcores, static IPs, and load balancers, and manage owner permissions.

Configure users, teams and permissions in the Anypoint platform by inviting users, creating engineering, DevOps and QA teams, and assigning role-based access across business groups, environments, and components.

Configure identity management in the Anypoint platform with an identity provider like Okta to enable single sign-on using OpenID Connect or SAML 2.0 and provision users from the provider.

Enable multi-factor authentication on the Anypoint platform, configuring mfa for non-sso and sso users, and supporting totp apps, built-in authenticators, security keys, and salesforce authenticators via a qr code.

Design APIs by using plural noun resources, avoid abstract nouns and verbs as resources, rely on HTTP methods; use lowercase or kebab-case for resources, camelCase for fields, and status codes.

Design efficient APIs for ehub-sapi by outlining four resources in RAML and using reusable fragments and traits with a standard error structure to ensure consistency across environments.

Master naming standards and project structure for a real-time mule project, using kebab-case for names, camelCase variables, and organized flows, implementations, and global.xml with APIkit routing.

Explore the uhub-sapi case-study implementation, covering global configuration, secure properties, environment-specific files, and a main flow for registering, updating, and querying covid cases with database interactions.

Design and implement a global error handler that provides common, well-structured API error responses across projects, covering 99% of errors with detailed logging and reusable flows.

Publish a mule template archetype to exchange to auto-include common utilities like global.xml and global error handler, then create new projects from the template and refactor for environment properties.

Decode the base64 document payload, compose the s3 key from folderPath and fileName, and upload the document to the configured bucket in s3, with correlation id tracking and error handling.

the lecture shows implementing a who-sapi api that converts a covid case json payload to xml, then publishes it to the q.who.covid.case.report active mq queue with a dynamic case_type property.

Register or update a COVID case through the case API, using national ID checks, upsert logic, uploading the identity document to Amazon S3, and reporting to WHO.

Implement the Covid EAPI by configuring headers and a state query parameter to call the uhub get report service and return state-wise reports.

Explore how the Mule 4 runtime uses a reactive, non-blocking event-processing model built on the observer pattern, with observable and observer roles, a thread pool scheduler, and back pressure.

Explore how Mule 4 uses a reactive, non-blocking execution engine with cpu lite, cpu intensive, blocking IO thread pools, plus Grizzly shared and dedicated pools, to optimize threading and performance.

Explore how transactional scopes enforce thread management, with all event processors running on BLOCKING_IO threads during a try transactional scope, including EMP and EMP_PROFILE database calls and rollback on failure.

Explore Mule event processing strategies, including sequential processing, parallel processing with scatter-gather, and async scope, and discuss reliability patterns for async operations.

Explore synchronous and asynchronous integration messaging patterns, comparing rest and soap web services with jms publish/consume request-reply, and learn when to apply each in high-traffic, distributed applications.

Use idempotent communication in synchronous rest processing with MuleSoft’s Idempotent Message Validator, storing request fingerprints in a persistent object store (max 100 entries, time-to-live one hour) to block duplicates.

Use the content negotiation pattern to return JSON or XML based on the accept header, via a choice router and set variable, including error responses, defaulting to JSON.

Learn the synchronous quick acknowledgement pattern for REST APIs, where the backend processes run asynchronously via JMS, a unique ID is generated, and a callback URL lets clients track status.

Explore asynchronous Mule event processing using the broadcast pattern, pub-sub messaging, and topic bridges to orchestrate data flow across multiple Mule apps and queues for scalable, targeted delivery.

Explore how JMS listener acknowledgements work in Mule, comparing AUTO, DUPES_OK, IMMEDIATE, and MANUAL modes, with examples of persistent messages and dead-letter handling.

Learn Mule's iterative processing strategies, including sequential, parallel, and async-based processing, covering Foreach's sequential processing, parallel Foreach, payload visibility, and cross-scope variables with onboarding and payroll examples.

Discover how parallel for each executes Mule events in parallel, with timeouts, max concurrency, and error handling. Learn how aggregation works and how core and blocking factors influence performance.

Explore how MuleSoft batch job enables reliable, scalable processing of millions of records through a three-phase flow: load and dispatch, process, and on complete phase.

Master batch processing and execution in Mule, including load and dispatch, max failed records, accept policy, batch aggregator with size or streaming, and reliability with persistent queues.

Use foreach for small data with sequential processing; use parallel foreach for moderate data when order isn’t required; use batch job for massive data for asynchronous processing and higher throughput.

Explore scheduled mule event processing, distinguishing real-time and near real-time events, using the MuleSoft scheduler with fixed frequency or cron, configuring disallowConcurrentExecution and on-demand runs.

Explore transaction management in Mule flows, covering local and XA transactions, rollback, and saga patterns across database, JMS, and VM connectors.

Explore how transactional try scopes route all Mule event processors through Blocking_IO threads, ensuring atomic database operations and automatic rollback on failure within an onboarding flow.

Learn how to manage local transactions in Mule applications, including rolling back target data on action failure and using transaction types like local and XA for cross-module operations.

Master xa global transactions in Mule apps to coordinate multiple targets, enabling two-phase commit and rollback with Bitronix recovery across database and JMS operations.

Learn how the until successful scope enhances reliability by retrying failed targets (database, JMS, REST/SOAP) with configurable max retries and delays, ensuring messages are not lost.

Configure reconnection strategies to improve reliability by retrying failed connections across database, soap service, and Salesforce, using until successful retries and defined frequency and attempts.

Explore a JMS reliability framework in MuleSoft that uses until successful retries, error handling, and waiting queues with a scheduler-driven orchestration to manage retry delays, max retries, and dead-letter processing.

Learn to design reliable JMS patterns for transactional and non-transactional systems using a covid-case-mule example, with filters and database-backed payloads to ensure accurate NGO and WHO delivery.

Balance trade-offs for reliability in MuleSoft integrations by tuning reconnection strategies and until successful retries with appropriate max retries and delays, mindful of SLA in request-reply patterns and asynchronous flows.

Design robust MuleSoft integration test strategies with MUnit unit testing, covering manual and automated tests, test driven development, and regression, functional, performance, and integration testing to reduce defects.

Learn how to use MUnit for unit testing in Mule applications, including creating test cases, setting events, asserting results, mocking and spying processors, and integrating with CI/CD.

Explore MUnit assertions, including assert equals, assert that, and assert expression, and learn how core, string, comparable, iterable, and map matchers work with DataWeave assertions.

Learn to use DataWeave .dwl files in MUnit assertions by separating the logic into per-flow dwl files, importing them in assertions, and driving input/output data without editing test cases.

Mock input data for munit by loading input attributes and payload from a dataweave dwl file. Read the file with readUrl on the classpath and apply it to set event.

Demonstrate how to use MUnit mocking processors to simulate database calls for an employee appraisal API, including mock when and not found scenarios for 100% test coverage.

Explore the MUnit verify call feature to confirm whether a specific event processor is invoked, with attributes and exact call counts, and learn how verification affects test outcomes.

Explore how to spy an event processor in MUnit, capturing before and after payloads, mocking rest calls, and asserting responses with dwl files.

Master parameterized test suites in MUnit to run the same test with multiple inputs, such as SC, M, L, and empty, via YAML parameterization.

Develop and test MUnit error scenarios for Mule flows by mocking DB connectivity and validating inputs, comparing on-error continue with on-error propagate to ensure robust error handling.

Master mocking and asserting payloads with JSON files in MuleSoft tests, replacing DWL payloads and validating get employee by id flows with JSON fixtures.

Enable MUnit flow sources to call HTTP request connectors from the execution scope of a REST API test case, validating response attributes and payload.

Use the MUnit test recorder to scaffold and record test cases from a RAML API. Include mock and spy for ReqRes calls and handle 200, 404, and 500 scenarios.

Design black-box functional integration tests for MuleSoft, automate with frameworks like ready APIs and Selenium, enable QA access to third-party integration systems, and produce sign-off ready reports.

Design and execute performance tests for Mule applications by defining baselines with stakeholders, performing stress and load tests, monitoring cpu and memory, scaling, and securing approvals for production.

Explore Anypoint platform capabilities and MuleSoft deployment models, including CloudHub 1.0/2.0 and hybrid or on-premise runtimes, with control plane and runtime plane concepts.

Learn MuleSoft-hosted control and runtime planes on CloudHub with persistent object stores, VM queues (1.0) or Anypoint MQ (2.0), zero downtime upgrades, domain projects not supported, and VCores are expensive.

The instructor explains the hybrid architecture with CloudHub control plane and customer data center runtime, Object Store v2, and Kubernetes-enabled runtime fabric for scalable Mule applications.

Explore customer-hosted control and runtime planes, a private cloud edition where security-minded organizations host Mule Runtime in their own data centers using Pivotal Cloud Foundry.

Learn CloudHub 1.0 runtime architecture on aws, with Mule apps deployed to ec2 workers inside a vpc, protected by firewalls and a dedicated load balancer, plus vpn to on-premise.

Configure a VPC CIDR block to size for each environment, selecting 10.1.0.0/22 for non-prod and 10.2.0.0/23 for production, avoiding overlaps with on-prem networks.

Configure vpcs across parent and child business groups (uho and uhis) for dev, test, load, and prod, with parent-to-child inheritance and region placements (us east 1, Sydney).

Configure firewall rules in a VPC to map public ports 8081 and 8082 and private ports 8091 and 8092, enabling public or within-VPC access with a dedicated load balancer.

Configure internal dns for the vpc to enable private api access via a private domain, linking a c-name to an internal ip and supporting private domain service inside your vpc.

Set up a VPC VPN to connect MuleSoft applications with customer data centers via IPsec tunnels, choosing between automatic or custom tunnel configurations, and share tunnel details with on-prem admins.

Allocate static ip addresses for mule runtime applications to enable reliable partner system whitelisting, using ips drawn from the aws ec2 pool and applied via runtime settings.

Achieve high availability with vertical and horizontal scaling in MuleSoft CloudHub, using round-robin load balancing across workers and choosing between shared and dedicated load balancers.