MuleSoft-Integration-Architect-I Questions Prepare with Learning Information! 2025 Regularly updated
Get MuleSoft-Integration-Architect-I Products Practice Material for MuleSoft-Integration-Architect-I Exam Question Preparation
Salesforce MuleSoft-Integration-Architect-I Exam Syllabus Topics:
| Topic | Details |
|---|---|
| Topic 1 |
|
| Topic 2 |
|
| Topic 3 |
|
| Topic 4 |
|
| Topic 5 |
|
NEW QUESTION # 39
Refer to the exhibit.
A Mule application is being designed to be deployed to several CIoudHub workers. The Mule application's integration logic is to replicate changed Accounts from Satesforce to a backend system every 5 minutes.
A watermark will be used to only retrieve those Satesforce Accounts that have been modified since the last time the integration logic ran.
What is the most appropriate way to implement persistence for the watermark in order to support the required data replication integration logic?
- A. Persistent Object Store
- B. Persistent VM Queue
- C. Persistent Cache Scope
- D. Persistent Anypoint MQ Queue
Answer: A
Explanation:
* 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.
2) Persistent store - Mule persists data when an object store is explicitly configured to be persistent.
In a standalone Mule runtime, Mule creates a default persistent store in the file system. If you do not specify an object store, the default persistent object store is used.
MuleSoft Reference: https://docs.mulesoft.com/mule-runtime/3.9/mule-object-stores
NEW QUESTION # 40
An organization has an HTTPS-enabled Mule application named Orders API that receives requests from another Mule application named Process Orders.
The communication between these two Mule applications must be secured by TLS mutual authentication (two-way TLS).
At a minimum, what must be stored in each truststore and keystore of these two Mule applications to properly support two-way TLS between the two Mule applications while properly protecting each Mule application's keys?
- A. Orders API truststore: The Orders API private key and public key
Process Orders keystore: The Process Orders private key public key - B. Orders API truststore: The Orders API public key
Process Orders keystore: The Process Orders private key and public key - C. Orders API truststore: The Process Orders public key
Orders API keystore: The Orders API private key and public key
Process Orders truststore: The Orders API public key
Process Orders keystore: The Process Orders private key and public key - D. Orders API truststore: The Process Orders public key
Orders API keystore: The Orders API private key
Process Orders truststore: The Orders API public key
Process Orders keystore: The Process Orders private key
Answer: C
NEW QUESTION # 41
A bank is implementing a REST API in a Mule application to receive an array of accounts from an online banking platform user interface (UI),retrieve account balances for those accounts from a backend Finance system, and then return the account balances so they can be displayed inthe online banking platform UI. As part of the processing, the MuleSoft API also needs to insert the retrieved account data into an AuditDatabase for auditing purposes. the auditing process should not add latency to the account balance retrieval response back to the onlinebanking platform UI.
The retrieveBalances flow in the Mule application is designed to use an operation in a connector to the Finance system (the Finance operation) that can only look up one account record at a time, and a operation from a different connector to the Audit system (the Audit operation) that can only insert one account record at a time.
To best meet the performance-related requirements, what scope or scopes should be used and how should they be used to incorporate the Finance operation and Audit operation into the retrieveBalances flow?
- A. Wrap the Finance operation in a Until-Successful scope. Wrap the Audit operation in a Try-Catch scope.
- B. Wrap the Finance operation in a Parallel For-Each scope. Wrap the Audit operation in a Async scope.
- C. Wrap both connector operations in a For-Each scope.
- D. Wrap both connector operations in a Async scope.
Answer: B
Explanation:
* Understanding the Operations:
* The Finance operation can only look up one account record at a time.
* The Audit operation can only insert one account record at a time.
* Parallel For-Each Scope:
* Finance Operation: Use a Parallel For-Each scope to process multiple account lookups simultaneously.
* This improves performance by allowing concurrent processing of account records, leveraging parallelism.
* Async Scope:
* Audit Operation: Use an Async scope to handle the insertion of account records independently.
* The Async scope ensures that the Audit operation does not block the main processing flow, allowing other processes to continue without waiting for the Audit operation to complete.
* Performance Optimization:
* Combining Parallel For-Each for the Finance operation and Async scope for the Audit operation maximizes throughput.
* This approach ensures efficient use of resources and reduces latency by parallelizing account lookups and asynchronously handling audit inserts.
MuleSoft Documentation on Scopes: Mule Scopes
MuleSoft Best Practices for Performance: Performance Best Practices
NEW QUESTION # 42
An organization is creating a set of new services that are critical for their business. The project team prefers using REST for all services but is willing to use SOAP with common WS-" standards if a particular service requires it.
What requirement would drive the team to use SOAP/WS-* for a particular service?
- A. Must support message acknowledgement and retry as part of the protocol
- B. Must secure the service, requiring all consumers to submit a valid SAML token
- C. Must use XML payloads for the service and ensure that it adheres to a specific schema
- D. Must publish and share the service specification (including data formats) with the consumers of the service
Answer: B
Explanation:
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
NEW QUESTION # 43
What are two reasons why a typical MuleSoft customer favors a MuleSoft-hosted Anypoint Platform runtime plane over a customer-hosted runtime for its Mule application deployments? (Choose two.)
- A. Reduced time-to-market for the first application
- B. Increased application isolation
- C. Reduced IT operations effort
- D. Reduced application latency
- E. Increased application throughput
Answer: A,C
NEW QUESTION # 44
A Mule application currently writes to two separate SQL Server database instances across the internet using a single XA transaction. It is 58. proposed to split this one transaction into two separate non-XA transactions with no other changes to the Mule application.
What non-functional requirement can be expected to be negatively affected when implementing this change?
- A. Availability
- B. Consistency
- C. Throughput
- D. Response time
Answer: B
Explanation:
Correct answer is Consistency as XA transactions are implemented to achieve this. XA transactions are added in the implementation to achieve goal of ACID properties. In the context of transaction processing, the acronym ACID refers to the four key properties of a transaction: atomicity, consistency, isolation, and durability. Atomicity : All changes to data are performed as if they are a single operation. That is, all the changes are performed, or none of them are. For example, in an application that transfers funds from one account to another, the atomicity property ensures that, if a debit is made successfully from one account, the corresponding credit is made to the other account. Consistency : Data is in a consistent state when a transaction starts and when it ends.For example, in an application that transfers funds from one account to another, the consistency property ensures that the total value of funds in both the accounts is the same at the start and end of each transaction. Isolation : The intermediate state of a transaction is invisible to other transactions. As a result, transactions that run concurrently appear to be serialized. For example, in an application that transfers funds from one account to another, the isolation property ensures that another transaction sees the transferred funds in one account or the other, but not in both, nor in neither. Durability : After a transaction successfully completes, changes to data persist and are not undone, even in the event of a system failure. For example, in an application that transfers funds from one account to another, the durability property ensures that the changes made to each account will not be reversed. MuleSoft reference: https://docs.mulesoft.com/mule-runtime/4.3/xa-transactions
NEW QUESTION # 45
Refer to the exhibit.
A shopping cart checkout process consists of a web store backend sending a sequence of API invocations to an Experience API, which in turn invokes a Process API. All API invocations are over HTTPS POST. The Java web store backend executes in a Java EE application server, while all API implementations are Mule applications executing in a customer -hosted Mule runtime.
End-to-end correlation of all HTTP requests and responses belonging to each individual checkout Instance is required. This is to be done through a common correlation ID, so that all log entries written by the web store backend, Experience API implementation, and Process API implementation include the same correlation ID for all requests and responses belonging to the same checkout instance.
What is the most efficient way (using the least amount of custom coding or configuration) for the web store backend and the implementations of the Experience API and Process API to participate in end-to-end correlation of the API invocations for each checkout instance?
A)
The web store backend, being a Java EE application, automatically makes use of the thread-local correlation ID generated by the Java EE application server and automatically transmits that to the Experience API using HTTP-standard headers No special code or configuration is included in the web store backend, Experience API, and Process API implementations to generate and manage the correlation ID
B)
The web store backend generates a new correlation ID value at the start of checkout and sets it on the X-CORRELATlON-lt 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
C)
The Experience API implementation generates a correlation ID for each incoming HTTP request and passes it to the web store backend in the HTTP response, which includes it in all subsequent API invocations to the Experience API.
The Experience API implementation must be coded to also propagate the correlation ID to the Process API in a suitable HTTP request header
D)
The web store backend sends a correlation ID value in the HTTP request body In the way required by the Experience API The Experience API and Process API implementations must be coded to receive the custom correlation ID In the HTTP requests and propagate It in suitable HTTP request headers
- A. Option A
- B. Option C
- C. Option B
- D. Option D
Answer: C
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" : 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-Endpoint-in-Mule-4
NEW QUESTION # 46
A MuteSoft developer must implement an API as a Mule application, run the application locally, and execute unit tests against the Running application.
Which Anypoint Platform component can the developer use to full all of these requirements?
- A. Anypoint Studio
- B. API Manager
- C. API Designer
- D. Anypoint CLI
Answer: A
NEW QUESTION # 47
A Mule application name Pub uses a persistence object store. The Pub Mule application is deployed to Cloudhub and it configured to use Object Store v2.
Another Mule application name sub is being developed to retrieve values from the Pub Mule application persistence object Store and will also be deployed to cloudhub.
What is the most direct way for the Sub Mule application to retrieve values from the Pub Mule application persistence object store with the least latency?
- A. Use the Object store v2 REST API configured to access the Pub Mule application persistence object store.
- B. Use a VM connector configured to directly access the persistence queue of the Pub Mule application persistence object store.
- C. Use an Anypoint MQ connector configured to directly access the Pub Mule application persistence object store
- D. Use an object store connector configured to access the Pub Mule application persistence object store
Answer: A
Explanation:
* The Object Store V2 API enables API access to Anypoint Platform Object Store v2.
* 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. However, Object Store v2 is not designed for app-to-app communication. To share data between two Mule4 apps, use a queue in Anypoint MQ.
* The Object Store v2 APIs enable you to use REST to perform the following:
- Retrieve a list of object stores and keys associated with an application.
- Store and retrieve key-value pairs in an object store.
- Delete key-value pairs from an object store.
- Retrieve Object Store usage statistics for your organization.
- Object Store provides these APIs:
Object Store API
Object Store Stats API
Reference:
Additional Info:
When to use Object Store and when to use VM
NEW QUESTION # 48
A banking company is developing a new set of APIs for its online business. One of the critical API's is a master lookup API which is a system API. This master lookup API uses persistent object store. This API will be used by all other APIs to provide master lookup data.
Master lookup API is deployed on two cloudhub workers of 0.1 vCore each because there is a lot of master data to be cached. Master lookup data is stored as a key value pair. The cache gets refreshed if they key is not found in the cache.
Doing performance testing it was observed that the Master lookup API has a higher response time due to database queries execution to fetch the master lookup data.
Due to this performance issue, go-live of the online business is on hold which could cause potential financial loss to Bank.
As an integration architect, which of the below option you would suggest to resolve performance issue?
- A. Implement HTTP caching policy for all GET endpoints for the master lookup API and implement locking to synchronize access to object store
- B. Implement HTTP caching policy for all GET endpoints for master lookup API
- C. Upgrade vCore size from 0.1 vCore to 0,2 vCore
- D. Add an additional Cloudhub worker to provide additional capacity
Answer: A
Explanation:
A: Implement HTTP caching policy for all GET endpoints for the master lookup API and implement locking to synchronize access to object store Comprehensive Detailed Step by Step ExplanationTo resolve the performance issue observed during the performance testing of the Master lookup API, the best approach involves caching and synchronization:
* HTTP Caching Policy:
* Purpose: Reduces the load on the database by caching the responses for GET requests. Once a response is cached, subsequent requests for the same resource can be served from the cache instead of querying the database.
* Implementation: Apply the HTTP caching policy to all GET endpoints of the Master lookup API. This policy ensures that the frequently accessed master lookup data is stored in the cache and served quickly.
* Benefits: This significantly reduces the number of database queries, thus lowering the response time and improving performance.
* Object Store Locking:
* Purpose: Ensures data consistency and prevents race conditions when multiple workers attempt to access or update the cache concurrently.
* Implementation: Use a locking mechanism to synchronize access to the object store. This can be achieved by using MuleSoft's Object Store Connector with lock/unlock operations.
* Benefits: Prevents multiple database queries for the same key and ensures that only one worker updates the cache at a time, thus avoiding redundant operations and maintaining data integrity.
By implementing these two strategies, the response time of the Master lookup API will be significantly improved, and the performance issue will be resolved.
References
* MuleSoft HTTP Caching Policy
* MuleSoft Object Store Connector
NEW QUESTION # 49
A Mule application name Pub uses a persistence object store. The Pub Mule application is deployed to Cloudhub and it configured to use Object Store v2.
Another Mule application name sub is being developed to retrieve values from the Pub Mule application persistence object Store and will also be deployed to cloudhub.
What is the most direct way for the Sub Mule application to retrieve values from the Pub Mule application persistence object store with the least latency?
- A. Use the Object store v2 REST API configured to access the Pub Mule application persistence object store.
- B. Use a VM connector configured to directly access the persistence queue of the Pub Mule application persistence object store.
- C. Use an Anypoint MQ connector configured to directly access the Pub Mule application persistence object store
- D. Use an object store connector configured to access the Pub Mule application persistence object store
Answer: A
Explanation:
* The Object Store V2 API enables API access to Anypoint Platform Object Store v2.
* 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. However, Object Store v2 is not designed for app-to-app communication. To share data between two Mule4 apps, use a queue in Anypoint MQ.
* The Object Store v2 APIs enable you to use REST to perform the following:
- Retrieve a list of object stores and keys associated with an application.
- Store and retrieve key-value pairs in an object store.
- Delete key-value pairs from an object store.
- Retrieve Object Store usage statistics for your organization.
- Object Store provides these APIs:
Object Store API
Object Store Stats API
NEW QUESTION # 50
A project uses Jenkins to implement CI/CD process. It was observed that each Mule package contains some of the Jenkins files and folders for configurations of CI/CD jobs.
As these files and folders are not part of the actual package, expectation is that these should not be part of deployed archive.
Which file can be used to exclude these files and folders from the deployed archive?
- A. _muleExclude
- B. mulelnclude
- C. _unTrackMule
- D. muleignore
Answer: D
Explanation:
* Requirement Analysis: Jenkins files and folders used for CI/CD configurations are not part of the actual Mule package and should be excluded from the deployed archive.
* Solution: MuleSoft provides the .muleignore file to specify files and directories that should be excluded from the packaged application.
* Implementation Steps:
* Create a .muleignore File: In the root directory of your Mule project, create a file named .
muleignore.
* Specify Exclusions: Add the paths of the Jenkins files and folders that you want to exclude from the deployment package into the .muleignore file.
# .muleignore example /path/to/jenkins/file1 /path/to/jenkins/folder/*
* Build and Deploy: When you build your Mule application, the Mule runtime will read the .
muleignore file and exclude the specified files and directories from the deployment archive.
* Advantages:
* Clean Deployment: Ensures that only necessary files are included in the deployment package, reducing the package size and preventing potential issues related to unwanted files.
* Ease of Maintenance: Easy to update and manage which files are excluded from the deployment package.
References
* MuleSoft Documentation on .muleignore
NEW QUESTION # 51
When the mule application using VM is deployed to a customer-hosted cluster or multiple cloudhub workers, how are messages consumed by the Mule engine?
- A. in a deterministic way
- B. the primary only in order to avoid duplicate processing
- C. in non-deterministic way
- D. by starting an XA transaction for each new message
Answer: C
Explanation:
When a Mule application using VM (Virtual Machine) queues is deployed to a customer-hosted cluster or multiple CloudHub workers, the messages are consumed by the Mule engine in a non-deterministic way. Here' s an in-depth explanation:
* VM Queues Overview:
* VM queues in Mule applications are used for intra-application communication, allowing different flows within the same application to exchange messages.
* Deployment in Clusters or Multiple Workers:
* Customer-Hosted Cluster: In a customer-hosted cluster, multiple Mule runtime instances work together to process messages. Each instance can pick up messages from the VM queue.
* CloudHub Workers: When deployed on CloudHub, multiple worker instances can run the same Mule application, and each worker can access the VM queue.
* Non-Deterministic Message Consumption:
* Load Distribution: Messages are distributed among the available nodes or workers based on their availability. This means any node or worker that is ready to process a message can pick it up from the queue.
* No Guaranteed Order: Because any available node or worker can consume messages, the order in which messages are processed is not guaranteed, making the consumption non-deterministic.
* Parallel Processing: This approach allows for parallel processing of messages, which improves the scalability and throughput of the application.
* Advantages:
* Scalability: By allowing multiple nodes or workers to process messages, the system can handle increased load more effectively.
* Fault Tolerance: If one node or worker fails, other nodes/workers can continue processing messages from the VM queue, providing higher availability.
* Considerations:
* Idempotency: Ensure that the processing logic is idempotent, meaning that processing the same message more than once does not produce different outcomes. This is crucial in a non- deterministic consumption environment to avoid issues with data consistency.
* Transaction Management: Proper transaction management should be in place to handle scenarios where a message might need to be reprocessed due to errors.
MuleSoft Documentation on VM Connector
MuleSoft Documentation on High Availability Clustering
MuleSoft Documentation on Deploying to CloudHub
NEW QUESTION # 52
A large life sciences customer plans to use the Mule Tracing module with the Mapped Diagnostic Context (MDC) logging operations to enrich logging in its Mule application and to improve tracking by providing more context in the Mule application logs. The customer also wants to improve throughput and lower the message processing latency in its Mule application flows.
After installing the Mule Tracing module in the Mule application, how should logging be performed in flows in Mule applications, and what should be changed In the log4j2.xml files?
- 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.
- B. In the flows, add Mule Tracing module Set logging variable operations before any CoreLogger components.In log4j2.xmI files, change the appender's pattern layout to use the %MDC placeholder and then assign the appender to an AsyncLogger element.
- C. In the flows, wrap Logger components in Async scopes. In log4j2.xmI files, change the appender's pattern layout to use the %asyncLoggerplaceholder and then assign the appender to a Logger or Root element.
- D. In the flows, add Mule Tracing module Set logging variable operations before any CoreLogger components.In log4j2.xmI files, change the appender''s pattern layout to use %asyncLogger placeholder and then assign the appender to an AsyncLogger element.
Answer: A
Explanation:
* Mule Tracing Module and MDC:
* The Mule Tracing module enhances logging by adding context-specific information to logs using Mapped Diagnostic Context (MDC).
* MDC allows including additional metadata in logs, making it easier to trace and debug issues in the application.
* Set Logging Variable Operations:
* In Mule flows, before any Core Logger components, add Set logging variable operations from the Mule Tracing module.
* This ensures that the contextual information is set before logs are written.
* Configuring log4j2.xml:
* Update the log4j2.xml file to change the appender's pattern layout to include %MDC placeholders.
* Assign the appender to either a Logger or the Root element to ensure that logs across the application include the MDC-enriched information.
* Improving Throughput and Lowering Latency:
* Using MDC with %MDC placeholders ensures that enriched logging does not significantly impact performance.
* This setup improves logging detail while maintaining efficient message processing.
MuleSoft Documentation on Mule Tracing: Mule Tracing Module
Log4j2 Documentation on MDC: Log4j2 MDC
NEW QUESTION # 53
The company's FTPS server login username and password
- A. The partner's PGP public key used by the company to login to the FTPS server. A TLS context key store containing the private key for the company The partner's PGP private key that was used to sign the files
- B. The partner's PGP public key used by the company to login to the FTPS server. A TLS context key store containing the private key for ftps.partner.com The company's PGP private key that was used to sign the files
- C. The company's FTPS server login username and password. A TLS context trust store containing a public certificate for ftps.partner.com The partner's PGP public key that was used to sign the files
- D. TLS context trust store containing a public certificate for the company. The company's PGP public key that was used to sign the files
Answer: C
Explanation:
When configuring secure communication with an FTPS server and handling signed files, the necessary components include:
* FTPS Server Login Credentials: The username and password used to authenticate with the company's FTPS server.
* TLS Context Trust Store: This should contain the public certificate for the FTPS server (ftps.partner.
com) to establish a secure SSL/TLS connection.
* Partner's PGP Public Key: This is used to verify the signature of the files received from the partner, ensuring data integrity and authenticity.
These components collectively ensure secure communication and data validation.
References
* MuleSoft Documentation on FTPS and PGP Encryption
* Best Practices for Secure File Transfer and Encryption
NEW QUESTION # 54
What API policy would LEAST likely be applied to a Process API?
- A. Client ID enforcement
- B. Rate limiting
- C. Custom circuit breaker
- D. JSON threat protection
Answer: D
Explanation:
Key to this question lies in the fact that Process API are not meant to be accessed directly by clients. Lets analyze options one by one. Client ID enforcement : This is applied at process API level generally to ensure that identity of API clients is always known and available for API-based analytics Rate Limiting : This policy is applied on Process Level API to secure API's against degradation of service that can happen in case load received is more than it can handle Custom circuit breaker : This is also quite useful feature on process level API's as it saves the API client the wasted time and effort of invoking a failing API. JSON threat protection :
This policy is not required at Process API and rather implemented as Experience API's. This policy is used to safeguard application from malicious attacks by injecting malicious code in JSON object. As ideally Process API's are never called from external world , this policy is never used on Process API's Hence correct answer is JSON threat protection MuleSoft Documentation Reference : https://docs.mulesoft.com/api-manager/2.x
/policy-mule3-json-threat
NEW QUESTION # 55
What requires configuration of both a key store and a trust store for an HTTP Listener?
- A. Encryption of both HTTP request and HTTP response bodies for all HTTP clients
- B. Encryption of both HTTP request header and HTTP request body for all HTTP clients
- C. Encryption of requests to both subdomains and API resource endpoints fhttPs://aDi.customer.com/ and https://customer.com/api)
- D. Support for TLS mutual (two-way) authentication with HTTP clients
Answer: D
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.
NEW QUESTION # 56
In one of the critical payment related mule application, transaction is being used . As an enhancement to implementation , scatter gather route is introduced which is also the part of transaction group. Scatter gather route has 4 routes.
What will be the behavior of the Mule application in case of error occurs in 4th route of the scatter-gather router and transaction needs to be rolled back?
- A. All routes will be rolled back
- B. Scatter Gather router cannot be part of transaction
- C. Only errored route will be rolled back
Answer: A
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
NEW QUESTION # 57
A new upstream API Is being designed to offer an SLA of 500 ms median and 800 ms maximum (99th percentile) response time. The corresponding API implementation needs to sequentially invoke 3 downstream APIs of very similar complexity. The first of these downstream APIs offers the following SLA for its response time: median: 100 ms, 80th percentile: 500 ms, 95th percentile: 1000 ms. If possible, how can a timeout be set in the upstream API for the invocation of the first downstream API to meet the new upstream API's desired SLA?
- A. 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
- B. Do not set a timeout; the Invocation of this API Is mandatory and so we must wait until it responds
- C. Set a timeout of 50 ms; this times out more invocations of that API but gives additional room for retries
- D. Set a timeout of 100 ms; that leaves 400 ms for the other two downstream APIs to complete
Answer: A
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
NEW QUESTION # 58
An insurance company is using a CIoudHub runtime plane. As a part of requirement, email alert should be sent to internal operations team every time of policy applied to an API instance is deleted As an integration architect suggest on how this requirement be met?
- A. Implement a new application that uses the Audit log REST API to
- B. Use Anypoint monitoring to configure an alert that sends an email to the operations team every time a policy is deleted in API manager
- C. Create a custom connector to be triggered every time of policy is deleted in API manager
- D. Use audit logs in Anypoint platform to detect a policy deletion and configure the Audit logs alert feature to send an email to the operations team
Answer: A
Explanation:
detect the policy deletion and send an email to operations team the SMTP connector
NEW QUESTION # 59
An IT integration tram followed an API-led connectivity approach to implement an order-fulfillment business process. It created an order processing AP that coordinates stateful interactions with a variety of microservices that validate, create, and fulfill new product orders Which interaction composition pattern did the integration architect who designed this order processing AP| use?
- A. Aggregation
- B. Orchestration
- C. Multicasting
- D. Streaming
Answer: B
NEW QUESTION # 60
A Mule application is being designed to do the following:
Step 1: Read a SalesOrder message from a JMS queue, where each SalesOrder consists of a header and a list of SalesOrderLineltems.
Step 2: Insert the SalesOrder header and each SalesOrderLineltem into different tables in an RDBMS.
Step 3: Insert the SalesOrder header and the sum of the prices of all its SalesOrderLineltems into a table In a different RDBMS.
No SalesOrder message can be lost and the consistency of all SalesOrder-related information in both RDBMSs must be ensured at all times.
What design choice (including choice of transactions) and order of steps addresses these requirements?
- A. 1) Read and acknowledge the JMS message (NOT in an XA transaction)
2) In a NEW XA transaction, perform BOTH DB inserts - B. 1) Read the JMS message in an XA transaction
2) In the SAME XA transaction, perform BOTH DB inserts but do NOT acknowledge the JMS message - C. 1) Read the JMS message (NOT in an XA transaction)
2) Perform EACH DB insert in a SEPARATE DB transaction
3) Acknowledge the JMS message - D. 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: D
Explanation:
* 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)
NEW QUESTION # 61
......
Most Reliable Salesforce MuleSoft-Integration-Architect-I Training Materials: https://certkingdom.vce4dumps.com/MuleSoft-Integration-Architect-I-latest-dumps.html