Salesforce MuleSoft-Integration-Architect-I Test Dumps

A.   Implement a scatter-gather scope to invoke the two vendor

applications on two different route

Use the Until-Successful scope to implement the retry mechanism

for timeout errors on each route

Answer DescriptionExplanation:

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

C.   An API client creates an API consumer, which receives API invocation from an API such that they are processed for an API implementation

Answer DescriptionExplanation

The API consumer creates an API client which sends API invocations to an API such that they are processed by an API implementation This is based on below definitions API client • An application component • that accesses a service • by invoking an API of that service - by definition of the term API over HTTP API consumer • A business role, which is often assigned to an individual • that develops API clients, i.e., performs the activities necessary for enabling an API client to invoke APIs API implementation • An application component • that implements the functionality

A.   API Management (APIM)

Answer DescriptionExplanation:

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

A.   1) Read the JMS message (NOT in an XA transaction)

2) Perform BOTH DB inserts in ONE DB transaction

3) Acknowledge the JMS message

Answer DescriptionExplanation

● Option A says "Perform EACH DB insert in a SEPARATE DB transaction". In this case if first DB insert is successful and second one fails then first insert won't be rolled back causing inconsistency. This option is ruled out.

● Option D says Perform BOTH DB inserts in ONE DB transaction.

Rule of thumb is when one or more DB connections are required we must use XA transaction as local transactions support only one resource. So this option is also ruled out.

● Option B acknowledges the before DB processing, so message is removed from the queue. In case of system failure at later point, message can't be retrieved.

● Option C is Valid: Though it says "do not ack JMS message", message will be auto acknowledged at the end of transaction. Here is how we can ensure all components are part of XA transaction: https://docs.mulesoft.com/jms-connector/1.7/jms-transactions

Additional Information about transactions:

● XA Transactions - You can use an XA transaction to group together a series of operations from multiple transactional resources, such as JMS, VM or JDBC resources, into a single, very reliable, global transaction.

● The XA (eXtended Architecture) standard is an X/Open group standard which specifies the interface between a global transaction manager and local transactional resource managers.

The XA protocol defines a 2-phase commit protocol which can be used to more reliably coordinate and sequence a series of "all or nothing" operations across multiple servers, even servers of different types

● Use JMS ack if

– Acknowledgment should occur eventually, perhaps asynchronously

– The performance of the message receipt is paramount

– The message processing is idempotent

– For the choreography portion of the SAGA pattern

● Use JMS transactions

– For all other times in the integration you want to perform an atomic unit of work

– When the unit of work comprises more than the receipt of a single message

– To simply and unify the programming model (begin/commit/rollback)

D.   Must secure the service, requiring all consumers to submit a valid SAML token

Answer DescriptionExplanation

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

A.   Request-Reply

Answer DescriptionExplanation:

A synchronous invocation of a RESTful API using HTTP to get an individual customer record from a single system exemplifies the request-reply interaction pattern. In this pattern, a client sends a request to a service and waits for a response. The interaction is synchronous because the client expects an immediate reply and is blocked until it receives the response.

This pattern is common in scenarios where the client needs to retrieve specific data or perform an action that requires immediate feedback from the server, such as retrieving a customer record from a database.

References

MuleSoft Integration Patterns Documentation

Request-Reply Pattern Overview

D.   Anypoint Visualizer

Answer DescriptionExplanation:

Reference: [Reference: https://docs.mulesoft.com/visualizer/, , ]

A.   In the flows, add Mule Tracing module Set logging variable operations before any Core Logger components. In log4j2.xml files, change the appender's pattern layout to use %MDC and then assign the appender to a Logger or Root element.

Answer DescriptionExplanation:

Mule Tracing Module and MDC:

Set Logging Variable Operations:

Configuring log4j2.xml:

Improving Throughput and Lowering Latency:

References:

MuleSoft Documentation on Mule Tracing: Mule Tracing Module

Log4j2 Documentation on MDC: Log4j2 MDC

D.   Database

Answer DescriptionExplanation:

Reference: [Reference: https://docs.mulesoft.com/mule-runtime/4.4/reconnection-strategy-about, , ]

A.   Build a Mule domain project, add the Database connector and configuration to it, and reference this one domain project from each System API

Answer DescriptionExplanation:

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