Skip to main content

MULESOFT-INTEGRATION-ARCHITECT-I Real Exam Questions

Salesforce Certified MuleSoft Platform Integration Architect (Mule-Arch-202)

273 questions available · Page 1 of 28

Updated Exam DumpsVerified AnswersPass Guarantee

Get Complete Exam Dumps
Question 1 Single choice

An organization if struggling frequent plugin version upgrades and external plugin project dependencies.
The team wants to minimize the impact on applications by creating best practices that will define a set of default dependencies across all new and in progress projects.

How can these best practices be achieved with the applications having the least amount of responsibility?

  1. A

    Create a Mule plugin project with all the dependencies and add it as a dependency in each
    application's POM.xml file

  2. B

    Create a mule domain project with all the dependencies define in its POM.xml file and add each

    application to the domain Project

  3. C

    Add all dependencies in each application's POM.xml file

  4. D

    Create a parent POM of all the required dependencies and reference each in each application's
    POM.xml file

Show answer and explanation

Correct answer: D

Explanation

Requirement Analysis: The organization wants to standardize dependencies across all new and ongoing MuleSoft projects to minimize the impact of frequent plugin version upgrades and external plugin project dependencies. Solution: Creating a parent POM (Project Object Model) file with all required dependencies and referencing it in each application's POM.xml file is the best practice.
Implementation Steps:
pom</artifactId> <version>1.0.0</version> <packaging>pom</packaging> <dependencyManagement>
<dependencies> <dependency>
<groupId>org.mule.runtime</groupId> <artifactId>mule-core-extensions-maven-plugin</artifactId>
<version>1.0.0</version> </dependency> <!--Add other dependencies here --> </dependencies> </ dependencyManagement> </project> uk.co.certification.simulator.questionpool.PList@1b368240
<project> <modelVersion>4.0.0</modelVersion> <parent>
<groupId>com.example</groupId> <artifactId>parent-pom</artifactId> <version>1.0.0</version> </parent>
<artifactId>child-application</artifactId> <version>1.0.0</version> <!--Application specific dependencies
and configurations --> </ project> uk.co.certification.simulator.questionpool.PList@1b368950

References:
MuleSoft Documentation on Managing dependencies with Maven Apache Maven Documentation on POM Reference

Question 2 Single choice

An organization's security requirements mandate centralized control at all times over authentication and authorization of external applications when invoking web APIs managed on Anypoint Platform.

What Anypoint Platform feature is most idiomatic (used for its intended purpose), straightforward, and maintainable to use to meet this requirement?

  1. A

    Client management configured in access management

  2. B

    Identity management configured in access management

  3. C

    Enterprise Security module coded in Mule applications

  4. D

    External access configured in API Manager

Show answer and explanation

Correct answer: A

Explanation

References:
https://blogs.mulesoft.com/dev-guides/api-security-ways-to-authenticate-and-authorize/

Question 3 Single choice

An insurance company is implementing a MuleSoft API to get inventory details from the two vendors. Due to network issues, the invocations to vendor applications are getting timed-out intermittently.

But the transactions are successful upon reprocessing What is the most performant way of implementing this requirement?

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

  2. B

    Implement a Choice scope to invoke the two vendor applications on two different route
    Use the try-catch scope to implement the retry mechanism for timeout errors on each route

  3. C

    Implement a For-Each scope to invoke the two vendor applications
    Use until successful scope to implement the retry mechanism for the timeout errors

  4. D

    Implement Round-Robin scope to invoke the two vendor applications on two different routes
    Use the Try-Catch scope to implement retry mechanism for timeout errors on each route

Show answer and explanation

Correct answer: A

Explanation

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

Question 4 Single choice

As a part of project requirement, client will send a stream of data to mule application. Payload size can vary between 10mb to 5GB. Mule application is required to transform the data and send across multiple sftp servers. Due to the cost cuttings in the organization, mule application can only be allocated one worker with size of 0.2 vCore.

As an integration architect , which streaming strategy you would suggest to handle this scenario?

  1. A

    In-memory non repeatable stream

  2. B

    File based non-repeatable stream

  3. C

    In-memory repeatable stream

  4. D

    File based repeatable storage

Show answer and explanation

Correct answer: D

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

Question 5 Single choice

What requires configuration of both a key store and a trust store for an HTTP Listener?

  1. A

    Support for TLS mutual (two-way) authentication with HTTP clients

  2. B

    Encryption of requests to both subdomains and API resource endpoints fhttPs://aDi.customer.com/ and
    https://customer.com/api)

  3. C

    Encryption of both HTTP request and HTTP response bodies for all HTTP clients

  4. D

    Encryption of both HTTP request header and HTTP request body for all HTTP clients

Show answer and explanation

Correct answer: A

Explanation

1 way SSL : The server presents its certificate to the client and the client adds it to its list of trusted certificate. And so, the client can talk to the server. 2-way SSL: The same principle but both ways. i.e. both the client and the server has to establish trust between themselves using a trusted certificate. In this way of a digital handshake, the server needs to present a certificate to authenticate itself to client and client has to present its certificate to server.
* 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 Keystores and Truststores Truststore and keystore contents differ depending on whether they are used for clients or servers: For servers: the truststore contains certificates of the trusted clients, the keystore contains the private and public key of the server. For clients: the truststore contains certificates of the trusted servers, the keystore contains the private and public key of the client. Adding both a keystore and a truststore to the configuration implements two-way TLS authentication also known as mutual authentication.
* in this case, correct answer is Support for TLS mutual (two-way) authentication with HTTP clients.

Question 6 Single choice

An organization is creating a Mule application that will be deployed to CloudHub. The Mule application has a property named dbPassword that stores a database user's password. The organization's security standards indicate that the dbPassword property must be hidden from every Anypoint Platform user after the value is set in the Runtime Manager Properties tab.

What configuration in the Mule application helps hide the dbPassword property value in Runtime Manager?

  1. A

    Use secure::dbPassword as the property placeholder name and store the cleartext (unencrypted) value
    in a secure properties placeholder file

  2. B

    Use secure::dbPassword as the property placeholder name and store the property encrypted value in a
    secure properties placeholder file

  3. C

    Add the dbPassword property to the secureProperties section of the pom.xml file

  4. D

    Add the dbPassword property to the secureProperties section of the mule-artifact.json file

Show answer and explanation

Correct answer: B

Explanation

References:
https://docs.mulesoft.com/runtime-manager/secure-application-properties

Question 7 Single choice

An Order microservice and a Fulfillment microservice are being designed to communicate with their dients through message-based integration (and NOT through API invocations).

The Order microservice publishes an Order message (a kind of command message) containing the details of an order to be fulfilled. The intention is that Order messages are only consumed by one Mute application, the Fulfillment microservice.

The Fulfilment microservice consumes Order messages, fulfills the order described therein, and then publishes an OrderFulfilted message (a kind of event message). Each OrderFulfilted message can be consumed by any interested Mule application, and the Order microservice is one such Mute application.

What is the most appropriate choice of message broker(s) and message destination(s) in this scenario?

  1. A

    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

  2. B

    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

  3. C

    Order messages are sent directly to the Fulfillment microservices. OrderFulfilled messages are sent directly to the Order microservice.
    The Order microservice interacts with one AMQP-compatible message broker and the Fulfillment microservice interacts with a different AMQP-compatible message broker, so that both message brokers can be chosen and scaled to best support the load of each microservice

  4. D

    Order messages are sent to a JMS queue. OrderFulfilled messages are sent to a JMS topic The Order microservice interacts with one JMS provider (message broker) and the Fulfillment microservice interacts with a different JMS provider, so that both message brokers can be chosen and scaled to best support the load of each microservice

Show answer and explanation

Correct answer: B

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:

Question 8 Single choice

The ABC company has an Anypoint Runtime Fabric on VMs/Bare Metal (RTF-VM) appliance installed on its own customer-hosted AWS infrastructure. Mule applications are deployed to this RTF-VM appliance. As part of the company standards, the Mule application logs must be forwarded to an external log management tool (LMT).

Given the company's current setup and requirements, what is the most idiomatic (used for its intended purpose) way to send Mule application logs to the external LMT?

  1. A

    In RTF-VM, install and configure the external LTM's log-forwarding agent

  2. B

    In RTF-VM, edit the pod configuration to automatically install and configure an Anypoint Monitoring agent

  3. C

    In each Mule application, configure custom Log4j settings

  4. D

    In RTF-VM. configure the out-of-the-box external log forwarder

Show answer and explanation

Correct answer: A

Explanation

References:
https://help.mulesoft.com/s/article/Enable-external-log-forwarding-for-Mule-applications-deployed-in-RTF

Question 9 Single choice

What approach configures an API gateway to hide sensitive data exchanged between API consumers and API implementations, but can convert tokenized fields back to their original value for other API requests or responses, without having to recode the API implementations?

  1. A

    Create both masking and tokenization formats and use both to apply a tokenization policy in an API

    gateway to mask sensitive values in message payloads withcharacters, and apply a corresponding detokenization policy to return the original values to other APIs

  2. B

    Create a masking format and use it to apply a tokenization policy in an API gateway to mask sensitive values in message payloads with characters, and apply a corresponding detokenization policy to return the original values to other APIs

  3. C

    Use a field-level encryption policy in an API gateway to replace sensitive fields in message payload with encrypted values, and apply a corresponding field-level decryption policy to return the original values to other APIs

  4. D

    Create a tokenization format and use it to apply a tokenization policy in an API gateway to replace sensitive fields in message payload with similarly formatted tokenized values, and apply a corresponding detokenization policy to return the original values to other APIs

Show answer and explanation

Correct answer: D

Explanation

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

Question 10 Single choice

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?

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

  2. B

    Use MUnit to simulate standard responses from the back-end system.
    Then conduct performance test to identify other bottlenecks in the system

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

  4. D

    Conduct scaled-down performance tests in the staging environment against rate-limiting back-end system. Then upscale performance results to full production scale

Show answer and explanation

Correct answer: C

Explanation

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