MuleSoft-Integration-Architect-I Salesforce Certified MuleSoft Integration Architect 1 (SP24) Exam Questions and Answers

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

Diagram Description automatically generated

Explanation

Explanation

* It's mentioned that the API is governed by a Client ID Enforcement policy in all environments.

* Client ID Enforcement policy allows only authorized applications to access the deployed API implementation.

* Each authorized application is configured with credentials: client_id and client_secret.

* At runtime, authorized applications provide the credentials with each request to the API implementation.

MuleSoft Reference: https://docs.mulesoft.com/api-manager/2.x/polic y-mule3-client-id-based-policies

Explanation

Correct answer is Anypoint Runtime Manager

MuleSoft Anypoint Runtime Manager (ARM) provides connectivity to Mule Runtime engines deployed across your organization to provide centralized management, monitoring and analytics reporting. However, most enterprise customers find it necessary for these on-premises runtimes to integrate with their existing non MuleSoft analytics / monitoring systems such as Splunk and ELK to support a single pane of glass view across the infrastructure.

* You can configure the Runtime Manager agent to export data to external analytics tools.

Using either the Runtime Manager cloud console or Anypoint Platform Private Cloud Edition, you can:

--> Send Mule event notifications, including flow executions and exceptions, to Splunk or ELK.

--> Send API Analytics to Splunk or ELK. Sending data to third-party tools is not supported for applications deployed on CloudHub.

You can use the CloudHub custom log appender to integrate with your logging system. Reference: https://docs.mulesoft.com/runtime-manager/ https://docs.mulesoft.com/release-notes/runtime-manager-agent/runtime-manager-agent-release-notes

Diagram Description automatically generated

Additional Info:

It can be achieved in 3 steps:

1) register an agent to a runtime manager,

2) configure a gateway to enable API analytics to be sent to non MuleSoft analytics platform (Splunk for ex.) – as highlighted in the following diagram and

3) setup dashboards.

Diagram Description automatically generated

Explanation

* Correct answer is To directly reference one shared and customized log4j2.xml file from multiple Mule applications. Key word  to note in the answer is directly.

* By default, CloudHub replaces a Mule application's log4j2.xml file with a CloudHub log4j2.xml file. This specifies the CloudHub appender to write logs to the CloudHub logging service.

* You cannot modify CloudHub log4j2.xml file to add any custom appender. But there is a process in order to achieve this. You need to raise a request on support portal to disable CloudHub provided Mule application log4j2 file.

Graphical user interface, application, Word Description automatically generated

* Once this is done , Mule application's log4j2.xml file is used which you can use to send/export application logs to other log4j2 appenders, such as a custom logging system MuleSoft does not own any responsibility for lost logging data due to misconfiguration of your own log4j appender if it happens by any chance.

Graphical user interface, text, application, email Description automatically generated

* One more difference between customer-hosted Mule runtimes and CloudHub deployed mule instance is that

- CloudHub system log messages cannot be sent to external log management system without installing custom CH logging configuration through support

- where as Customer-hosted runtime can send system and application log to external log management system

MuleSoft Reference:

https://docs.mulesoft.com/runtime-manager/viewing-log-data

https://docs.mulesoft.com/runtime-manager/custom-log-appender

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

After completing the build and test activities for a Mule application that implements a System API, the team should use Runtime Manager to both deploy and monitor the System API implementation. Runtime Manager is a component of Anypoint Platform that provides capabilities for deploying, managing, and monitoring Mule applications and APIs. It allows teams to manage applications and APIs across various environments, ensuring they operate correctly and efficiently.

References:

• Anypoint Runtime Manager
• Deploying and Managing Applications with Runtime Manager

Explanation

Connected Apps

The Connected Apps feature provides a framework that enables an external application to integrate with Anypoint Platform using APIs through OAuth 2.0 and OpenID Connect. Connected apps help users delegate their access without sharing sensitive credentials or giving full control of their accounts to third parties. Actions taken by connected apps are audited, and users can also revoke access at any time. Note that some products do not currently include client IDs in this release of the Connected Apps feature. The Connected Apps feature enables you to use secure authentication protocols and control an app’s access to user data. Additionally, end users can authorize the app to access their Anypoint Platform data.

Mule Ref Doc : https://docs.mulesoft.com/access-management/connected-apps-overview

Explanation

As the question says that data needs to be sent across multiple sftp serves , we cannot use non-repeatable streams. The non-repeatable strategy disables repeatable streams, which enables you to read an input stream only once.

You cant use in memory storage because with 0.2 vcore you will get only 1 GB of heap memory. Hence application will error out for file more than 1 GB.

Hence the correct option is file base repeatable stream

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

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

* Sharing Mule applications as templates is a great way to share your work with other people who are in your organization in Anypoint Platform. When they need to build a similar application they can create the mule application using the template project from Anypoint studio.

* Anypoint Templates are designed to make it easier and faster to go from a blank canvas to a production application. They’re bit for bit Mule applications requiring only Anypoint Studio to build and design, and are deployable both on-premises and in the cloud.

* Anypoint Templates are based on five common data Integration patterns and can be customized and extended to fit your integration needs. So even if your use case involves different endpoints or connectors than those included in the template, they still offer a great starting point. 

Some of the best practices while creating the template project: - Define the common error handler as part of template project, either using pom dependency or mule config file - Define common logger/audit framework as part of the template project - Define the env specific properties and secure properties file as per the requirement - Define global.xml for global configuration - Define the config file for connector configuration like Http,Salesforce,File,FTP etc - Create separate folders to create DWL,Properties,SSL certificates etc - Add the dependency and configure the pom.xml as per the business need - Configure the mule-artifact.json as per the business need

Explanation

* If you need to scale a JMS provider/ message broker, - add nodes to scale it horizontally or - add memory to scale it vertically * Cons of adding another JMS provider/ message broker: - adds cost. - adds complexity to use two JMS brokers - adds Operational overhead if we use two brokers, say, ActiveMQ and IBM MQ * So Two options that mention to use two brokers are not best choice. * It's mentioned that "The Fulfillment microservice consumes Order messages, fulfills the order described therein, and then publishes an OrderFulfilled message. Each OrderFulfilled message can be consumed by any interested Mule application." - When you publish a message on a topic, it goes to all the subscribers who are interested - so zero to many subscribers will receive a copy of the message. - When you send a message on a queue, it will be received by exactly one consumer. * As we need multiple consumers to consume the message below option is not valid choice: "Order messages are sent to an Anypoint MQ exchange. OrderFulfilled messages are sent to an Anypoint MQ queue. Both microservices interact with Anypoint MQ as the message broker, which must therefore scale to support the load of both microservices" * Order messages are only consumed by one Mule application, the Fulfillment microservice, so we will publish it on queue and OrderFulfilled message can be consumed by any interested Mule application so it need to be published on Topic using same broker. * Correct Answer: Best choice in this scenario is: "Order messages are sent to a JMS queue. OrderFulfilled messages are sent to a JMS topic. Both microservices interact with the same JMS provider (message broker) instance, which must therefore scale to support the load of both microservices" Tried to depict scenario in diagram:

Diagram Description automatically generated

Explanation

Lets analyze the situation in regards to the different options available Option : A common Experience API but separate Process APIs Analysis : This solution will not work because having common experience layer will not help the purpose as mobile and web applications will have different set of requirements which cannot be fulfilled by single experience layer API

Option : Common Process API Analysis : This solution will not work because creating a common process API will impose limitations in terms of flexibility to customize API;s as per the requirements of different applications. It is not a recommended approach.

Option : Separate set of API's for both the applications Analysis : This goes against the principle of Anypoint API-led connectivity approach which promotes creating reusable assets. This solution may work but this is not efficient solution and creates duplicity of code.

Hence the correct answer is: Separate Experience APIs for the mobile and web app, but a common Process API that invokes separate System APIs created for the database and CRM system

A screenshot of a computer Description automatically generated with low confidence

Lets analyze the situation in regards to the different options available Option : A common Experience API but separate Process APIs Analysis : This solution will not work because having common experience layer will not help the purpose as mobile and web applications will have different set of requirements which cannot be fulfilled by single experience layer API

Option : Common Process API Analysis : This solution will not work because creating a common process API will impose limitations in terms of flexibility to customize API;s as per the requirements of different applications. It is not a recommended approach.

Option : Separate set of API's for both the applications Analysis : This goes against the principle of Anypoint API-led connectivity approach which promotes creating reusable assets. This solution may work but this is not efficient solution and creates duplicity of code.

Hence the correct answer is: Separate Experience APIs for the mobile and web app, but a common Process API that invokes separate System APIs created for the database and CRM system

Diagram Description automatically generated

The interaction composition pattern used by the integration architect for the order processing API that coordinates stateful interactions with various microservices is called orchestration. Orchestration involves managing and coordinating multiple services to achieve a specific business process or workflow. In this case, the order processing API is responsible for validating, creating, and fulfilling new product orders by coordinating interactions with different microservices.

Orchestration provides a centralized control mechanism where the order processing API acts as the orchestrator, handling the sequence of service calls, managing state, and ensuring that the business process is executed correctly.

References

• MuleSoft API-led Connectivity Approach
• Patterns for Microservices and API Design

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

To design a caching strategy that queries the database only when there is an update to the Employees table, follow these steps:

• On Table Row Operation: Configure an On Table Row operation to monitor the Employees table for updates.
• Invalidate Cache: When the On Table Row operation detects an update, trigger the invalidate cache operation to clear the cache.
• Object Store Caching Strategy: Use an object-store-caching-strategy to store the cached responses.
• Default Expiration Interval: Use the default expiration interval for the cache, which ensures that cached data is invalidated based on the detection of changes in the Employees table rather than a fixed time interval.

This strategy ensures that the cache is only invalidated when there are actual changes in the Employees table, thereby minimizing redundant transactions and optimizing database performance.

References

• MuleSoft Documentation on Caching Strategies
• Best Practices for Database Integration with MuleSoft

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

* 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 Application A accesses the persistent object store via the Object Store REST API Application B uses the Object Store connector to access a persistent object * Object Store v2 lets CloudHub applications store data and states across batch processes, Mule components and applications, from within an application or by using the Object Store REST API. * On-premise Mule applications cannot use Object Store v2. * You can select Object Store v2 as the implementation for Mule 3 and Mule 4 in CloudHub by checking the Object Store V2 checkbox in Runtime Manager at deployment time. * CloudHub Mule applications can use Object Store connector to write to the object store * The only way on-premises Mule applications can access Object Store v2 is via the Object Store REST API. * 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.

An application load balancer routes requests to a RESTful web API secured by Anypoint Flex Gateway using the HTTPS protocol. HTTPS (HyperText Transfer Protocol Secure) ensures that the communication between the load balancer and the gateway is encrypted and secure, protecting the data from eavesdropping and tampering. HTTPS is the standard protocol for secure communication over the internet, especially for APIs handling sensitive data.

References:

• Securing APIs with HTTPS
• Understanding HTTPS

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

• Requirements:
• Persistent VM Queues:
• MuleSoft Best Practices:
• Configuration in Runtime Manager:

References:

• MuleSoft Documentation on VM Queues: VM Queues
• MuleSoft Best Practices: MuleSoft Best Practices
• CloudHub Deployment Guide: CloudHub Deployment

Explanation

Types of logging:

A) Synchronous: The execution of thread that is processing messages is interrupted to wait for the log message to be fully handled before it can continue.

● The execution of the thread that is processing your message is interrupted to wait for the log message to be fully output before it can continue

● Performance degrades because of synchronous logging

● Used when the log is used as an audit trail or when logging ERROR/CRITICAL messages

● If the logger fails to write to disk, the exception would raise on the same thread that's currently processing the Mule event. If logging is critical for you, then you can rollback the transaction.

Chart, diagram Description automatically generated

Chart, diagram, box and whisker chart Description automatically generated

B) Asynchronous:

● The logging operation occurs in a separate thread, so the actual processing of your message won’t be delayed to wait for the logging to complete

● Substantial improvement in throughput and latency of message processing

● Mule runtime engine (Mule) 4 uses Log4j 2 asynchronous logging by default

● The disadvantage of asynchronous logging is error handling.

● If the logger fails to write to disk, the thread doing the processing won't be aware of any issues writing to the disk, so you won't be able to rollback anything. Because the actual writing of the log gets differed, there's a chance that log messages might never make it to disk and get lost, if Mule were to crash before the buffers are flushed.

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

So Correct answer is: Asynchronous logging can improve Mule event processing throughput while also reducing the processing time for each Mule event

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

• Mocking REST API Invocations:
• Achieving Test Coverage:
• Execution of MUnit Tests:

References:

• MuleSoft Documentation on MUnit Testing
• Best practices for Mocking in MUnit

In a microservices architecture, a service mesh manages the communication between microservices. This involves handling service discovery, load balancing, failure recovery, metrics, and monitoring. Service meshes also provide more complex operational requirements like A/B testing, canary releases, rate limiting, access control, and end-to-end authentication. By abstracting these functionalities away from individual microservices, a service mesh allows developers to focus on business logic while ensuring reliable and secure inter-service communication.

References:

• Understanding Service Mesh
• Service Mesh for Microservices

In this business scenario, the supplier needs to deliver two fundamental integration use cases to provide an end-to-end solution:

A. Synchronized data transfer: This involves ensuring that the customer’s purchase orders (sent using ANSI X12 EDI standard) are accurately and timely transferred and reflected in the supplier’s ERP system. This synchronization ensures data consistency between the EDI transactions and the ERP system.

B. Sharing data with external partners: This involves providing the customer with a RESTful API to access current product inventory levels from the supplier’s ERP system. Sharing data through a RESTful API allows the customer to retrieve up-to-date inventory information as needed.

References:

• EDI Integration with APIs
• Integrating with External Partners Using APIs

Explanation

Correct answer is Workers are randomly distributed across available AZs within that region. This ensure high availability for deployed mule applications Mulesoft documentation reference :

https://docs.mulesoft.com/runtime-manager/cloudhub-hadr

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.

References:

• API Design Best Practices
• Design-First API Development

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.

References:

• MuleSoft's API-led Connectivity Approach
• Service-Oriented Architecture (SOA) Principles

To track the entire lifecycle of each request across different microservices, the DevOps team should consider adopting tracing. Distributed tracing allows teams to follow a request as it travels through the various microservices, providing visibility into how long each part of the request lifecycle takes and where any bottlenecks or failures occur. Tools like Zipkin, Jaeger, and AWS X-Ray are commonly used for this purpose. Tracing complements metrics and logging by providing detailed insights into the interactions and dependencies between services.

References:

• Distributed Tracing in Microservices
• What is Distributed Tracing?

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

To ensure the high availability and reliability of critical APIs, it is essential to monitor their liveliness and readiness. Anypoint Monitoring provides comprehensive monitoring capabilities for Mule applications. Here’s how it can be implemented:

• Application Monitoring: Enable monitoring for each individual Mule application. This allows for real-time visibility into the performance and health of each API.
• Custom Dashboards: Create custom dashboards in Anypoint Monitoring to track key metrics such as response time, error rates, and throughput.
• Alerts and Notifications: Configure alerts based on specific failure conditions or performance thresholds. These alerts can notify the Ops team immediately when an outage or performance degradation is detected.
• Proactive Management: With detailed insights and proactive alerts, the Ops team can quickly respond to issues, ensuring that the APIs remain available and meet the defined SLAs.

References:

• Anypoint Monitoring
• Configuring Alerts

The advantage of using OAuth 2.0 client credentials and access tokens over only API keys for API authentication is that if the access token is compromised, the client credentials do not have to be reissued.

OAuth 2.0 is a secure protocol for authenticating clients and authorizing them to access protected resources. It works by having the client authenticate with the authorization server and receive an access token, which is then used to authenticate requests to the API. If the access token is compromised, it can be revoked and replaced without needing to reissue the client credentials.

References: MuleSoft Certified Integration Architect - Level 1 Official Text Book and Resources:

• Chapter 7: Security
• Section 7.2: OAuth 2.0

According to the National Institute of Standards and Technology (NIST), a hybrid cloud is a cloud computing deployment model that describes a composition of two or more distinct cloud infrastructures (private, community, or public) that remain unique entities but are bound together by standardized or proprietary technology that enables data and application portability. Hybrid clouds allow organizations to leverage the advantages of multiple cloud environments, such as combining the scalability and cost-efficiency of public clouds with the security and control of private clouds. This model facilitates flexibility and dynamic scalability, supporting diverse workloads and business needs while ensuring that sensitive data and applications can remain in a controlled private environment.

References

• NIST Definition of Cloud Computing
• Hybrid Cloud Overview and Benefits

Explanation

Correct answer is using below set of activities Until Successful component ActiveMQ long retry Queue ActiveMQ Dead Letter Queue for manual processing We will see why this is correct answer but before that lets understand few of the concepts which we need to know. Until Successful Scope The Until Successful scope processes messages through its processors until the entire operation succeeds. Until Successful repeatedly retries to process a message that is attempting to complete an activity such as: - Dispatching to outbound endpoints, for example, when calling a remote web service that may have availability issues. - Executing a component method, for example, when executing on a Spring bean that may depend on unreliable resources. - A sub-flow execution, to keep re-executing several actions until they all succeed, - Any other message processor execution, to allow more complex scenarios. How this will help requirement : Using Until Successful Scope we can retry sending the order to backend systems in case of error to avoid manual processing later. Retry values can be configured in Until Successful Scope Apache ActiveMQ It is an open source message broker written in Java together with a full Java Message Service client ActiveMQ has the ability to deliver messages with delays thanks to its scheduler. This functionality is the base for the broker redelivery plug-in. The redelivery plug-in can intercept dead letter processing and reschedule the failing messages for redelivery. Rather than being delivered to a DLQ, a failing message is scheduled to go to the tail of the original queue and redelivered to a message consumer. How this will help requirement : If backend application is down for a longer duration where Until Successful Scope wont work, then we can make use of ActiveMQ long retry Queue. The redelivery plug-in can intercept dead letter processing and reschedule the failing messages for redelivery. Mule Reference: https://docs.mulesoft.com/mule-runtime/4.3/migration-core-until-successful

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.

References:

• Understanding Service Mesh
• Service Mesh for Microservices

In a clustered Mule runtime environment, when using a JMS listener to consume messages from a queue destination, it is essential to ensure that messages are appropriately received by all nodes in the cluster. The configuration must support high availability and scalability. Here's why option B is correct:

• primaryNodeOnly="false": Setting this parameter to "false" ensures that the JMS listener is active on all nodes in the cluster, not just the primary node. This setting allows multiple instances of the JMS listener to run concurrently across different nodes, enabling them to consume messages from the JMS queue.
• Shared Subscription: Using a shared subscription means that all nodes will share the consumption of messages from the queue. This approach prevents duplicate message processing, as each message is delivered to only one listener instance within the cluster. This configuration ensures that message processing is balanced across the nodes, improving throughput and reliability.

To configure the JMS listener in Mule, the XML configuration might look something like this:

xml

This setup ensures that all nodes in the cluster are involved in message processing, leveraging the high availability and load balancing capabilities of the cluster.

References

• MuleSoft Documentation on JMS Listener
• MuleSoft Clustering Guide

To close the IT delivery gap, MuleSoft recommends that IT organizations make their technology assets easily discoverable via a central repository. This approach ensures that existing assets, such as APIs, connectors, templates, and other reusable components, are accessible to all teams within the organization. By having a central repository, teams can quickly find and leverage these assets, reducing duplication of effort, speeding up project delivery, and fostering a culture of reuse and collaboration. This strategy aligns with the principles of an API-led connectivity approach, where reusable assets and APIs form the foundation for scalable and efficient IT delivery.

References

• MuleSoft Documentation on API-led Connectivity
• Anypoint Platform Best Practices for Asset Management

• JMS (Java Message Service): JMS is a robust messaging standard that supports reliable and asynchronous communication. It allows message producers and consumers to exchange messages via a common message broker.
• Transactions with Automatic Acknowledgements: Utilizing JMS transactions ensures that messages are processed reliably. The automatic acknowledgement mode means that once the consumer receives the message, it acknowledges the broker automatically, ensuring that no messages are lost.
• Performance and Reliability: JMS transactions offer both high performance and reliability. By enabling transactions, each message processing step can be committed or rolled back, ensuring data integrity.
• Cross-Cluster Messaging: For a stock trading company dealing with millions of trades, using JMS transactions allows for consistent and reliable message delivery across different clusters in their network. This approach is more suitable compared to non-transactional or VM queues due to the scale and reliability requirements.
• Event-Driven APIs: The APIs can leverage the transactional nature of JMS to ensure that messages exchanged between different services are reliable and can recover gracefully from failures.

References:

• MuleSoft Documentation on JMS Connector: MuleSoft JMS Connector
• JMS 2.0 Specification: Oracle JMS 2.0

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:

Table Description automatically generated

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.)

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.

Explanation

JMX Management Java Management Extensions (JMX) is a simple and standard way to manage applications, devices, services, and other resources. JMX is dynamic, so you can use it to monitor and manage resources as they are created, installed, and implemented. You can also use JMX to monitor and manage the Java Virtual Machine (JVM). Each resource is instrumented by one or more Managed Beans, or MBeans. All MBeans are registered in an MBean Server. The JMX server agent consists of an MBean Server and a set of services for handling Mbeans. There are several agents provided with Mule for JMX support. The easiest way to configure JMX is to use the default JMX support agent. Log4J Agent The log4j agent exposes the configuration of the Log4J instance used by Mule for JMX management. You enable the Log4J agent using the element. It does not take any additional properties MuleSoft Reference: https://docs.mulesoft.com/mule-runtime/3.9/jmx-management

To migrate Mule applications from CloudHub to Runtime Fabric (RTF) while maintaining the same deployment strategy using CI/CD, follow these steps:

• POM.xml Modification: Update the POM.xml file of each Mule application to include runtimeFabric deployment configurations. This ensures that the applications are packaged and prepared correctly for deployment to RTF.
• CI/CD Script Adjustments: Modify the existing CI/CD scripts to accommodate RTF-specific deployment commands and configurations. This includes updating the deployment targets and parameters to match the RTF environment.
• Deployment Strategy: Ensure that the CI/CD pipeline remains consistent with the organization’s existing strategy, but with the necessary changes to support RTF. This might involve using Anypoint CLI or API to interact with RTF.

By updating the POM.xml and CI/CD scripts, you can ensure a smooth transition from CloudHub to RTF while retaining the automated deployment process.

References:

• MuleSoft Runtime Fabric
• Mule Maven Plugin

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.

References:

• MuleSoft Documentation on Tokenization

Explanation

CloudHub object store should be in same region where the Mule application is deployed. This will give optimal performance.

Before learning about Cache scope and object store in Mule 4 we understand what is in general Caching is and other related things.

WHAT DOES “CACHING” MEAN?

Caching is the process of storing frequently used data in memory, file system or database which saves processing time and load if it would have to be accessed from original source location every time.

In computing, a cache is a high-speed data storage layer which stores a subset of data, so that future requests for that data are served up faster than is possible by accessing the data’s primary storage location. Caching allows you to efficiently reuse previously retrieved or computed data.

How does Caching work?

The data in a cache is generally stored in fast access hardware such as RAM (Random-access memory) and may also be used in correlation with a software component. A cache’s primary purpose is to increase data retrieval performance by reducing the need to access the underlying slower storage layer.

Caching in MULE 4

In Mule 4 caching can be achieved in mule using cache scope and/or object-store. Cache scope internally uses Object Store to store the data.

What is Object Store

Object Store lets applications store data and states across batch processes, Mule components, and applications, from within an application. If used on cloud hub, the object store is shared between applications deployed on Cluster.

Cache Scope is used in below-mentioned cases:

● Need to store the whole response from the outbound processor

● Data returned from the outbound processor does not change very frequently

● As Cache scope internally handle the cache hit and cache miss scenarios it is more readable

Object Store is used in below-mentioned cases:

● Need to store custom/intermediary data

● To store watermarks

● Sharing the data/stage across applications, schedulers, batch.

If CloudHub object store is in same region where the Mule application is deployed it will aid in fast access of data and give optimal performance.

To securely consume compressed and digitally signed files from a partner's FTPS server, the following inputs are required:

• PGP Public Key of the Partner:
• PGP Private Key for the Company:
• FTP Username and Password:

By using these inputs, the Mule application can securely connect to the FTPS server, verify the integrity and authenticity of the files using PGP, and decrypt the contents for further processing.

References

• MuleSoft FTPS Connector
• MuleSoft PGP Module

• Try-Catch Scope for Data Fetching:
• Async Scope for Inserting Records into Audit Database:
• Ensuring Better Throughput:

References:

• MuleSoft Documentation on Async Scope
• Best practices for Error Handling 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

* By default, Anypoint Platform performs its own user management

– For user management, one external IdP can be integrated with the Anypoint Platform organization (note: not at business group level)

– Permissions and access control are still enforced inside Anypoint Platform and CANNOT be controlled via the external Identity Provider * As the Anypoint Platform organization administrator, you can configure identity management in Anypoint Platform to set up users for single sign-on (SSO). * You can map users in a federated organization’s group to a role which also gives the flexibility of controlling the business group within Anypoint Platform to which the user belongs to. Also user can nbe removed from external identity management system when they no longer work for the organization. So they wont be able to authenticate using SSO to login to Anypoint Platform. * Using external identity we can no change permissions of a particular role in Mulesoft Anypoint platform.

* So Correct answer is Assigning Anypoint Platform permissions to a role

Explanation

Correct answer is Depending on the Listener operation configuration, either all messages are consumed by ONLY the primary cluster node or else EACH message is consumed by ANY ONE cluster node

For applications running in clusters, you have to keep in mind the concept of primary node and how the connector will behave. When running in a cluster, the JMS listener default behavior will be to receive messages only in the primary node, no matter what kind of destination you are consuming from. In case of consuming messages from a Queue, you’ll want to change this configuration to receive messages in all the nodes of the cluster, not just the primary.

This can be done with the primaryNodeOnly parameter:

For handling millions of requests per day with high performance and reliability, JMS (Java Message Service) transactions are the most suitable method. JMS transactions ensure that messages are processed reliably and can be rolled back in case of failures, providing transactional integrity. This is crucial for a trading company where reliable message processing is critical.

Using JMS transactions within Mule clusters allows for the decoupling of message producers and consumers, improving scalability and fault tolerance. JMS provides built-in mechanisms for handling transactional messaging, ensuring that messages are processed once and only once, even in the event of system failures.

References:

• MuleSoft Documentation on JMS

In a typical MuleSoft integration project, the role primarily responsible for building API implementations is the API Developer. The API Developer focuses on writing the code that implements the logic, data transformations, and business processes defined in the API specifications. They use tools like Anypoint Studio to develop and test Mule applications, ensuring that the APIs function as required and integrate seamlessly with other systems and services.

While the API Designer is responsible for defining the API specifications and the Integration Architect for designing the overall integration solution, the API Developer translates these designs into working software. The Operations team typically manages the deployment, monitoring, and maintenance of the APIs in production environments.

References

• MuleSoft Documentation on Roles and Responsibilities
• Anypoint Platform Development Best Practices

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

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

According to the National Institute of Standards and Technology (NIST), a hybrid cloud is a cloud computing deployment model that describes a composition of two or more distinct cloud infrastructures (private, community, or public) that remain unique entities but are bound together by standardized or proprietary technology that enables data and application portability. Hybrid clouds allow organizations to leverage the advantages of multiple cloud environments, such as combining the scalability and cost-efficiency of public clouds with the security and control of private clouds. This model facilitates flexibility and dynamic scalability, supporting diverse workloads and business needs while ensuring that sensitive data and applications can remain in a controlled private environment.

References

• NIST Definition of Cloud Computing
• Hybrid Cloud Overview and Benefits

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

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.”

When leveraging Anypoint MQ Audit Logs, it's important to note that they include logs for operations such as creating, deleting, modifying, and purging queues. These logs are crucial for auditing and monitoring the state and changes made to the message queues within Anypoint MQ. However, they do not include logs for individual message actions like sending, receiving, or browsing messages.

References

• MuleSoft Documentation on Anypoint MQ Audit Logs
• Anypoint Platform Audit Logging Overview

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-Endpo int-in-Mule-4

Graphical user interface, application, Word Description automatically generated

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/

• Requirement Analysis: The security team requires any external API call to be restricted by an IP include list. This ensures that only specified IP addresses can access the third-party API.
• Design Plan: To fulfill this requirement, implementing a proxy for the third-party API is the best approach. This proxy can enforce the IP include list policy.
• Implementation Steps:
• Advantages:

References

• MuleSoft Documentation on API Proxies
• MuleSoft Documentation on IP Whitelist Policy

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.

The most performant way to handle intermittent network issues with vendor applications and ensure successful transaction reprocessing is to use a combination of the Scatter-Gather scope and the Until-Successful scope. Here’s how it works:

• Scatter-Gather Scope: This scope allows you to send requests to multiple endpoints (in this case, the two vendor applications) simultaneously. This ensures that both vendors are queried at the same time, reducing overall processing time.
• Until-Successful Scope: This scope is used to implement a retry mechanism. By wrapping each route to the vendor applications with an Until-Successful scope, the flow can automatically retry the request if a timeout error occurs. This scope retries the request until it succeeds or until a specified number of retries is reached.

Implementation Steps:

• Configure a Scatter-Gather scope in your Mule application.
• Inside each route of the Scatter-Gather scope, place an Until-Successful scope.
• Configure the Until-Successful scope with appropriate retry policies, such as retry count and delay between retries.
• Inside the Until-Successful scope, configure the HTTP request to the vendor application.

This approach ensures that:

• Both vendor applications are queried in parallel.
• Each request is retried upon timeout errors, ensuring eventual success without manual intervention.

References:

• MuleSoft Documentation: Scatter-Gather
• MuleSoft Documentation: Until-Successful Scope

To improve delivery quality, a MuleSoft integration team should adopt automated testing with MUnit. MUnit is MuleSoft's testing framework that allows developers to create, design, and run unit and integration tests on their Mule applications. Automated testing with MUnit ensures that each part of the Mule application is tested for correctness and performance, catching issues early in the development cycle. This practice leads to higher quality code, reduced defects, and more reliable integrations.

Other practices mentioned, such as continuous design with API Designer and passive monitoring with Anypoint Monitoring, are important but do not directly address the need for rigorous and automated testing to ensure quality.

References

• MuleSoft Documentation on MUnit
• Best Practices for Automated Testing with MUnit

REST (Representational State Transfer) is an architectural style for designing networked applications. It supports multiple content types, including XML and JSON, making it suitable for APIs that need to handle requests from clients in both formats. RESTful APIs use standard HTTP methods (GET, POST, PUT, DELETE) and are designed to be stateless and scalable. REST's flexibility and wide adoption make it an appropriate choice for the integration architect’s requirements.

References:

• REST API Design
• Understanding RESTful API Design

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

* 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.

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.

References:

• MuleSoft REST API Design Best Practices
• HTTP Methods in RESTful Services

Explanation

* Any change in the application will require a restart except when the issue outside the app. For below situations , you would need to redeploy the code after doing necessary changes

-- One of the stored procedures being called by the Mule application has been renamed. In this case, in the Mule application you will have to do changes to accommodate the new stored procedure name.

-- Required redesign of Mule applications to follow microservice architecture principles. As code is changed, deployment is must

-- If the credentials changed and you need to update the connector or the properties.

-- The credentials for accessing the database have been updated and the previous credentials are no longer valid. In this situation you need to restart or redeploy depending on how credentials are configured in Mule application.

* So Correct answer is The database server was unavailable for four hours due to a major outage but is now fully operational again as this is the only external issue to application.

Explanation

Correct answer is IBM: CICS CRM: SOAP

* Within Anypoint Exchange, MuleSoft offers the IBM CICS connector. Anypoint Connector for IBM CICS Transaction Gateway (IBM CTG Connector) provides integration with back-end CICS apps using the CICS Transaction Gateway.

* Anypoint Connector for Salesforce Marketing Cloud (Marketing Cloud Connector) enables you to connect to the Marketing Cloud API web services (now known as the Marketing Cloud API), which is also known as the Salesforce Marketing Cloud. This connector exposes convenient operations via SOAP for exploiting the capabilities of Salesforce Marketing Cloud.

Anypoint Runtime Fabric is the appropriate choice for deploying Mule applications in an isolated Mule runtime within Docker containers on an Azure Kubernetes Service (AKS) infrastructure. This solution provides a containerized and orchestrated environment managed from the MuleSoft-hosted control plane. It enhances the availability, scalability, and robustness of Mule applications by allowing fine-grained control over deployments and providing built-in support for high availability and fault tolerance.

References:

• Anypoint Runtime Fabric Overview
• Deploying Mule Applications to Kubernetes

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.