Pass the Salesforce MuleSoft MuleSoft-Integration-Architect-I Questions and answers with ValidTests

Explanation

* As per definition of API by Mulesoft , it is Application Programming Interface using HTTP-based protocols. Non-HTTP-based programmatic interfaces are not APIs.

* HTTP-based programmatic interfaces are APIs even if they don’t use REST or JSON. Hence implementation based on Java RMI, CORBA/IIOP, raw TCP/IP interfaces are not API's as they are not using HTTP.

* One more thing to note is FTP was not built to be secure. It is generally considered to be an insecure protocol because it relies on clear-text usernames and passwords for authentication and does not use encryption.

* Data sent via FTP is vulnerable to sniffing, spoofing, and brute force attacks, among other basic attack methods.

Considering the above points only correct option is

-XML over ActiveMQ

- XML over SFTP

- XML/REST over HTTPS

Explanation

Before we answer this question , we need to understand what median (50th percentile) and 80th percentile means. If the 50th percentile (median) of a response time is 500ms that means that 50% of my transactions are either as fast or faster than 500ms.

If the 90th percentile of the same transaction is at 1000ms it means that 90% are as fast or faster and only 10% are slower. Now as per upstream SLA , 99th percentile is 800 ms which means 99% of the incoming requests should have response time less than or equal to 800 ms. But as per one of the backend API , their 95th percentile is 1000 ms which means that backend API will take 1000 ms or less than that for 95% of. requests. As there are three API invocation from upstream API , we can not conclude a timeout that can be set to meet the desired SLA as backend SLA's do not support it.

Let see why other answers are not correct.

1) Do not set a timeout --> This can potentially violate SLA's of upstream API

2) Set a timeout of 100 ms; ---> This will not work as backend API has 100 ms as median meaning only 50% requests will be answered in this time and we will get timeout for 50% of the requests. Important thing to note here is, All APIs need to be executed sequentially, so if you get timeout in first API, there is no use of going to second and third API. As a service provider you wouldn't want to keep 50% of your consumers dissatisfied. So not the best option to go with.

*To quote an example: Let's assume you have built an API to update customer contact details.

- First API is fetching customer number based on login credentials

- Second API is fetching Info in 1 table and returning unique key

- Third API, using unique key provided in second API as primary key, updating remaining details

* Now consider, if API times out in first API and can't fetch customer number, in this case, it's useless to call API 2 and 3 and that is why question mentions specifically that all APIs need to be executed sequentially.

3) Set a timeout of 50 ms --> Again not possible due to the same reason as above Hence correct answer is No timeout is possible to meet the upstream API's desired SLA; a different SLA must be negotiated with the first downstream API or invoke an alternative API

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/

To conduct performance testing in a non-production environment where rate limits are enforced, the most cost-effective approach is:

C. Create a Mocking service that replicates the back-end system's production performance characteristics. Then configure the API implementation to use the mocking service and conduct the performance test.

Mocking Service: Develop a mock service that emulates the performance characteristics of the production back-end system. This service should mimic the response times, data formats, and any relevant behavior of the actual back-end system without imposing rate limits.

Configuration: Modify the API implementation to route requests to the mocking service instead of the actual back-end system. This ensures that the performance tests are not impacted by the rate limits imposed in the non-production environment.

Performance Testing: Conduct the performance tests using the API implementation configured with the mocking service. This approach allows you to assess the performance under expected production load conditions without being constrained by non-production rate limits.

This method ensures that performance testing is accurate and reflective of the production environment without additional costs or constraints due to rate limiting in staging environments.

References:

MuleSoft Documentation: Mocking Services

MuleSoft Documentation: Performance Testing

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

When an API client makes an HTTP request to an API gateway with an Accept header containing the value "application/json", the valid HTTP response payload should be in JSON format. The correct JSON format for indicating a healthy status is {"status": "healthy"}. This format uses a JSON object with a key-value pair where the key is "status" and the value is "healthy".

Other options provided are not valid JSON responses:

<status>healthy</status> is XML format.

status('healthy') and status: healthy are not valid JSON syntax.

References

HTTP Content Negotiation and Accept Headers

JSON Formatting and Syntax Rules

When a batch job instance running on a runtime fabric environment with two cluster replicas encounters an unexpected failure, the following sequence of events occurs:

Failure Detection: The runtime fabric environment detects the failure of the replica running the batch job.

Replica Replacement: A new replica is provisioned to replace the failed one.

Batch Job State Recovery: MuleSoft’s batch processing mechanism ensures that the state of the batch job is periodically saved (checkpointing). This allows the new replica to resume processing from the last saved state.

Resumption of Processing: The new replica takes over the batch job, continuing from where the previous one left off, thus processing the remaining 99,000 records without starting from scratch or causing duplicate processing.

References:

MuleSoft Documentation on Batch Processing

Runtime Fabric Guide

=======================