- Email support@dumps4free.com
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.
Explanation:
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
In which order are the API Client, API Implementation, and API interface components called in a typical REST request?
A. API Client > API implementation > API Interface
B. API interface > API Client > API Implementation
C. API Client > API Interface > API implementation
D. API Implementation > API Interface > API Client
Explanation:
In a typical REST request, the order of interaction is:
API Client: The client initiates the request to access data or functionality exposed by the API.
API Interface: This represents the contract or the definition of the API, often specified in OpenAPI or RAML. It defines the endpoints, request/response formats, and other API details.
API Implementation: This is the actual backend logic that processes the request and returns the response. It interacts with databases, other services, or performs business logic to fulfill the request.
References:
Understanding REST APIs
API Design and Implementation
Mule application A receives a request Anypoint MQ message REQU with a payload containing a variable-length list of request objects. Application A uses the For Each scope to split the list into individual objects and sends each object as a message to an Anypoint MQ queue.
Service S listens on that queue, processes each message independently of all other messages, and sends a response message to a response queue.
Application A listens on that response queue and must in turn create and publish a response Anypoint MQ message RESP with a payload containing the list of responses sent by service S in the same order as the request objects originally sent in REQU.
Assume successful response messages are returned by service S for all request messages.
What is required so that application A can ensure that the length and order of the list of objects in RESP and REQU match, while at the same time maximizing message throughput?
A. Use a Scatter-Gather within the For Each scope to ensure response message order Configure the Scatter-Gather with a persistent object store
B. Perform all communication involving service S synchronously from within the For Each scope, so objects in RESP are in the exact same order as request objects in REQU
C. Use an Async scope within the For Each scope and collect response messages in a second For Each scope in the order In which they arrive, then send RESP using this list of responses
D. Keep track of the list length and all object indices in REQU, both in the For Each scope and in all communication involving service Use persistent storage when creating RESP
Explanation
Correct answer is Perform all communication involving service S synchronously from within the For Each scope, so objects in RESP are in the exact same order as request objects in REQU Explanation : Using Anypoint MQ, you can create two types of queues: Standard queue These queues don’t guarantee a specific message order. Standard queues are the best fit for applications in which messages must be delivered quickly. FIFO (first in, first out) queue These queues ensure that your messages arrive in order. FIFO queues are the best fit for applications requiring strict message ordering and exactly-once delivery, but in which message delivery speed is of less importance Use of FIFO queue is no where in the option and also it decreased throughput. Similarly persistent object store is not the preferred solution approach when you maximizing message throughput. This rules out one of the options. Scatter Gather does not support ObjectStore. This rules out one of the options. Standard Anypoint MQ queues don’t guarantee a specific message order hence using another for each block to collect response wont work as requirement here is to ensure the order. Hence considering all the above factors the feasible approach is Perform all communication involving service S synchronously from within the For Each scope, so objects in RESP are in the exact same order as request objects in REQU
According to MuteSoft, which principle is common to both Service Oriented Architecture (SOA) and API-led connectivity approaches?
A. Service centralization
B. Service statefulness
C. Service reusability
D. Service interdependence
Explanation:
Both Service Oriented Architecture (SOA) and API-led connectivity emphasize the principle of service reusability. This principle involves designing services and APIs in a way that they can be reused across different applications and use cases, reducing redundancy and improving efficiency. By creating reusable services, organizations can accelerate development, maintain consistency, and reduce costs associated with developing and maintaining multiple similar services.
References:
MuleSoft's API-led Connectivity Approach
Service-Oriented Architecture (SOA) Principles
An API client makes an HTTP request to an API gateway with an Accept header containing the value’’ application’’. What is a valid HTTP response payload for this request in the client requested data format?
A. healthy
B. {"status" "healthy"}
C. status(‘healthy")
D. status: healthy
Explanation:
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:
healthy 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
| Page 16 out of 54 Pages |
| Previous |