MuleSoft-Integration-Architect-I Salesforce Certified MuleSoft Platform Integration Architect (Mule-Arch-202) Questions and Answers

In Anypoint Exchange, policies are the asset type that represents configuration modules extending the functionality of an API and enforcing capabilities such as security. Policies can be applied to APIs to control access, apply throttling, manage security, and other aspects that modify or extend the behavior of APIs.

Rulesets, REST APIs, and connectors serve different purposes within the Anypoint Platform. Rulesets are used for validation or routing decisions. REST APIs define the endpoints and methods for API interactions, and connectors enable connectivity to various systems and services. Only policies are specifically designed to enforce additional capabilities on APIs.

References

MuleSoft Anypoint Platform Documentation on API Policies

Anypoint Exchange Overview

Understanding the Operations:

The Finance operation can only look up one account record at a time.

The Audit operation can only insert one account record at a time.

Parallel For-Each Scope:

Finance Operation: Use a Parallel For-Each scope to process multiple account lookups simultaneously.

This improves performance by allowing concurrent processing of account records, leveraging parallelism.

Async Scope:

Audit Operation: Use an Async scope to handle the insertion of account records independently.

The Async scope ensures that the Audit operation does not block the main processing flow, allowing other processes to continue without waiting for the Audit operation to complete.

Performance Optimization:

Combining Parallel For-Each for the Finance operation and Async scope for the Audit operation maximizes throughput.

This approach ensures efficient use of resources and reduces latency by parallelizing account lookups and asynchronously handling audit inserts.

MuleSoft Documentation on Scopes: Mule Scopes

MuleSoft Best Practices for Performance: Performance Best Practices

A design-first approach in API development focuses on creating a detailed API specification before any implementation begins. This specification acts as a contract that defines the API's endpoints, request/response formats, and error codes. By developing this specification early, potential consumers can provide feedback, and testing can be conducted against mock implementations to ensure the API meets their needs. This approach helps identify issues early in the development process, improving the likelihood of successful implementation and adoption.

Explanation

* "Create a Mule domain project that maintains the credentials as Mule domain-shared resources" is wrong as domain project is not supported in Cloudhub * We should Avoid Creating duplicates in each Mule application but below two options cause duplication of credentials - Store the credentials in properties files in a shared folder within the organization’s data center. Have the Mule applications load properties files from this shared location at startup - Segregate the credentials for each backend system into environment-specific properties files. Package these properties files in each Mule application, from where they are loaded at startup So these are also wrong choices * Credentials service is the best approach in this scenario. Mule domain projects are not supported on CloudHub. Also its is not recommended to have multiple copies of configuration values as this makes difficult to maintain Use the Mule Credentials Vault to encrypt data in a .properties file. (In the context of this document, we refer to the .properties file simply as the properties file.) The properties file in Mule stores data as key-value pairs which may contain information such as usernames, first and last names, and credit card numbers. A Mule application may access this data as it processes messages, for example, to acquire login credentials for an external Web service. However, though this sensitive, private data must be stored in a properties file for Mule to access, it must also be protected against unauthorized – and potentially malicious – use by anyone with access to the Mule application

Explanation

Correct answer is Client Management

* Anypoint Platform acts as a client provider by default, but you can also configure external client providers to authorize client applications.

* As an API owner, you can apply an OAuth 2.0 policy to authorize client applications that try to access your API. You need an OAuth 2.0 provider to use an OAuth 2.0 policy.

* You can configure more than one client provider and associate the client providers with different environments. If you configure multiple client providers after you have already created environments, you can associate the new client providers with the environment.

* You should review the existing client configuration before reassigning client providers to avoid any downtime with existing assets or APIs.

* When you delete a client provider from your master organization, the client provider is no longer available in environments that used it.

* Also, assets or APIs that used the client provider can no longer authorize users who want to access them.

-------------------------------------------------------------------------------------------------------------MuleSoft Reference: https://docs.mulesoft.com/access-management/managing-api-clients

https://www.folkstalk.com/2019/11/mulesoft-integration-and-platform.html

The mocking service is a feature of Anypoint Platform and runs continuously. You can run the mocking service from the text editor, the visual editor, and from Anypoint Exchange. You can simulate calls to the API in API Designer before publishing the API specification to Exchange or in Exchange after publishing the API specification.

Explanation

* If your API implementation involves putting a load balancer in front of your APIkit application, configure the load balancer to redirect URLs that reference the baseUri of the application directly. If the load balancer does not redirect URLs, any calls that reach the load balancer looking for the application do not reach their destination.

* When you receive incoming traffic through the load balancer, the responses will go out the same way. However, traffic that is originating from your instance will not pass through the load balancer. Instead, it is sent directly from the public IP address of your instance out to the Internet. The ELB is not involved in that scenario.

* The question says “each API is deployed to multiple redundant Mule runtimes”, that seems to be a hint for self hosted Mule runtime cluster. Set Inbound allowed for the LB, outbound allowed for runtime to request out.

* Hence correct way is to enable communication from each API’s Mule Runtimes and Network zone to the load balancer of the other API. Because communication is asynchronous one

To determine when permissions were last changed for an Anypoint Platform user, the system administrator should use the Audit Logging component. Audit Logging in Anypoint Platform captures detailed logs of various activities, including changes to user permissions, login attempts, and other significant actions. These logs provide a historical record that administrators can review to track changes and ensure compliance with security policies.

Other components like Anypoint Monitoring, Anypoint Studio, and Mule Stack Traces are used for monitoring application performance, development, and debugging, respectively, but they do not provide specific information about user permission changes.

References

MuleSoft Documentation on Audit Logging

Anypoint Platform User Management

MuleSoft's IT delivery and operating model suggests adopting an approach that decouples core IT projects from the innovation within each line of business. This approach, often referred to as API-led connectivity, allows different lines of business to innovate and deliver projects independently by using reusable APIs that provide access to core systems and data. This decoupling enhances agility, speeds up delivery, and ensures that core IT maintains control over critical systems and data while enabling rapid innovation.

Explanation

Correct answer is Untill Successful scope can be implemented while calling backend API's The Until Successful scope repeatedly triggers the scope's components (including flow references) until they all succeed or until a maximum number of retries is exceeded The scope provides option to control the max number of retries and the interval between retries The scope can execute any sequence of processors that may fail for whatever reason and may succeed upon retry

Explanation

V2 Rest API is recommended for on premise applications to access Object Store. It also comes with overhead of encryption and security of using rest api. With Object Store v2, the API call is localized to the same data center as the Runtime Manager app.

But in this case requirement is to access the OS of other mule application and not the same mule application.

You can configure a Mule app to use the Object Store REST API to store and retrieve values from an object store in another Mule app.

However, Object Store v2 is not designed for app-to-app communication.

Explanation

* Mule High Availability Clustering provides basic failover capability for Mule. * When the primary Mule Runtime becomes unavailable, for example, because of a fatal JVM or hardware failure or it’s taken offline for maintenance, a backup Mule Runtime immediately becomes the primary node and resumes processing where the failed instance left off. * After a system administrator recovers a failed Mule Runtime server and puts it back online, that server automatically becomes the backup node. In this case, Alice, once up, will become backup ---------------------------------------------------------------------------------------------------------------------------------------------- Reference: https://docs.mulesoft.com/mule-runtime/4.3/hadr-guide So correct choice is : Files are polled form Bob node Bob is now the primary node

Explanation

Correct answer is Batch-triggered ETL Within a Mule application, batch processing provides a construct for asynchronously processing larger-than-memory data sets that are split into individual records. Batch jobs allow for the description of a reliable process that automatically splits up source data and stores it into persistent queues, which makes it possible to process large data sets while providing reliability. In the event that the application is redeployed or Mule crashes, the job execution is able to resume at the point it stopped.

Set the Anypoint MQ connector operation to publish or consume messages, or to accept (ACK) or not accept (NACK) a message.

Explanation

* Scatter-Gather is used for parallel processing, to improve performance. In this scenario, input files are coming from different vendors so mostly at different times. Goal here is to minimize the impact of future change. So scatter Gather is not the correct choice.

* If we use 1 API to receive all files from different Vendors, any new vendor addition will need changes to that 1 API to accommodate new requirements. So Option A and C are also ruled out.

* Correct answer is Create an API that receives the file and invokes a Process API with the data contained in the file, then have the Process API process the data using a MuleSoft Batch Job and other System APIs as needed. Answer to this question lies in the API led connectivity approach.

* API-led connectivity is a methodical way to connect data to applications through a series of reusable and purposeful modern APIs that are each developed to play a specific role – unlock data from systems, compose data into processes, or deliver an experience. System API : System API tier, which provides consistent, managed, and secure access to backend systems. Process APIs : Process APIs take core assets and combines them with some business logic to create a higher level of value. Experience APIs : These are designed specifically for consumption by a specific end-user app or device.

So in case of any future plans , organization can only add experience API on addition of new Vendors, which reuse the already existing process API. It will keep impact minimal.

Diagram Description automatically generated

Explanation

* Organization should continue to use SCM system of their choice, in addition to keeping source code for these asset types in Anypoint Exchange, thereby enabling parallel development, branching.

* Reason is that Anypoint exchange is not full fledged version repositories like GitHub.

* But at same time it is tightly coupled with Mule assets

Explanation

Correct answer is Perform all communication involving service S synchronously from within the For Each scope, so objects in RESP are in the exact same order as request objects in REQU Explanation : Using Anypoint MQ, you can create two types of queues: Standard queue These queues don’t guarantee a specific message order. Standard queues are the best fit for applications in which messages must be delivered quickly. FIFO (first in, first out) queue These queues ensure that your messages arrive in order. FIFO queues are the best fit for applications requiring strict message ordering and exactly-once delivery, but in which message delivery speed is of less importance Use of FIFO queue is no where in the option and also it decreased throughput. Similarly persistent object store is not the preferred solution approach when you maximizing message throughput. This rules out one of the options. Scatter Gather does not support ObjectStore. This rules out one of the options. Standard Anypoint MQ queues don’t guarantee a specific message order hence using another for each block to collect response wont work as requirement here is to ensure the order. Hence considering all the above factors the feasible approach is Perform all communication involving service S synchronously from within the For Each scope, so objects in RESP are in the exact same order as request objects in REQU

For an organization migrating its Mule applications and load balancer to CloudHub while preserving its public URL, the most straightforward and cost-effective approach involves leveraging CloudHub's shared load balancer (SLB). Here’s how to do it:

Deploying Mule Applications to CloudHub:

First, deploy your Mule applications to CloudHub. This involves packaging your Mule applications and using the Anypoint Platform to deploy them to CloudHub.

DNS Configuration:

Update your DNS settings to ensure the base URL (https://api.rutujar.com) points to the CloudHub shared load balancer. Specifically, create or update a CNAME record for api.rutujar.com to point to the CloudHub SLB 's A record.

Configuring Shared Load Balancer (SLB):

In CloudHub, configure the SLB to handle incoming traffic and route it to the appropriate Mule applications.

Apply mapping rules in the SLB to map the base URL and its paths to the corresponding Mule applications. This ensures that requests to https://api.rutujar.com are correctly routed to the specific Mule application endpoints.

Steps to Apply Mapping Rules:

In Anypoint Platform, navigate to the Runtime Manager and select the application deployed on CloudHub.

Configure the SLB settings by defining the domain and URL mappings. For instance, set rules that map requests from https://api.rutujar.com/app1 to the corresponding Mule application app1.

Benefits of Using SLB:

Cost-Effective: The shared load balancer is a more economical option compared to a dedicated load balancer (DLB).

Simplicity: Using SLB simplifies the deployment process, as it requires less configuration and management compared to setting up and maintaining a dedicated load balancer.

Consistency: Preserves the public-facing URL structure, ensuring a seamless transition for users and clients accessing the APIs.

MuleSoft Documentation on CloudHub Deployment

MuleSoft Documentation on Shared Load Balancer

By following these steps, the organization can effectively migrate its applications to CloudHub, ensuring minimal disruption and preserving the existing public URL structure.

Explanation

Correct answer is "Compile, package, unit test, validate unit test coverage, deploy" Explanation : Anypoint Platform supports continuous integration and continuous delivery using industry standard tools Mule Maven Plugin The Mule Maven plugin can automate building, packaging and deployment of Mule applications from source projects Using the Mule Maven plugin, you can automate your Mule application deployment to CloudHub, to Anypoint Runtime Fabric, or on-premises, using any of the following deployment strategies • CloudHub deployment • Runtime Fabric deployment • Runtime Manager REST API deployment • Runtime Manager agent deployment MUnit Maven Plugin The MUnit Maven plugin can automate test execution, and ties in with the Mule Maven plugin. It provides a full suite of integration and unit test capabilities, and is fully integrated with Maven and Surefire for integration with your continuous deployment environment. Since MUnit 2.x, the coverage report goal is integrated with the maven reporting section. Coverage Reports are generated during Maven’s site lifecycle, during the coverage-report goal. One of the features of MUnit Coverage is to fail the build if a certain coverage level is not reached. MUnit is not used for integration testing Also publishing to Anypoint Exchange or to create associated API instances in API Manager is not a part of CICD pipeline which can ne achieved using mulesoft provided maven plugin

Explanation

Architecture mentioned in the question can be diagrammatically put as below. Persistent Object Store is the correct answer .

* Mule Object Stores: An object store is a facility for storing objects in or across Mule applications. Mule uses object stores to persist data for eventual retrieval.

Mule provides two types of object stores:

1) In-memory store – stores objects in local Mule runtime memory. Objects are lost on shutdown of the Mule runtime. So we cant use in memory store in our scenario as we want to share watermark within all cloudhub workers

2) Persistent store – Mule persists data when an object store is explicitly configured to be persistent. Hence this watermark will be available even any of the worker goes down

Explanation

Anypoint Platform provides a scripting and command-line tool for both Anypoint Platform and Anypoint Platform Private Cloud Edition (Anypoint Platform PCE). The command-line interface (CLI) supports both the interactive shell and standard CLI modes and works with: Anypoint Exchange Access management Anypoint Runtime Manager

A. Implement HTTP caching policy for all GET endpoints for the master lookup API and implement locking to synchronize access to object store

Comprehensive Detailed Step by Step Explanation

To resolve the performance issue observed during the performance testing of the Master lookup API, the best approach involves caching and synchronization:

HTTP Caching Policy:

Purpose: Reduces the load on the database by caching the responses for GET requests. Once a response is cached, subsequent requests for the same resource can be served from the cache instead of querying the database.

Implementation: Apply the HTTP caching policy to all GET endpoints of the Master lookup API. This policy ensures that the frequently accessed master lookup data is stored in the cache and served quickly.

Benefits: This significantly reduces the number of database queries, thus lowering the response time and improving performance.

Object Store Locking:

Purpose: Ensures data consistency and prevents race conditions when multiple workers attempt to access or update the cache concurrently.

Implementation: Use a locking mechanism to synchronize access to the object store. This can be achieved by using MuleSoft’s Object Store Connector with lock/unlock operations.

Benefits: Prevents multiple database queries for the same key and ensures that only one worker updates the cache at a time, thus avoiding redundant operations and maintaining data integrity.

By implementing these two strategies, the response time of the Master lookup API will be significantly improved, and the performance issue will be resolved.

References

MuleSoft HTTP Caching Policy

MuleSoft Object Store Connector

A core pillar of the MuleSoft Catalyst delivery approach is focusing on business outcomes. This approach ensures that the integration and API strategies are aligned with the organization’s overall business objectives. By emphasizing business outcomes, MuleSoft Catalyst helps organizations realize measurable benefits such as increased efficiency, faster time to market, and improved customer experiences. This outcome-driven methodology ensures that IT initiatives deliver tangible value to the business.

SLAs and non-functional requirements to access the backend systems. Only this option actually speaks to design parameters and reqs. * Below two are technical implementations and not the part of design: - Snapshots of the Mule application’s flows, including their error handling - The credentials to access the backend systems and contact details for the administrator of each system * List of consumers is not relevant to the design

MUnit and Test Recorder:

MUnit is MuleSoft's testing framework designed to create automated tests for Mule applications.

Test Recorder in Anypoint Studio allows capturing live processing flows and events to automatically generate test cases.

Core Consideration:

While using Test Recorder, it is essential to consider how errors within the flows are handled.

If Mule errors are raised within the flows, Test Recorder will not be able to create tests for these flows, even if the errors are managed by On-Error Continue error handlers.

This limitation requires careful design and error handling strategies to ensure test cases can be recorded and executed effectively.

Error Handling in MUnit:

MUnit allows simulating error scenarios using mocks and spies.

Proper error handling within the application flow ensures robustness and reliable test creation.

However, the inability to create tests when errors are raised during recording indicates a need for alternative approaches to manage errors during test case generation.

MuleSoft Documentation on MUnit: MUnit Documentation

MuleSoft Blog on MUnit Test Recorder: MUnit Test Recorder

Object Store v2 (OSv2) in MuleSoft allows multiple applications within the same Anypoint Virtual Private Cloud (VPC) to share data. To achieve this, the OSv2 connector must be configured in each application to access the common persistent object store instance. This configuration enables the applications to read from and write to the same object store, facilitating data sharing. Object Store v2 is designed to be persistent and reliable, making it suitable for scenarios where data needs to be retained and shared across multiple applications.

MuleSoft Documentation on Object Store v2

Explanation

Correct Answer: XSD In this approach to developing a web service, you begin with an XML schema (XSD file) that defines XML data structures to be used as parameters and return types in the web service operations.

----------------------------------------------------------------------------------------------------------------- Reference: https://www.w3schools.com/xml/schema_intro.asp

Explanation

•Scatter Gather: When running within a transaction, Scatter Gather does not execute in parallel. This means that the second route is executed after the first one is processed, the third after the second one, etc. In case of error, all routes will be rolled back

Requirement Analysis: The organization needs to send email alerts to the internal operations team whenever a policy applied to an API instance is deleted in the CloudHub runtime plane.

Solution: The most effective approach is to implement a new Mule application that uses the Audit Log REST API to detect when a policy is deleted and then sends an email using the SMTP connector.

Implementation Steps:

Access Audit Logs:

Use the Anypoint Platform's Audit Log REST API to monitor and detect policy deletion events.

Example of accessing the Audit Log REST API:

GET /accounts/api/v2/organizations/{orgId}/audit-logs

This endpoint will provide logs, including events related to policy deletions.

Create Email Notification Application:

Create a Mule application that periodically polls the Audit Log REST API to check for policy deletion events.

Use the SMTP connector to send email notifications to the operations team.

Example Mule flow:

Policy deletion detected: #[payload]

Scheduler: Configures the application to check the audit logs at regular intervals (e.g., every minute).

HTTP Request: Makes a GET request to the Audit Log REST API to fetch the logs.

Choice Router: Checks if the payload contains a policy deletion event.

SMTP Connector: Sends an email to the operations team with details about the policy deletion.

Advantages:

Automation: Automates the detection of policy deletions and the notification process, reducing manual monitoring efforts.

Timeliness: Ensures the operations team is promptly informed of any policy deletions, enabling them to take immediate action if necessary.

References

MuleSoft Documentation on Audit Log REST API

MuleSoft Documentation on SMTP Connector

MuleSoft Documentation on MuleSoft Scheduler Component

Explanation

In this scenario, both A & C will work, but A is better as it does not require repackage to the domain project at all.

Correct answer is Package the HTTPS Listener configuration in a Mule DOMAIN project, referencing it from all Mule applications that need to expose an HTTPS endpoint. Store the server-side certificate in a shared filesystem location in the Mule runtime’s classpath, OUTSIDE the Mule DOMAIN or any Mule APPLICATION.

What is Mule Domain Project?

* A Mule Domain Project is implemented to configure the resources that are shared among different projects. These resources can be used by all the projects associated with this domain. Mule applications can be associated with only one domain, but a domain can be associated with multiple projects. Shared resources allow multiple development teams to work in parallel using the same set of reusable connectors. Defining these connectors as shared resources at the domain level allows the team to: - Expose multiple services within the domain through the same port. - Share the connection to persistent storage. - Share services between apps through a well-defined interface. - Ensure consistency between apps upon any changes because the configuration is only set in one place.

* Use domains Project to share the same host and port among multiple projects. You can declare the http connector within a domain project and associate the domain project with other projects. Doing this also allows to control thread settings, keystore configurations, time outs for all the requests made within multiple applications. You may think that one can also achieve this by duplicating the http connector configuration across all the applications. But, doing this may pose a nightmare if you have to make a change and redeploy all the applications.

* If you use connector configuration in the domain and let all the applications use the new domain instead of a default domain, you will maintain only one copy of the http connector configuration. Any changes will require only the domain to the redeployed instead of all the applications.

You can start using domains in only three steps:

1) Create a Mule Domain project

2) Create the global connector configurations which needs to be shared across the applications inside the Mule Domain project

3) Modify the value of domain in mule-deploy.properties file of the applications

Graphical user interface Description automatically generated

Use a certificate defined in already deployed Mule domain Configure the certificate in the domain so that the API proxy HTTPS Listener references it, and then deploy the secure API proxy to the target Runtime Fabric, or on-premises target. (CloudHub is not supported with this approach because it does not support Mule domains.)

According to MuleSoft's IT delivery and operating model, one effective approach to reduce the frequency of IT project delivery failures is to decouple central IT projects from the innovation that happens within each line of business. This approach allows individual business units to innovate and develop solutions tailored to their specific needs while the central IT team focuses on providing core services and governance. By decentralizing innovation, organizations can increase agility, reduce bottlenecks, and foster a more responsive IT environment that can quickly adapt to changing business requirements.

References

MuleSoft IT Operating Model Guidelines

Anypoint Platform Documentation on Decoupling IT Projects

Explanation

* Organization can continue using existing load balancer even if backend application changes are there. So option A is ruled out.

* As Mule runtime is within their datacenter, this model is RTF and not PCE. So option C is ruled out.

Mule runtime deployment model within their datacenter, so each Mule runtime hosts several Mule applications -- This mean PCE or Hybird not RTF - Also mentioned in Question is that - Mule runtime is hosting several Mule Application, so that also rules out RTF and as for hosting multiple Application it will have Domain project which need redesign to make it microservice architecture

---------------------------------------------------------------------------------------------------------------

Correct Answer: Required redesign of Mule applications to follow microservice architecture principles

Explanation

CloudHub supports updating your applications at runtime so end users of your HTTP APIs experience zero downtime. While your application update is deploying, CloudHub keeps the old version of your application running. Your domain points to the old version of your application until the newly uploaded version is fully started. This allows you to keep servicing requests from your old application while the new version of your application is starting.

Explanation

Correct answer is "The web store backend generates a new correlation ID value at the start of checkout and sets it on the X¬CORRELATION-ID HTTP request header in each API invocation belonging to that checkout No special code or configuration is included in the Experience API and Process API implementations to generate and manage the correlation ID" Explanation : By design, Correlation Ids cannot be changed within a flow in Mule 4 applications and can be set only at source. This ID is part of the Event Context and is generated as soon as the message is received by the application. When a HTTP Request is received, the request is inspected for "X-Correlation-Id" header. If "X-Correlation-Id" header is present, HTTP connector uses this as the Correlation Id. If "X-Correlation-Id" header is NOT present, a Correlation Id is randomly generated. For Incoming HTTP Requests: In order to set a custom Correlation Id, the client invoking the HTTP request must set "X-Correlation-Id" header. This will ensure that the Mule Flow uses this Correlation Id. For Outgoing HTTP Requests: You can also propagate the existing Correlation Id to downstream APIs. By default, all outgoing HTTP Requests send "X-Correlation-Id" header. However, you can choose to set a different value to "X-Correlation-Id" header or set "Send Correlation Id" to NEVER.

Mulesoft Reference: https://help.mulesoft.com/s/article/How-to-Set-Custom-Correlation-Id-for-Flows-with-HTTP-Endpoint-in-Mule-4

To meet the requirements of enriching logging with more context and improving throughput while reducing latency, the customer should use an asynchronous logging approach. Here's why option B is correct:

Async Logger: Asynchronous logging helps in improving the performance by decoupling the logging from the main thread of execution. This reduces the latency of message processing since logging operations are offloaded to a separate thread.

Logging Level Greater than INFO: Logging at levels such as WARN, ERROR, or FATAL ensures that only essential logs are written asynchronously, further enhancing performance. Avoiding DEBUG or TRACE levels unless necessary reduces the overhead of logging.

Pattern Layout with [%MDC]: Using the pattern layout with [%MDC] in the log4j2.xml configuration file allows the inclusion of mapped diagnostic context in the logs. MDC is a feature that provides context-specific information, such as transaction IDs or user IDs, which helps in tracing and debugging.

Example configuration in log4j2.xml:

This configuration ensures that the logs are enriched with context information provided by MDC and processed asynchronously to maintain high throughput and low latency.

References

Log4j2 Asynchronous Logging

Mapped Diagnostic Context (MDC) in Log4j2

Explanation

* Anypoint Runtime Fabric is a container service that automates the deployment and orchestration of your Mule applications and gateways.

* Runtime Fabric runs on customer-managed infrastructure on AWS, Azure, virtual machines (VMs) or bare-metal servers.

* As none of the Mule applications use Mule domain projects. applications are not required to be rewritten. Also when applications are deployed on RTF, by default ingress is allowed only on 8081.

* Hence port conflicts are not required to be managed by DevOps team

Explanation

Mule 4 is built to:

•Minimize the need for custom code.

•Avoid the need for you to know or understand Java.

However, some advanced uses cases require integration with custom Java code, such as:

•Reuse of a library, such as a tax calculation library.

•Reuse of a canonical object model that is standard in the organization.

•Execution of custom logic using Java.

Mule ref doc : https://docs.mulesoft.com/java-module/1.2/

The data format shown in the exhibit is YAML (YAML Ain't Markup Language). YAML is a human-readable data serialization standard that is commonly used for configuration files and data exchange between languages with different data structures. In the exhibit, the indentation and the use of colons to define key-value pairs are characteristic of YAML.

JSON (JavaScript Object Notation) and XML (eXtensible Markup Language) have different syntax structures, and CSV (Comma-Separated Values) is a flat file format that uses commas to separate values. The format shown in the exhibit fits the structure and style of YAML.

References

YAML Specification Documentation

MuleSoft Documentation on Supported Data Formats

To secure all internal APIs within an integration solution by using an API proxy to apply required authentication and authorization policies, the organization should use API Management (APIM). APIM provides a comprehensive platform to manage, secure, and analyze APIs. It allows the IT team to create API proxies, enforce security policies, control access through authentication and authorization mechanisms, and monitor API usage.

Using APIM for this purpose ensures that internal APIs are protected with standardized security policies, facilitating centralized management and governance of API traffic. This approach is specifically designed for managing APIs and their security, making it the most suitable choice among the options provided.

References

MuleSoft Documentation on API Management

Best Practices for API Security and Governance

When migrating from an on-premises cluster to a Runtime Fabric (RTF) cluster, and needing to enable Mule applications to store and share data across application replicas and restarts, the use of Anypoint Object Store V2 is the most suitable option. Here’s why and how to implement it:

Understanding Object Store V2:

Object Store V2 is designed to store and retrieve key-value pairs in a scalable and highly available manner. It is particularly useful for sharing state and data between different instances of applications running on RTF.

Setting Up Anypoint Object Store V2:

First, ensure that your MuleSoft Anypoint Platform account has access to Object Store V2.

Configure your Mule application to use Object Store V2 by defining an object store in your Mule configuration file. This can be done using the objectstore element in your Mule flow.

Configuration Steps:

Add the Object Store connector to your Mule project.

Define the object store configuration in your Mule flow as follows:

xml

Use the object store in your flows to store and retrieve data:

xml

Deploying on RTF:

Deploy your Mule application to the RTF cluster. The RTF will handle scaling and ensure that the Object Store V2 is available to all instances of your application.

Benefits:

Object Store V2 ensures data is shared and persisted across different application replicas and restarts, which meets the requirement of storing and sharing data across application replicas in the RTF cluster.

MuleSoft Documentation on Object Store V2

MuleSoft Documentation on Runtime Fabric

Explanation

By default, CloudHub replaces a Mule application's log4j2.xml file with a CloudHub log4j2.xml file. In CloudHub, you can disable the CloudHub provided Mule application log4j2 file. This allows integrating Mule application logs with custom or third-party log management systems

Anypoint Platform offers universal API management and Integration-Platform-as-a-Service (iPaaS) capabilities in a unified platform, meaning that it provides a single control plane to manage both full-lifecycle API management and integration. This allows organizations to easily manage their APIs and integrations, as well as deploy APIs and integrations quickly and efficiently. According to the MuleSoft Certified Integration Architect - Level 1 Course Book, “Anypoint Platform provides a unified platform for managing, deploying, and monitoring both API and integration solutions, allowing organizations to quickly and easily build and manage their APIs and integrations.”

Requirement Analysis: The Mule application needs secure access to both an on-premises database and a Kafka cluster in AWS VPC.

Solution: Setting up Anypoint VPN for the on-premises corporate data center and VPC peering with AWS VPC ensures secure and seamless connectivity.

Implementation Steps:

Anypoint VPN Setup:

In the Anypoint Platform, navigate to the VPN configuration.

Create a new VPN connection between the CloudHub VPC and the on-premises corporate data center.

Configure the necessary VPN parameters such as IP address, shared secret, and routing information.

Establish the VPN tunnel and verify connectivity.

VPC Peering Setup:

In the AWS Management Console, navigate to the VPC dashboard.

Create a VPC peering connection between the AWS VPC (where Kafka is hosted) and the CloudHub VPC.

Configure the necessary route tables to allow traffic between the peered VPCs.

Verify the peering connection and ensure that the routing is correctly set up to allow communication between the Mule application and the Kafka cluster.

Testing: Conduct thorough testing to ensure the Mule application can securely connect to both the on-premises database and the Kafka cluster in AWS.

Advantages:

Security: Ensures secure communication channels between CloudHub VPC, on-premises data center, and AWS VPC.

Reliability: Provides a robust and reliable network setup for accessing critical infrastructure components.

References

MuleSoft Documentation on Anypoint VPN

AWS Documentation on VPC Peering

Explanation

* The Object Store V2 API enables API access to Anypoint Platform Object Store v2.

* You can configure a Mule app to use the Object Store REST API to store and retrieve values from an object store in another Mule app. However, Object Store v2 is not designed for app-to-app communication. To share data between two Mule4 apps, use a queue in Anypoint MQ.

* The Object Store v2 APIs enable you to use REST to perform the following:

- Retrieve a list of object stores and keys associated with an application.

- Store and retrieve key-value pairs in an object store.

- Delete key-value pairs from an object store.

- Retrieve Object Store usage statistics for your organization.

- Object Store provides these APIs:

Object Store API

Object Store Stats API

Explanation

Correct answer is Create a mocking service that replicates the backend system’s production performance characteristics. Then configure the API implementation to use the mocking service and conduct the performance tests

* MUnit is for only Unit and integration testing for APIs and Mule apps. Not for performance Testing, even if it has the ability to Mock the backend.

* Bypassing the backend invocation defeats the whole purpose of performance testing. Hence it is not a valid answer.

* Scaled down performance tests cant be relied upon as performance of API's is not linear against load.

Explanation

* An object store is a facility for storing objects in or across Mule applications. Mule uses object stores to persist data for eventual retrieval.

* Mule provides two types of object stores:

1) In-memory store – stores objects in local Mule runtime memory. Objects are lost on shutdown of the Mule runtime.

2) Persistent store – Mule persists data when an object store is explicitly configured to be persistent.

In a standalone Mule runtime, Mule creates a default persistent store in the file system. If you do not specify an object store, the default persistent object store is used.

MuleSoft Reference: https://docs.mulesoft.com/mule-runtime/3.9/mule-object-stores

MuleSoft customers often favor a MuleSoft-hosted Anypoint Platform runtime plane over a customer-hosted runtime for the following reasons:

Reduced time-to-market for the first application (C): Using a MuleSoft-hosted runtime plane accelerates the deployment process because MuleSoft manages the infrastructure, allowing customers to focus on developing and deploying their applications quickly. This leads to faster time-to-market for the initial application and subsequent updates.

Reduced IT operations effort (E): By leveraging a MuleSoft-hosted environment, customers offload the operational responsibilities, such as infrastructure maintenance, updates, and scalability management, to MuleSoft. This reduces the IT operations workload and allows internal teams to focus on more strategic initiatives.

In contrast, other options like reduced application latency and increased application throughput are not directly influenced by whether the runtime plane is MuleSoft-hosted or customer-hosted.

References

MuleSoft Anypoint Platform Documentation

MuleSoft Hosted vs. Customer Hosted Deployment Guides

MUnit is the testing framework component of Anypoint Platform that provides test automation capabilities for customers to use in their CI/CD pipelines. MUnit allows developers to write, run, and automate unit and integration tests for Mule applications. It supports creating repeatable tests for various scenarios, ensuring that the application functions correctly and adheres to specified requirements. MUnit integrates seamlessly with Anypoint Studio, enabling efficient test creation and execution as part of the development lifecycle.

Explanation

Correct answer is EACH item VM message is processed AT LEAST ONCE by ONE ARBITRARY CloudHub worker. Each of the four CloudHub workers can be expected to process some item VM messages In Cloudhub, each persistent VM queue is listened on by every CloudHub worker - But each message is read and processed at least once by only one CloudHub worker and the duplicate processing is possible - If the CloudHub worker fails , the message can be read by another worker to prevent loss of messages and this can lead to duplicate processing - By default , every CloudHub worker's VM Listener receives different messages from VM Queue Referenece: https://dzone.com/articles/deploying-mulesoft-application-on-1-worker-vs-mult

Explanation

* Roles are business group specific. Configure identity management in the Anypoint Platform master organization. As the Anypoint Platform organization administrator, you can configure identity management in Anypoint Platform to set up users for single sign-on (SSO). * Roles and permissions can be set up at business group and organization level also. But Identity Management setup is only done at Organization level * Business groups are self-contained resource groups that contain Anypoint Platform resources such as applications and APIs. Business groups provide a way to separate and control access to Anypoint Platform resources because users have access only to the busine

According to MuleSoft’s recommended REST conventions, the HTTP method GET should be used to specify how API clients can request data from a specified resource. The GET method is designed to retrieve data from a server at the specified resource. It is one of the most common HTTP methods used in RESTful APIs, ensuring that data retrieval is performed without any side effects on the server or resource.

Explanation

Correct answer is Request size, number of requests, response size, response time Analytics API Analytics can provide insight into how your APIs are being used and how they are performing. From API Manager, you can access the Analytics dashboard, create a custom dashboard, create and manage charts, and create reports. From API Manager, you can get following types of analytics: - API viewing analytics - API events analytics - Charted metrics in API Manager

It can be accessed using: http://anypoint.mulesoft.com/analytics

API Analytics provides a summary in chart form of requests, top apps, and latency for a particular duration.

The custom dashboard in Anypoint Analytics contains a set of charts for a single API or for all APIs Each chart displays various API characteristics

– Requests size: Line chart representing size of requests in KBs

– Requests : Line chart representing number of requests over a period

– Response size : Line chart representing size of response in KBs

– Response time :Line chart representing response time in ms

* To check this, You can go to API Manager > Analytics > Custom Dashboard > Edit Dashboard > Create Chart > Metric

When deploying to Runtime Fabric, there are several tools available within the Anypoint Platform ecosystem that facilitate the deployment process. These include:

AnypointCLI: This command-line interface tool provides comprehensive capabilities for deploying applications to Runtime Fabric. Using AnypointCLI, you can script and automate deployments, which is useful for integrating into CI/CD pipelines.

Anypoint Platform REST APIs: These APIs allow for programmatic deployment and management of applications on Runtime Fabric. They provide flexibility for integrating deployment processes with other systems and tools.

Mule Maven Plugin: This plugin can be used within a Maven project to package and deploy Mule applications to Runtime Fabric as part of a build process.

However, directly uploading a JAR file from the Runtime Manager is not a supported method for deploying to Runtime Fabric.

Anypoint CLI Documentation

Mule Maven Plugin Documentation

To minimize the risk of exposing sensitive data such as credit card information while still allowing it to be converted back to its original value when necessary, tokenization is the most effective approach. Tokenization replaces sensitive data with a non-sensitive equivalent, called a token, which has no exploitable value. This method ensures that the original sensitive data is stored securely and only accessible through a secure tokenization system.

In this scenario, applying a tokenization policy at the API Gateway ensures that sensitive information is replaced with tokens before the data leaves the trusted boundary. This minimizes the risk of matching sensitive data to the original. When the original data is needed, the tokenization system can detokenize the token back to its original value securely.

MuleSoft Documentation on Tokenization

In MuleSoft's Anypoint Exchange, a complete API specification in RAML (RESTful API Modeling Language) or OAS (OpenAPI Specification) format is represented as a "REST API". This asset type provides a comprehensive description of the API, including endpoints, methods, request/response structures, and other relevant details. It serves as the blueprint for implementing and consuming the API, ensuring that all stakeholders have a clear understanding of its functionality and design.

Other asset types like connectors, API spec fragments, and SOAP APIs represent different components or partial specifications, but only REST APIs provide the full specification in the mentioned formats.

References

MuleSoft Anypoint Exchange Documentation

API Specification Documentation on RAML and OAS

A canonical data model is used in integration projects to provide a standard way of representing data across different systems and applications. The two main reasons for using a canonical data model are:

A. To have a consistent data structure aligned in processes: By using a canonical data model, you ensure that data is represented uniformly across all processes and systems. This consistency simplifies data integration, reduces transformation logic, and minimizes errors.

E. Because the model isolates the back-end systems and supports Mule applications from change: A canonical data model abstracts the underlying data structures of the back-end systems. This isolation means that changes in the back-end systems do not directly affect the Mule applications. The applications interact with the canonical model, and any required transformations are handled centrally, making the system more adaptable to changes.

Implementation Steps:

Design the Canonical Data Model:

Identify the common data elements and structures used across different systems.

Define a unified schema that represents these elements in a consistent manner.

Implement Data Transformation Logic:

Use MuleSoft DataWeave to transform data between the canonical model and the specific formats required by each system.

Centralize the transformation logic to simplify maintenance and updates.

Integrate with Mule Applications:

Ensure all Mule applications use the canonical data model for data exchange.

Modify existing applications to transform data to and from the canonical model.

Using a canonical data model improves data consistency and system flexibility, making it a valuable approach in integration projects.

Both Service Oriented Architecture (SOA) and API-led connectivity emphasize the principle of service reusability. This principle involves designing services and APIs in a way that they can be reused across different applications and use cases, reducing redundancy and improving efficiency. By creating reusable services, organizations can accelerate development, maintain consistency, and reduce costs associated with developing and maintaining multiple similar services.

In a distributed application architecture, a service mesh typically manages communication between services within the application. A service mesh provides a dedicated infrastructure layer that handles service-to-service communication, including service discovery, load balancing, failure recovery, metrics, and monitoring. This allows developers to offload these operational concerns from individual services, ensuring consistent and reliable inter-service communication.

urpose of Metadata API:

The Metadata API is specifically designed to manage customization and configuration data in Salesforce. It allows users to deploy, retrieve, create, update, or delete customization information such as custom object definitions, page layouts, and more.

Use in MuleSoft:

When using the Mule Salesforce connector in a Mule application, invoking the Metadata API enables you to programmatically manage and deploy Salesforce metadata. This is essential for tasks such as deploying new custom objects, updating existing configurations, or deleting obsolete customizations.

Why Not Other APIs:

REST API: Primarily used for accessing Salesforce data and interacting with standard and custom objects.

SOAP API: Similar to REST API but uses SOAP protocol; also mainly for data access and manipulation.

Bulk API: Designed for handling large volumes of data for insert, update, delete operations but not for metadata management.

Explanation

* When you create an Anypoint VPC, the range of IP addresses for the network must be specified in the form of a Classless Inter-Domain Routing (CIDR) block, using CIDR notation.

* This address space is reserved for Mule workers, so it cannot overlap with any address space used in your data center if you want to peer it with your VPC.

* To calculate the proper sizing for your Anypoint VPC, you first need to understand that the number of dedicated IP addresses is not the same as the number of workers you have deployed.

* For each worker deployed to CloudHub, the following IP assignation takes place: For better fault tolerance, the VPC subnet may be divided into up to four Availability Zones.

* A few IP addresses are reserved for infrastructure. At least two IP addresses per worker to perform at zero-downtime.

* Hence in this scenario 2048 IP's are required to support the requirement.

In an HTTP/1.1-compliant web service, the class of HTTP response status codes that indicates successful client requests is the 2xx class. These status codes signify that the client's request was successfully received, understood, and accepted by the web service. Common 2xx status codes include:

200 OK: The request was successful.

201 Created: The request was successful and a new resource was created.

202 Accepted: The request has been accepted for processing, but the processing is not yet complete.

Other status code classes like 3xx (redirection), 4xx (client errors), and 5xx (server errors) indicate different types of responses and do not signify successful request processing.

References

IETF RFC 2616: HTTP/1.1 Specification

HTTP Status Code Definitions

According to MuleSoft's surveys of global IT leaders, a common cause of IT project failure is a lack of alignment around business outcomes. When IT projects do not have clear business objectives or fail to align with the strategic goals of the organization, they are more likely to face challenges and fail to deliver value. Ensuring that IT initiatives are closely tied to business goals and have stakeholder buy-in is crucial for their success.

The MuleSoft-recommended best practice for sharing the connector and configuration information among multiple APIs is to use a Mule domain project. The steps are:

Create a Mule domain project.

Add the Database connector and its configuration to the domain project.

Reference this domain project from each System API that needs to use the Database connector and configuration.

By using a domain project, you centralize the configuration and reuse it across multiple APIs. This approach ensures consistency, reduces duplication, and simplifies maintenance and updates to the connector configuration.

References

MuleSoft Documentation on Domain Projects

Best Practices for Reusable Configuration in MuleSoft

To hide sensitive data exchanged between API consumers and API implementations while allowing the conversion of tokenized fields back to their original values for other API requests or responses, the best approach is to use tokenization. This involves:

Tokenization Format: Create a tokenization format that will be used to apply a tokenization policy in the API gateway. This format ensures that sensitive fields in message payloads are replaced with tokenized values that maintain a similar format, making them less recognizable as sensitive data.

Tokenization Policy: Apply a tokenization policy in the API gateway that replaces sensitive data with tokenized values.

Detokenization Policy: Apply a corresponding detokenization policy in the API gateway to convert tokenized values back to their original values when required by other APIs.

This method does not require recoding the API implementations and ensures that sensitive data is protected while still being accessible in its original form when necessary.

References

MuleSoft Documentation on Tokenization Policies

API Gateway Security Best Practices

Explanation

As the stakeholders are semitechnical users , preferred option is Create Anypoint Exchange entries with pages elaborating the integration design, including API notebooks (where applicable) to help the stakeholders understand and interact with the Mule applications and APIs at various levels of technical depth

Mule Tracing Module and MDC:

The Mule Tracing module enhances logging by adding context-specific information to logs using Mapped Diagnostic Context (MDC).

MDC allows including additional metadata in logs, making it easier to trace and debug issues in the application.

Set Logging Variable Operations:

In Mule flows, before any Core Logger components, add Set logging variable operations from the Mule Tracing module.

This ensures that the contextual information is set before logs are written.

Configuring log4j2.xml:

Update the log4j2.xml file to change the appender's pattern layout to include %MDC placeholders.

Assign the appender to either a Logger or the Root element to ensure that logs across the application include the MDC-enriched information.

Improving Throughput and Lowering Latency:

Using MDC with %MDC placeholders ensures that enriched logging does not significantly impact performance.

This setup improves logging detail while maintaining efficient message processing.

MuleSoft Documentation on Mule Tracing: Mule Tracing Module

Log4j2 Documentation on MDC: Log4j2 MDC

Explanation

Object Store Connector is a Mule component that allows for simple key-value storage. Although it can serve a wide variety of use cases, it is mainly design for: - Storing synchronization information, such as watermarks. - Storing temporal information such as access tokens. - Storing user information. Additionally, Mule Runtime uses Object Stores to support some of its own components, for example: - The Cache module uses an Object Store to maintain all of the cached data. - The OAuth module (and every OAuth enabled connector) uses Object Stores to store the access and refresh tokens. Object Store data is in the same region as the worker where the app is initially deployed. For example, if you deploy to the Singapore region, the object store persists in the Singapore region. MuleSoft Reference : https://docs.mulesoft.com/object-store-connector/1.1/ Data can be shared between different instances of the Mule application. This is not recommended for Inter Mule app communication. Coming to the question, object store cannot be used to share cached data if it is deployed as separate Mule applications or deployed under separate Business Groups. Hence correct answer is When there is one CloudHub deployment of the API implementation to three workers that must share the cache state.

When a RAML definition is updated and a new version is published to Anypoint Exchange, the client applications that consume the API need to be updated to utilize the new operations. Here’s how the Mule application team can achieve this:

Access Anypoint Exchange:

Go to Anypoint Exchange and find the updated RAML definition of the API.

Update the REST Connector:

In the Mule application, locate the existing REST connector that was generated from the previous version of the API.

Update this connector to the latest version by reimporting the RAML definition.

This can be done via the Anypoint Studio by navigating to the Mule Palette, finding the REST connector, and updating it with the new RAML.

Regenerate Client Code (If Necessary):

Sometimes, updating the connector may require regenerating the client code to include new operations.

Ensure that all new methods and endpoints are available in your Mule application after the update.

Test New Operations:

Incorporate and test the new operations in the Mule application to ensure they function correctly with the updated API implementation.

References

MuleSoft Documentation: API Development

Anypoint Studio Documentation: Using Connectors

Explanation

Below Anypoint Connectors support transactions ● JMS – Publish – Consume ● VM – Publish – Consume ● Database – All operations

Explanation

Correct answer is By default, the Anypoint CLI and Mule Maven plugin are not included in the Mule runtime Maven is not part of runtime though it is part of studio. You do not need it to deploy in order to deploy your app. Same is the case with CLI.

Explanation

* Shared load balancers don’t allow you to configure custom SSL certificates or proxy rules

* Dedicated Load Balancer are optional but you need to purchase them additionally if needed.

* TLS is a cryptographic protocol that provides communications security for your Mule app. TLS offers many different ways of exchanging keys for authentication, encrypting data, and guaranteeing message integrity.

* The CloudHub Shared Load Balancer terminates TLS connections and uses its own server-side certificate.

* Only a DLB allows the configuration of a custom TLS server certificate

* DLB enables you to define SSL configurations to provide custom certificates and optionally enforce two-way SSL client authentication.

* To use a DLB in your environment, you must first create an Anypoint VPC. Because you can associate multiple environments with the same Anypoint VPC, you can use the same dedicated load balancer for your different environments.

* MuleSoft Reference: https://docs.mulesoft.com/runtime-manager/dedicated-load-balancer-tutorial

Additional Info on SLB Vs DLB:

Explanation

* Object Store and VM Store is used for sharing data inter or intra mule applications in same setup. Can't be used with external Business Partner

* Also File connector will not be useful as the two companies currently have no shared IT infrastructure. It's specific for local use.

* Correct answer is SFTP connector. The SFTP Connector implements a secure file transport channel so that your Mule application can exchange files with external resources. SFTP uses the SSH security protocol to transfer messages. You can implement the SFTP endpoint as an inbound endpoint with a one-way exchange pattern, or as an outbound endpoint configured for either a one-way or request-response exchange pattern.

Explanation

Correct answer is Federated Identity Management As the Anypoint Platform organization administrator, you can configure identity management in Anypoint Platform to set up users for single sign-on (SSO). Configure identity management using one of the following single sign-on standards: OpenID Connect: End user identity verification by an authorization server including SSO SAML 2.0: Web-based authorization including cross-domain SSO Where as Client Management is where Anypoint Platform acts as a client provider by default, but you can also configure external client providers to authorize client applications. As an API owner, you can apply an OAuth 2.0 policy to authorize client applications that try to access your API. You need an OAuth 2.0 provider to use an OAuth 2.0 policy

Explanation

Security Assertion Markup Language (SAML) is an open standard that allows identity providers (IdP) to pass authorization credentials to service providers (SP).

SAML transactions use Extensible Markup Language (XML) for standardized communications between the identity provider and service providers.

SAML is the link between the authentication of a user’s identity and the authorization to use a service.

WS-Security is the key extension that supports many authentication models including: basic username/password credentials, SAML, OAuth and more.

A common way that SOAP API’s are authenticated is via SAML Single Sign On (SSO). SAML works by facilitating the exchange of authentication and authorization credentials across applications. However, there is no specification that describes how to add SAML to REST web services. 

Reference : https://www.oasis-open.org/committees/download.php/16768/wss-v1.1-spec-os-SAMLTokenProfile.pdf