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?

• A.Order messages are sent to an Anypoint MQ exchange
  OrderFulfilted 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 toad of both microservices
• B.Older 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 toad each microservice
• C.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
• 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

Correct Answer: D

* 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:

Comment: *

Name: *

Email: *

Verification: *

A Mule application contains a Batch Job with two Batch Steps (Batch_Step_1 and Batch_Step_2). A payload with 1000 records is received by the Batch Job.
How many threads are used by the Batch Job to process records, and how does each Batch Step process records within the Batch Job?

• A.Each Batch Job uses SEVERAL THREADS for the Batch Steps
  Each Batch Step instance receives ONE record at a time as the payload, and BATCH STEP INSTANCES execute IN PARALLEL to process records and Batch Steps in ANY order as fast as possible
• B.Each Batch Job uses SEVERAL THREADS for the Batch Steps
  Each Batch Step instance receives ONE record at a time as the payload, and RECORDS are processed IN PARALLEL within and between the two Batch Steps
• C.Each Batch Job uses a SINGLE THREAD for all Batch Steps
  Each Batch Step instance receives ONE record at a time as the payload, and RECORDS are processed IN ORDER, first through Batch_Step_1 and then through Batch_Step_2
• D.Each Batch Job uses a SINGLE THREAD to process a configured block size of record Each Batch Step instance receives A BLOCK OF records as the payload, and BLOCKS of records are processed IN ORDER

Comment: *

Name: *

Email: *

Verification: *

What limits if a particular Anypoint Platform user can discover an asset in Anypoint Exchange?

• A.Design Center and RAML were both used to create the asset
• B.The existence of a public Anypoint Exchange portal to which the asset has been published
• C.The type of the asset in Anypoint Exchange
• D.The business groups to which the user belongs

Comment: *

Name: *

Email: *

Verification: *

The implementation of a Process API must change. What is a valid approach that minimizes the impact of this change on API clients?

• A.Implement required changes to the Process API implementation so that whenever possible, the Process API's RAML definition remains unchanged
• B.Update the RAML definition of the current Process API and notify API client developers by sending them links to the updated RAML definition
• C.Postpone changes until API consumers acknowledge they are ready to migrate to a new Process API or API version
• D.Implement the Process API changes in a new API implementation, and have the old API implementation return an HTTP status code 301 - Moved Permanently to inform API clients they should be calling the new API implementation

Comment: *

Name: *

Email: *

Verification: *

Refer to the exhibit.
A Mule application is deployed to a multi-node Mule runtime cluster. The Mule application uses the competing consumer pattern among its cluster replicas to receive JMS messages from a JMS queue. To process each received JMS message, the following steps are performed in a flow:
Step l: The JMS Correlation ID header is read from the received JMS message.
Step 2: The Mule application invokes an idempotent SOAP webservice over HTTPS, passing the JMS Correlation ID as one parameter in the SOAP request.
Step 3: The response from the SOAP webservice also returns the same JMS Correlation ID.
Step 4: The JMS Correlation ID received from the SOAP webservice is validated to be identical to the JMS Correlation ID received in Step 1.
Step 5: The Mule application creates a response JMS message, setting the JMS Correlation ID message header to the validated JMS Correlation ID and publishes that message to a response JMS queue.
Where should the Mule application store the JMS Correlation ID values received in Step 1 and Step 3 so that the validation in Step 4 can be performed, while also making the overall Mule application highly available, fault-tolerant, performant, and maintainable?

• A.The Correlation ID value in Step 1 should be stored in a persistent object store The Correlation ID value in step 3 should be stored as a Mule event vanable/attnbute
• B.Both Correlation ID values should be stored in a persistent object store
• C.Both Correlation ID values should be stored In a non-persistent object store
• D.Both Correlation ID values should be stored as Mule event vanabtes/attnbutes

Comment: *

Name: *

Email: *

Verification: *