MuleSoft Certified Developer - Level 2 - Preparation Course

Add an open API specification to design centre and import it to any point studio for an API manager. Apply cryptography to secure data in transit and mask sensitive properties.

Explore the api lifecycle from design to retirement, using design center with RAML or OpenAPI specifications, mocking, testing, and publishing to exchange for developers.

Import an open API specification into design center, test it, and publish to exchange, showcasing a tickets process API that uses bid and city to fetch booking and biodata.

Explore how API manager and API gateway govern and secure APIs, compare proxy endpoints with basic endpoints, and apply out-of-the-box and custom policies with analytics and authentication.

Create an api instance for the super tickets process api in the dev environment. Add a basic logging policy to capture before and after api call details.

Explore how the APIKit router validates requests against the interface and routes to backend flow. See how it enforces content type and schema and returns responses via the http endpoint.

Import the tickets process API from any point exchange into studio, scaffolding main, console, and resource flows from the RAM specification, and validate mock responses in the console UI.

Configure api autodiscovery by linking a deployed Mule application to api manager using an api instance id and environment credentials; after deployment, api status becomes active and policies are enforced.

Enable api autodiscovery in anypoint studio, configure api manager credentials, deploy the application, and automatically download and apply policies such as message logging and analytics policy.

Learn and apply MuleSoft coding conventions, including naming conventions, project structure, and studio settings, with examples for api fragments, xml attributes, maven and jdk paths, and flow naming rules.

Refactor the super tickets process api to follow coding conventions, renaming configurations and creating mule configuration files while aligning global elements and error handlers.

Explore cryptography fundamentals by contrasting symmetric and asymmetric encryption, examining key lengths, performance, and how digital certificates support secure communications.

Understand digital certificates and certificate authorities, including self-signed options, CSR creation, and the exchange of public and private keys to establish secure ssl communication using a symmetric session key.

Explore one-way and two-way SSL, including key stores, trust stores, certificate authorities, and self-signed certificates, and learn how clients and servers verify identities and secure data.

Explore cloudhub architecture, deploying applications to the shared worker cloud with port mapping, load balancing, and dns-based routing, including a dedicated load balancer, vanity domains, and vpc integration.

Compare the JKS and PKCS12 keystore formats, noting that JKS is Java-specific while PKCS12 is standardized. See keytool commands for generating keys and basic TLS termination concepts.

generate a self-signed certificate, package it in source main resources, configure a tls context and https listener for one-way tls, and deploy to studio and cloud hub.

Parameterize Mule app configurations by centralizing property files, using environment-specific naming, and applying proper order, while leveraging secure properties for encrypted values and placeholders for environment references.

Create a properties.yaml to centralize api port, id, groupId, artifactId, and version, reference them in global XML with dollar syntax, enabling CloudHub to VPC environment changes.

Create environment-specific property files for dev and prod, promote an API and its policies from dev to prod, and deploy with runtime arguments and placeholders.

Encrypt and safely hide configuration properties for cloud deployments using the secure properties tool. The session demonstrates Blowfish CBC encryption, key management, and decryption with secure properties in Cloud Hub.

Encrypt sensitive properties with the secure properties tool, configure encrypted values in dev and prod YAML files, hide keys in the cloud UI, and deploy to Cloud Hub.

Master Maven basics, manage dependencies with local and central repos and coordinates (groupId, artifactId, version), and use lifecycles and phases (default, clean, site) with plugin goals for packaging and deployment.

Explore maven resource filtering with the maven resources plugin to replace placeholders in resources, avoiding coordinates across pom and properties YAML file, and configure exclusions like P12, cert, and PEM.

Explore how to configure the maven resources plugin to filter properties files, use placeholders for api coordinates, and selectively filter yaml files while deploying and validating the replaced values.

Reduce build redundancies by centralizing dependency and Maven plugin configurations with a reusable parent pom and a master bom, then refactor projects to share these configurations.

Configure a parent pom to manage plugins and dependencies for a multi-project setup, install it to the local Maven repository, and reference it from child projects before deploying and testing.

Configure a master BOM to centralize dependency versions while syncing the parent POM's plugin configurations, repositories, and versions. Reinstall in the local Maven repository and deploy to verify connector versions.

Learn to build a Mule application with Maven commands in a hands-on session. Update Studio 7.12, configure a local Maven repository, and install parent and master BOMs.

Explore connected applications on the any point platform, generate client credentials via OAuth 2.0 and Open Eddy Connect, and configure Maven to access artifacts from exchange with scopes.

Learn how to deploy Mule applications to Cloud Hub with the Mule Maven plugin, including environment and region setup, authentication via connected application, and deployment strategies.

Deploy CloudHub applications using the Mule Maven plugin by configuring cloud settings, creating a connected app, and deploying with Maven, including environment, client id, and secret.

Enable and configure any point visualizer in Mule applications, map apps to process, system, or experience layers, and monitor architecture, troubleshooting metrics, and policy visualization in sandbox and prod environments.

Summarizes section one topics: API versioning and RAM major versions, out-of-the-box policies, API auto discovery, Mule apps with build configurations, cloud deployment, and TLS security with property management.

Add integration logic to the super tickets API with rest connectors. Obtain credentials and call the award service via http request to get a token for the authorization header.

Explore rush connect and learn to create and configure it in a mule application, as rest connect converts RAML or OpenAPI specs to Mule 3 and Mule 4 connectors.

Pull system API connectors from any point exchange and configure them in the mail application using rest connect, Rush Connect, and an XML SDK, with master BOM version management.

Configure system api access by retrieving the instance url, client credentials, and host details from developer portal, then wire them in the mail application with camel case properties and logging.

Explore nonfunctional requirements and their impact on API performance, availability, and security, including response timeouts and the need for meaningful values tested through performance testing.

Explore the basics of OAuth 2.0, including authorization code grant type, access tokens, refresh tokens, and scopes, and how authorization servers enable secure delegated access.

Configure oauth in request connector using client credentials to obtain and store access token from token URL in object store, then attach it in the authorization header for booking service.

Deploy oauth and bookings api on cloud hub and import the solution jar. Create an oauth client, generate tokens, and enforce access with an oauth policy via api manager.

Fetch an OAuth access token using the client credentials grant and store it in object store for reuse by the token manager in http request connector as a bearer token.

Change the http connector log level to debug in Studio and deploy the app to view token fetch, usage logs, and calls to booking service, movies api, and biodata api.

Utilize dataweave transformation logic with target variables in the transform message to convert mock responses into actual data for bookings, biodata, and movies.

Explore global error handling in MuleSoft by using a choice router to validate Marvel vs. DC data, raise a custom error, and return a JSON message.

Learn to use scatter gather for parallel calls and error handling in Mule flows. Discover the Mule Shared Together component for broadcasting, gathering responses, and applying compensation logic.

Learn to run HTTP request connectors in parallel with scatter-gather, compare response times, redeploy the app, and explore error handling for timeouts in MuleSoft.

Learn to identify failed and successful routes in a scatter gather flow using the error payload, then implement compensation to undo successful routes.

Explore compensation logic in MuleSoft by demonstrating undoing successful external calls using a choice router and for-each scope, focusing on get versus write operations and rollback strategies.

Explore HTTP status code classes from informational to server errors, distinguish transient from permanent errors in MuleSoft, and apply retry options such as reconnection strategy and response validator.

Explore how to handle transient and permanent errors in MuleSoft, using the until successful scope to retry connectivity timeouts and unauthorized responses.

Explore caching in MuleSoft, comparing server-side and client-side caching with TTL and cache scope, and learn how object stores enable fast responses and reduced backend load.

Learn to implement client side caching with a cache scope, define a biodata object store and caching strategy, and verify cache hits, misses, and expiration in MuleSoft.

Apply a server-side API caching policy to reduce backend calls. Configure cache key and TTL, enable distributed caching, and use an invalidate header to clear single entries or all.

Apply the CDP caching policy to a system API, configure ttl, distributed caching, and a custom header to invalidate cache, then visualize API interactions with the visualizer.

Explore section two coverage: server-side API caching, environment-specific scoping; log level changes and analysis to debug; fault-tolerant ATP API invocations, scatter-gather compensation, and oauth plus basic authentication.

Explore asynchronous message processing by configuring http callbacks with an external service and registering them with William Connectors, using dl cues, transactions, re delivery policy, and circuit breaker.

Understand how http callbacks work by registering a callback endpoint in the Mule app and receiving cancelled show data via the external server's http post, with a 202 accepted response.

configure an http callback flow to handle cancel show notifications in the super tickets puppy app, exposing post /api/cancel show, logging cancellations, deploying the app, and testing with postman.

Register an external service callback using a post request, with a dynamic URL via cloud hub reserved properties (full domain) and property files, then test with postman.

Explore asynchronous processing patterns in mule, comparing non-blocking flows, VM queues, and AnyPoint MQ connectors, with publish, consume, and brokered messaging for reliable, scalable integration.

Explore the reliability pattern by configuring VM queues and publishing messages to a persistent queue, ensuring durability even if a non transactional connector receives the request.

Create a VM listener flow to consume messages from a persistent queue. Transform the JSON payload and use a local transaction scope to roll back on errors, causing indefinite retries.

Enable a re delivery policy on the VM listener, set the max delivery count, and identify re delivered messages with a secure hash or correlation ID using an ID expression.

Explore handling re delivery exhausted errors by publishing undelivered messages to a dll queue and processing them with a vm listener and logger.

Explore any point mq concepts, including queues, exchanges, standard vs first in, first out, and dead letter queues, and learn to create, bind, publish, and browse messages in studio.

Configure the Anypoint MQ module in the mule application by adding the MQ config to global.xml, supplying the URL, client id, and client secret, using secure properties for encryption.

Publish a transformed JSON payload to an Anypoint MQ queue using the endpoint MQ, configuring the destination and correlation ID, and test via CloudHub deployment and Postman.

Explore any point MQ acknowledgement modes—auto, manual, and immediate, and distinguish acknowledgement, negative acknowledgement, and optional acknowledgement timeout with the acknowledgement token.

Set up a MuleSoft Anypoint MQ subscriber, enable manual acknowledgement with a token, deploy, transform payloads, and remove processed messages from the queue.

Publish events to an external system via Anypoint MQ and use negative acknowledgment to re-queue on errors; distinguish HTTP not found from connectivity errors and apply a circuit breaker.

Configure the any point MQ circuit breaker to protect a flow, with closed, open, and half open states, using error types, thresholds, and trip timeouts for the subscriber.

Configure the Anypoint MQ circuit breaker to handle http connectivity errors, using a five-error threshold and a twenty-second open state to protect resources and balance retries.

Learn how the correlation pattern uses a correlation ID to tag end-to-end transactions, propagate across components from HTTP to MQ, and enable traceability with Mule.

Trace and propagate correlation IDs across Mule applications using HTTP listeners, VM connectors, and Anypoint MQ, with a custom header to ensure end-to-end ID consistency and log visibility.

Master logging and tracing in Mule apps with standard log patterns and the tracing module, enriching logs via mapped diagnostic context and correlation IDs.

Learn to propagate a correlation ID across any point MQ using publisher user properties and the tracing module for end-to-end traceability.

Apply the Mule tracing module to implement mapped diagnostic context and enrich logs with MDC variables such as bid, booking id, and character id.

Explore how the validation module enforces API message quality by validating XML and JSON payloads against schemas, handling pre/post conditions and custom errors, and applying US tolerant reader principles.

Configure a validation module to verify non-null payloads, validate the content type is application/json, and handle errors with a 400 bad request and descriptive messages.

Learn to validate JSON payloads with a JSON module by creating and applying JSON schemas, handling errors, and enforcing additional properties to ensure strict schema compliance.

Learn how to configure an XML module in MuleSoft's mail application to validate XML payloads with a schema, generate the schema from an example, and handle errors with 400 responses.

Covers history-type callbacks, VM-based synchronous message processing with anypoint mq connectors, circuit breaker, and correlation id propagation, while validating payloads with XML and JSON modules and tracing-enabled logging.

Configure health endpoints for mail app and explore liveness and readiness. Build meal library for local maven repo, publish XML SDK module connector to any point exchange, and monitor mural.

Learn how health endpoints validate an application's status with liveness and readiness probes, and configure API monitoring to verify dependencies and traffic readiness.

Configure health endpoints in the MuleSoft mail application with liveness and readiness probes, validate HTTP responses, set timeouts, and monitor downstream API readiness for reliable traffic routing.

Create a MuleSoft shared library of reusable flows for logging, error handling, and common business logic; build, install to a local Maven repo or Exchange, and import into applications.

Create a new module as a shared library, migrate health endpoints and error handlers to the common library, and install the library to the local Maven repository.

Configure the shared library in a Mule app by adding dependency coordinates and the classifier plugin, pulling from the local Maven repo, and importing health and error libraries for readiness.

Learn to create a Mule XML SDK custom connector, generate a project with archetype, configure operations, input/output, and error mapping, and deploy via Maven to Exchange, including catalog usage.

Generate a custom connector with mule xml sdk by configuring maven settings, running the maven generate command, and importing the generated liveness check project into any point studio.

Add business logic to the XML SDK by defining dependencies, namespaces, and a liveness check operation, configuring HTTP requests with user-supplied URL and timeout, and mapping errors.

Configure the xml sdk connector as a dependency in a mule app using maven coordinates, then replace request connectors with the new custom connector and test the ready endpoint.

Map the custom error mapping for a newly created custom character, use catalogs and json schemas, and deploy the xml sdk liveness check connector to any point exchange via maven.

Set up API monitoring by creating a named monitor with location and schedule; add endpoints with status code assertions, enable notifications, and view monitor history.

Monitor your API health with external API monitoring, scheduling checks from multiple regions to validate /live and /ready endpoints, and send failure alerts to Slack or email.

Review liveness and readiness probes, expose health endpoints in a mail app, publish a library to maven repo, and create an XML SDK connector monitored by external API monitoring tool.

Develop a custom api policy from scratch and apply it using api manager and within any point studio to enhance api governance.

Learn how to create and deploy custom API policies using a Maven archetype, configure YAML, and use handlebars to build dynamic policy logic that logs client location details for APIs.

Generate a project skeleton for a customer policy using the Mule Maven archetype, configure the archetype repository profile, and customize the log client location policy description.

Log the client location by resolving the IP with an external API and log key details. Package the custom API policy using the YAML specification and a template.

Deploy a custom api policy to any point exchange, configure it in api manager, and verify client logging from the x-forwarded-for header.

Learn to implement custom offline policies in the Mule runtime, including prerequisites, packaging as a deployable jar, and configuring or removing them via a JSON file.

Apply an offline policy in Anypoint Studio by copying the custom policy jar to the Mule home directory, defining a JSON policy, deploying, testing, and removing it as needed.

Modify a custom api policy with handlebar logic, add optional hardcoded logging, and a choice router in the template; package, deploy to exchange, and validate logs in api manager.

Complete section five by generating a custom API policy, packaging and deploying to any point exchange, and applying it via the API manager with offline policies mode and handlebars options.

Learn to consume soap web services with the web consumer connector, configure tailored certificates, and deploy the soap system APIs to a mule force channel for demo.

Discover how to consume a soap web service in MuleSoft using TLS certificates, configure TLS in the HTTP request connector, and enable mutual authentication in the web service connector.

Demonstrates creating public/private key pairs and self-signed certificates for server and client in JCS (and PKCS) formats, exporting certificates, and importing into client trust stores to enable mutual authentication.

Import and deploy a soap system api to a standalone server, then build a process api that consumes it over plain http, test the addition operation using a calculator service.

Learn to generate server keys, create keystores and trust stores, configure one-way TLS for a SOAP service, deploy to a standalone server, and test TLS with the process API.

Learn to implement mutual authentication for a soap service by generating and configuring client key stores and server trust stores, and deploying secure two-way tls between rest and soap systems.

Review section six and confirm completed topics like creating packages and distributing keys and certificates, and TLS mutual authentication with a soap web service; remaining topics for section seven.

Explore am unit testing in section seven by configuring immunity, writing immune test cases with event data, and verifying calls and processor data, then automate immunity with HM Unit Ricardo.

Explore MUnit basics to isolate Mule code, test integrations and APIs with automated unit tests, and review detailed coverage reports.

Import and inspect a Mule app in Anypoint Studio, explore its three external rest API calls and private flows, and prepare for MUnit testing with a transform that combines responses.

Configure MUnit for a Mule app, add a startup test, and run it to verify the environment value is set, using the unit maven plugin and related dependencies.

Create and run a MUnit test using the set event to load a JSON payload from resources and set query parameters for a success scenario, then check coverage.

Add two MUnit assertions to verify the payload is not null and the payload name is correctly concatenated. Use assert that with equals and review failures to confirm the fix.

Learn how to mock external services in MuleSoft MUnit by marking request and response payloads, creating json mocks, and asserting mashup results.

Demonstrates using MUnit's verify call to ensure external HTTP connectors are executed only once, by selecting the processor and asserting counts such as equals one, at most, or at least.

In this hands-on session, use MUnit spy scope to assert the input and output payloads around an external http call, spying a specific processor's request and response.

Refactor MUnit tests by externalizing mock data into data files and variables in test resources, and extract a subflow for mocks to boost reuse and 80% coverage.

Master MUnit error testing by mocking errors, propagating on error, and validating error handling with test cases, expected error types, and coverage insights.

Explore how the MUnit Maven Plugin enables unit testing in a continuous integration environment, with configurable coverage levels (application, resource, and floor), optional fail builds, and diverse report formats.

Learn to run mUnit tests with the Maven plugin and diagnose failures caused by missing embedded containers, by configuring MuleSoft enterprise repository credentials in Maven settings.

Record and automate unit tests with the MUnit recorder by capturing a flow's request and response data, generating tests automatically, and configuring marks, verifications, and spies.

Learn to automatically generate MUnit test cases for a flow with the MUnit Recorder, configuring inputs, mocks, and assertions, and deploying to validate tests.

Complete section seven by configuring a multiplication unit test, creating manual test cases with set event mock and spy processor, refactoring unit data for reusable code, and automating with unit-recorder.

Secure an API proxy with inbound and outbound TLS using sacred groups, key stores, and trust stores to enable end-to-end encryption between consumer and application.

Build and deploy an https api proxy, configuring inbound and outbound tls contexts via secret groups, using trust stores and key stores to trust a self-signed backend certificate.

Enable API security with a gatekeeper that blocks access during policy download and enforces rate limiting and client verification. Choose disabled, flexible, or strict modes to manage gatekeeper behavior.

Demonstrate gatekeeper flexible mode with no local policy cache by configuring api discovery, deploying an api proxy, and observing 503 service unavailable when connectivity or policies are missing.

Configure API discovery and API manager credentials to start the gatekeeper in disabled mode with no local policy cache, allowing unsecured calls until policies download and enforcement begins.

Configure gatekeeper in flexible mode with a local policy cache; it enforces policies from the cache and initially blocks requests with 503, then unblocks when the local policy applies.

Configure gatekeeper to start in strict mode with API manager credentials; the gateway blocks calls until policies load from the local cache or are fetched, then the API unblocks.

Explore Gatekeeper strict mode with a local policy cache, block APIs without API manager credentials, and observe 503 responses until the AnyPoint Platform reconnects and downloads policies.