Mulesoft MCIA-LEVEL1 Online Practice Questions and Exam Preparation

Mulesoft MCIA-LEVEL1 Online Questions & Answers

• Question 91:

  According to MuleSoft, a synchronous invocation of a RESTful API using HTTP to get an individual customer record from a single system is an example of which system integration interaction pattern?

  A. Request-Reply
  B. Multicast
  C. Batch
  D. One-way
  A. Request-Reply

• Question 92:

  One of the backend systems involved by the API implementation enforces rate limits on the number of request a particle client can make.

  Both the back-end system and API implementation are deployed to several non-production environments including the staging environment and to a particular production environment. Rate limiting of the back-end system applies to all non-production environments.

  The production environment however does not have any rate limiting.

  What is the cost-effective approach to conduct performance test of the API implementation in the non-production staging environment?

  A. Including logic within the API implementation that bypasses in locations of the back-end system in the staging environment and invoke a Mocking service that replicates typical back-end system responses Then conduct performance test using this API implementation
  B. Use MUnit to simulate standard responses from the back-end system. Then conduct performance test to identify other bottlenecks in the system
  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
  D. Conduct scaled-down performance tests in the staging environment against rate-limiting back-end system. Then upscale performance results to full production scale
  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

• Question 93:

  A Mule application is being designed To receive nightly a CSV file containing millions of records from an external vendor over SFTP, The records from the file need to be validated, transformed. And then written to a database. Records can be inserted into the database in any order.

  In this use case, what combination of Mule components provides the most effective and performant way to write these records to the database?

  A. Use a Parallel for Each scope to Insert records one by one into the database
  B. Use a Scatter-Gather to bulk insert records into the database
  C. Use a Batch job scope to bulk insert records into the database.
  D. Use a DataWeave map operation and an Async scope to insert records one by one into the database.
  C. Use a Batch job scope to bulk insert records into the database.

  ---

  Correct answer is Use a Batch job scope to bulk insert records into the database

  # Batch Job is most efficient way to manage millions of records.

  A few points to note here are as follows :

  Reliability: If you want reliabilty while processing the records, i.e should the processing survive a runtime crash or other unhappy scenarios, and when restarted process all the remaining records, if yes then go for batch as it uses persistent queues. Error Handling: In Parallel for each an error in a particular route will stop processing the remaining records in that route and in such case you'd need to handle it using on error continue, batch process does not stop during such error instead you can have a step for

  failures and have a dedicated handling in it.

  Memory footprint: Since question said that there are millions of records to process, parallel for each will aggregate all the processed records at the end and can possibly cause Out Of Memory.

  Batch job instead provides a BatchResult in the on complete phase where you can get the count of failures and success. For huge file processing if order is not a concern definitely go ahead with Batch Job

• Question 94:

  A Mule application must handle temporary backend outages by retrying failed requests automatically. Which Mule component is most appropriate for this requirement?

  A. Try scope
  B. On Error Continue
  C. Until Successful scope
  D. Batch Job
  C. Until Successful scope

  ---

  The Until Successful scope is designed to retry processing until it succeeds or a maximum retry count is reached. It is commonly used to handle transient failures such as temporary backend outages.

• Question 95:

  A leading bank implementing new mule API.

  The purpose of API to fetch the customer account balances from the backend application and display them on the online platform the online banking platform. The online banking platform will send an array of accounts to Mule API get the account balances.

  As a part of the processing the Mule API needs to insert the data into the database for auditing purposes and this process should not have any performance related implications on the account balance retrieval flow

  How should this requirement be implemented to achieve better throughput?

  A. Implement the Async scope fetch the data from the backend application and to insert records in the Audit database
  B. Implement a for each scope to fetch the data from the back-end application and to insert records into the Audit database
  C. Implement a try-catch scope to fetch the data from the back-end application and use the Async scope to insert records into the Audit database
  D. Implement parallel for each scope to fetch the data from the backend application and use Async scope to insert the records into the Audit database
  D. Implement parallel for each scope to fetch the data from the backend application and use Async scope to insert the records into the Audit database

• Question 96:

  A key Cl/CD capability of any enterprise solution is a testing framework to write and run repeatable tests.

  Which component of Anypoint Platform provides the te6t automation capabilities for customers to use in their pipelines?

  A. Anypoint CLl
  B. Mule Maven Plugin
  C. Exchange Mocking Service
  D. MUnit
  D. MUnit

• Question 97:

  A payment processing company has implemented a Payment Processing API Mule application to process credit card and debit card transactions, Because the Payment Processing API handles highly sensitive information, the payment processing company requires that data must be encrypted both In-transit and at-rest.

  To meet these security requirements, consumers of the Payment Processing API must create request message payloads in a JSON format specified by the API, and the message payload values must be encrypted.

  How can the Payment Processing API validate requests received from API consumers?

  A. A Transport Layer Security (TLS) - Inbound policy can be applied in API Manager to decrypt the message payload and the Mule application implementation can then use the JSON Validation module to validate the JSON data
  B. The Mule application implementation can use the APIkit module to decrypt and then validate the JSON data
  C. The Mule application implementation can use the Validation module to decrypt and then validate the JSON data
  D. The Mule application implementation can use DataWeave to decrypt the message payload and then use the JSON Scheme Validation module to validate the JSON data
  A. A Transport Layer Security (TLS) - Inbound policy can be applied in API Manager to decrypt the message payload and the Mule application implementation can then use the JSON Validation module to validate the JSON data

  ---

  To ensure that data is encrypted both in-transit and at-rest, and to validate incoming requests to the Payment Processing API, the following approach is recommended:

  TLS Inbound Policy: Apply a Transport Layer Security (TLS) - Inbound policy in API Manager. This policy ensures that the data is encrypted during transmission and can be decrypted by the API Manager before it reaches the Mule application.

  Decryption: With the TLS policy applied, the message payload is decrypted when it is received by the API Manager.

  JSON Validation: After decryption, the Mule application can use the JSON Validation module to validate the structure and content of the JSON data. This ensures that the payload conforms to the specified format and contains valid data.

  This approach ensures that data is securely transmitted and properly validated upon receipt.

  References:

  Transport Layer Security (TLS) Policies JSON Validation Module

• Question 98:

  A retail company is implementing a MuleSoft API to get inventory details from two vendors by Invoking each vendor's online applications. Due to network issues, the invocations to the vendor applications are timing out intermittently, but the requests are successful after re-invoking each vendor application. What is the most performant way of implementing the API to invoke each vendor application and to retry invocations that generate timeout errors?

  A. Use a For-Each scope to invoke the two vendor applications in series, one after the other. Place the For-Each scope inside an Until-Successful scope to retry requests that raise timeout errors.
  B. Use a Choice scope to Invoke each vendor application on a separate route. Place the Choice scope inside an Until-Successful scope to retry requests that raise timeout errors.
  C. Use a Scatter-Gather scope to invoke each vendor application on a separate route. Use an Until-Successful scope in each route to retry requests that raise timeout errors.
  D. Use a Round-Robin scope to invoke each vendor application on a separate route. Use a Try-Catch scope in each route to retry requests that raise timeout errors.
  C. Use a Scatter-Gather scope to invoke each vendor application on a separate route. Use an Until-Successful scope in each route to retry requests that raise timeout errors.

  ---

  To efficiently handle the invocation of vendor applications and retry requests that generate timeout errors, the most performant way is:

  Scatter-Gather Scope: Use a Scatter-Gather scope to invoke each vendor application in parallel. This approach allows the API to send requests to both vendors simultaneously, reducing overall processing time.

  Until-Successful Scope: Inside each route of the Scatter-Gather scope, use an Until-Successful scope to handle retries. The Until-Successful scope will retry the request in case of timeout errors until the request succeeds or the maximum retry limit is reached.

  This combination ensures that the API can handle intermittent network issues efficiently while minimizing redundant transactions and maximizing performance.

  References: MuleSoft Documentation on Scatter-Gather Scope MuleSoft Documentation on Until-Successful Scope and Error Handling

• Question 99:

  An organization plans to migrate its deployment environment from an onpremises cluster to a Runtime Fabric (RTF) cluster. The on-premises Mule applications are currently configured with persistent object stores.

  There is a requirement to enable Mule applications deployed to the RTF cluster to store and share data across application replicas and through restarts of the entire RTF cluster,

  How can these reliability requirements be met?

  A. Replace persistent object stores with persistent VM queues in each Mule application deployment
  B. Install the Object Store pod on one of the cluster nodes
  C. Configure Anypoint Object Store v2 to share data between replicas in the RTF cluster
  D. Configure the Persistence Gateway in the RTF installation
  C. Configure Anypoint Object Store v2 to share data between replicas in the RTF cluster

  ---

  To meet the reliability requirements for Mule applications deployed to a Runtime Fabric (RTF) cluster, where data needs to be shared across application replicas and persist through restarts, the best approach is to use Anypoint Object Store v2. This service is designed to provide persistent storage that can be shared among different application instances and across restarts. Steps include:

  Configure Object Store v2: Set up Anypoint Object Store v2 in the Mule application to handle data storage needs.

  Persistent Data Handling: Ensure that the configuration allows data to be shared and persist, meeting the requirements for reliability and consistency.

  This solution leverages MuleSoft's cloud-based storage service optimized for these use cases, ensuring data integrity and availability.

  References: MuleSoft Documentation on Object Store v2 Configuring Persistent Data Storage in MuleSoft

• Question 100:

  An organization is building a test suite for their applications using m-unit. The integration architect has recommended using test recorder in studio to record the processing flows and then configure unit tests based on the capture events.

  What are the two considerations that must be kept in mind while using test recorder?

  (Choose two answers)

  A. Tests for flows cannot be created with Mule errors raised inside the flow or already existing in the incoming event
  B. Recorder supports smoking a message before or inside a ForEach processor
  C. The recorder support loops where the structure of the data been tested changes inside the iteration
  D. A recorded flow execution ends successfully but the result does not reach its destination because the application is killed
  E. Mocking values resulting from parallel processes are possible and will not affect the execution of the processes that follow in the test
  A. Tests for flows cannot be created with Mule errors raised inside the flow or already existing in the incoming event
  D. A recorded flow execution ends successfully but the result does not reach its destination because the application is killed