Mulesoft MCIA-LEVEL1 Online Practice Questions and Exam Preparation

Mulesoft MCIA-LEVEL1 Online Questions & Answers

• Question 281:

  An airline is architecting an API connectivity project to integrate its flight data into an online aggregation website. The interface must allow for secure communication high-performance and asynchronous message exchange.

  What are suitable interface technologies for this integration assuming that Mulesoft fully supports these technologies and that Anypoint connectors exist for these interfaces?

  A. AsyncAPI over HTTPS AMQP with RabbitMQ JSON/REST over HTTPS
  B. XML over ActiveMQ XML over SFTP XML/REST over HTTPS
  C. CSV over FTP YAM L over TLS JSON over HTTPS
  D. SOAP over HTTPS HOP over TLS gRPC over HTTPS
  A. AsyncAPI over HTTPS AMQP with RabbitMQ JSON/REST over HTTPS

• Question 282:

  Which Anypoint Platform component is responsible for enforcing runtime API policies such as rate limiting and client ID enforcement?

  A. Anypoint Studio
  B. Runtime Manager
  C. API Manager
  D. Anypoint Exchange
  C. API Manager

  ---

  API Manager is used to apply and manage policies at runtime, including security, traffic management, and governance policies.

• Question 283:

  An organization plans to migrate all its Mule applications to Runtime Fabric (RTF). Currently, all Mule applications have been deployed to CloudHub using automated CI/CD scripts. What steps should be taken to properly migrate the applications from CloudHub to RTF, while keeping the same automated CI/CD deployment strategy?

  A. A runtimeFabric dependency should be added as a mule-plugin to the pom.xml file in all the Mule applications.
  B. A runtimeFabric command-line parameter should be added to the CI/CD deployment scripts.
  C. A runtimeFabricDeployment profile should be added to Mule configuration properties YAML files in all the Mule applications. CI/CD scripts must be modified to use the new configuration properties.
  D. A runtimeFabricDeployment profile should be added to the pom.xml file in all the Mule applications. CI/CD scripts must be modified to use the new RTF profile.
  E. The pom.xml and Mule configuration YAML files can remain unchanged in each Mule application. A --runtimeFabric command-line parameter should be added to the CI/CD deployment scripts.
  D. A runtimeFabricDeployment profile should be added to the pom.xml file in all the Mule applications. CI/CD scripts must be modified to use the new RTF profile.

  ---

  To migrate Mule applications from CloudHub to Runtime Fabric (RTF) while maintaining the same automated CI/CD deployment strategy, follow these steps:

  Add runtimefabricDeployment Profile: Add a runtimefabricDeployment profile to the pom.xml file in all Mule applications. This profile will include the necessary configurations specific to RTF deployments.

  Modify CI/CD Scripts: Update the CI/CD deployment scripts to use the new runtimefabricDeployment profile. This modification ensures that the deployment process will correctly reference the RTF-specific configurations when deploying applications.

  Keep Configuration Files Unchanged: There is no need to change the pom.xml and Mule configuration YAML files other than adding the runtimefabricDeployment profile. This maintains consistency and reduces the risk of errors during the migration.

  This approach ensures a smooth transition to RTF while leveraging existing CI/CD scripts with minimal changes, maintaining the automated deployment strategy.

  References

  MuleSoft Documentation on Runtime Fabric Deployment Best Practices for CI/CD with MuleSoft

• Question 284:

  What aspects of a CI/CD pipeline for Mule applications can be automated using MuleSoft- provided Maven plugins?

  A. Compile, package, unit test, validate unit test coverage, deploy
  B. Compile, package, unit test, deploy, integration test (Incorrect)
  C. Compile, package, unit test, deploy, create associated API instances in API Manager
  D. Import from API designer, compile, package, unit test, deploy, publish to Anypoint Exchange
  A. Compile, package, unit test, validate unit test coverage, deploy

  ---

  Correct answer is "Compile, package, unit test, validate unit test coverage, deploy": Anypoint Platform supports continuous integration and continuous delivery using industry standard tools Mule Maven Plugin The Mule Maven plugin can automate building, packaging and deployment of Mule applications from source projects Using the Mule Maven plugin, you can automate your Mule application deployment to CloudHub, to Anypoint Runtime Fabric, or on-premises, using any of the following deployment strategies ?CloudHub deployment ?Runtime Fabric deployment ?Runtime Manager REST API deployment ?Runtime Manager agent deployment MUnit Maven Plugin The MUnit Maven plugin can automate test execution, and ties in with the Mule Maven plugin. It provides a full suite of integration and unit test capabilities, and is fully integrated with Maven and Surefire for integration with your continuous deployment environment. Since MUnit 2.x, the coverage report goal is integrated with the maven reporting section. Coverage Reports are generated during Maven's site lifecycle, during the coverage-report goal. One of the features of MUnit Coverage is to fail the build if a certain coverage level is not reached. MUnit is not used for integration testing Also publishing to Anypoint Exchange or to create associated API instances in API Manager is not a part of CICD pipeline which can ne achieved using mulesoft provided maven plugin Architecture mentioned in the question can be diagrammatically put as below. Persistent Object Store is the correct answer .

  # Mule Object Stores: 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. So we cant use in memory store in our scenario as we want to share watermark within all cloudhub workers

  2) Persistent store ?Mule persists data when an object store is explicitly configured to be persistent. Hence this watermark will be available even any of the worker goes down

  

• Question 285:

  What condition requires using a CloudHub Dedicated Load Balancer?

  A. When cross-region load balancing is required between separate deployments of the same Mule application
  B. When custom DNS names are required for API implementations deployed to customer- hosted Mule runtimes
  C. When API invocations across multiple CloudHub workers must be load balanced
  D. When server-side load-balanced TLS mutual authentication is required between API implementations and API clients
  D. When server-side load-balanced TLS mutual authentication is required between API implementations and API clients

  ---

  Correct answer is When server-side load-balanced TLS mutual authentication is required between API implementations and API clients CloudHub dedicated load balancers (DLBs) are an optional component of Anypoint Platform that enable you to route external HTTP and HTTPS traffic to multiple Mule applications deployed to CloudHub workers in a Virtual Private Cloud (VPC). Dedicated load balancers enable you to: # Handle load balancing among the different CloudHub workers that run your application.

  # Define SSL configurations to provide custom certificates and optionally enforce two-way SSL client authentication. # Configure proxy rules that map your applications to custom domains. This enables you to host your applications under a single domain

• Question 286:

  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 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
  B. 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
  C. 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
  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
  B. 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

  ---

  Correct answer is "The web store backend generates a new correlation ID value at the start of checkout and sets it on the XORRELATION-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

  https://help.mulesoft.com/s/article/How-to-Set-Custom-Correlation-Id-for-Flows-with-HTTP-Endpoint-in-Mule-4

  

• Question 287:

  What operation can be performed through a JMX agent enabled in a Mule application?

  A. View object store entries
  B. Replay an unsuccessful message
  C. Set a particular tog4J2 log level to TRACE
  D. Deploy a Mule application
  C. Set a particular tog4J2 log level to TRACE

  ---

  JMX Management Java Management Extensions (JMX) is a simple and standard way to manage applications, devices, services, and other resources. JMX is dynamic, so you can use it to monitor and manage resources as they are created, installed, and implemented. You can also use JMX to monitor and manage the Java Virtual Machine (JVM). Each resource is instrumented by one or more Managed Beans, or MBeans. All MBeans are registered in an MBean Server. The JMX server agent consists of an MBean Server and a set of services for handling Mbeans. There are several agents provided with Mule for JMX support. The easiest way to configure JMX is to use the default JMX support agent. Log4J Agent The log4j agent exposes the configuration of the Log4J instance used by Mule for JMX management. You enable the Log4J agent using the element. It does not take any additional properties MuleSoft

  https://docs.mulesoft.com/mule-runtime/3.9/jmx-management

• Question 288:

  An organization is adopting API-led connectivity and wants to ensure that multiple teams can independently reuse backend capabilities without impacting each other. Which design principle best supports this goal when building System APIs?

  A. Embedding business rules directly in the System API
  B. Exposing backend systems through stable, contract-first APIs
  C. Allowing direct database access to consuming applications
  D. Implementing long-running transactions in the System API
  B. Exposing backend systems through stable, contract-first APIs

  ---

  System APIs are intended to provide a stable, reusable abstraction over systems of record. Designing them using a contract-first approach with stable interfaces allows multiple consumers to reuse the same APIs without being affected by backend implementation changes. Embedding business logic or exposing databases directly reduces reusability and increases coupling.

• Question 289:

  A stock trading company handles millions of trades a day and requires excellent performance and reliability within its stock trading system. The company operates a number of event-driven APIs Implemented as Mule applications that are hosted on various customer-hosted Mule clusters and needs to enable message exchanges between the APIs within their internal network using shared message queues. What is an effective way to meet the cross-cluster messaging requirements of its event-driven APIs?

  A. Non-transactional JMS operations with a reliability pattern and manual acknowledgements
  B. Persistent VM queues with automatic acknowledgements
  C. JMS transactions with automatic acknowledgements
  D. extended Architecture (XA) transactions and XA connected components with manual acknowledgements
  C. JMS transactions with automatic acknowledgements

  ---

  JMS (Java Message Service): JMS is a robust messaging standard that supports reliable and asynchronous communication. It allows message producers and consumers to exchange messages via a common message broker.

  Transactions with Automatic Acknowledgements: Utilizing JMS transactions ensures that messages are processed reliably. The automatic acknowledgement mode means that once the consumer receives the message, it acknowledges the broker automatically, ensuring that no messages are lost.

  Performance and Reliability: JMS transactions offer both high performance and reliability. By enabling transactions, each message processing step can be committed or rolled back, ensuring data integrity.

  Cross-Cluster Messaging: For a stock trading company dealing with millions of trades, using JMS transactions allows for consistent and reliable message delivery across different clusters in their network. This approach is more suitable compared to non-transactional or VM queues due to the scale and reliability requirements.

  Event-Driven APIs: The APIs can leverage the transactional nature of JMS to ensure that messages exchanged between different services are reliable and can recover gracefully from failures.

  References: MuleSoft Documentation on JMS Connector: MuleSoft JMS Connector JMS 2.0 Specification: Oracle JMS 2.0

• Question 290:

  Refer to the exhibit.

  

  A Mule application is deployed to a cluster of two customer-hosted Mute runtimes. The Mute application has a flow that polls a database and another flow with an HTTP Listener.

  HTTP clients send HTTP requests directly to individual cluster nodes.

  What happens to database polling and HTTP request handling in the time after the primary (master) node of the cluster has railed, but before that node is restarted?

  A. Database polling continues Only HTTP requests sent to the remaining node continue to be accepted
  B. Database polling stops All HTTP requests continue to be accepted
  C. Database polling continues All HTTP requests continue to be accepted, but requests to the failed node Incur increased latency
  D. Database polling stops All HTTP requests are rejected
  A. Database polling continues Only HTTP requests sent to the remaining node continue to be accepted

  ---

  Correct answer is Database polling continues Only HTTP requests sent to the remaining node continue to be accepted.: Architecture descripted in the question could be described as follows.When node 1 is down , DB polling will still continue via node 2 . Also requests which are coming directly to node 2 will also be accepted and processed in BAU fashion. Only thing that wont work is when requests are sent to Node 1 HTTP connector. The flaw with this architecture is HTTP clients are sending HTTP requests directly to individual cluster nodes. By default, clustering Mule runtime engines ensures high system availability. If a Mule runtime engine node becomes unavailable due to failure or planned downtime, another node in the cluster can assume the workload and continue to process existing events and messages