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

Explanation

Lets analyze the situation in regards to the different options available Option : A common Experience API but separate Process APIs Analysis : This solution will not work because having common experience layer will not help the purpose as mobile and web applications will have different set of requirements which cannot be fulfilled by single experience layer API

Option : Common Process API Analysis : This solution will not work because creating a common process API will impose limitations in terms of flexibility to customize API;s as per the requirements of different applications. It is not a recommended approach.

Option : Separate set of API's for both the applications Analysis : This goes against the principle of Anypoint API-led connectivity approach which promotes creating reusable assets. This solution may work but this is not efficient solution and creates duplicity of code.

Hence the correct answer is: Separate Experience APIs for the mobile and web app, but a common Process API that invokes separate System APIs created for the database and CRM system

Lets analyze the situation in regards to the different options available Option : A common Experience API but separate Process APIs Analysis : This solution will not work because having common experience layer will not help the purpose as mobile and web applications will have different set of requirements which cannot be fulfilled by single experience layer API

Option : Common Process API Analysis : This solution will not work because creating a common process API will impose limitations in terms of flexibility to customize API;s as per the requirements of different applications. It is not a recommended approach.

Option : Separate set of API's for both the applications Analysis : This goes against the principle of Anypoint API-led connectivity approach which promotes creating reusable assets. This solution may work but this is not efficient solution and creates duplicity of code.

Hence the correct answer is: Separate Experience APIs for the mobile and web app, but a common Process API that invokes separate System APIs created for the database and CRM system

Explanation

* "The existence of a public Anypoint Exchange portal to which the asset has been published" - question does not mention anything about the public portal. Beside the public portal is open to the internet, to anyone. * If you cannot find an asset in the current business group scopes, search in other scopes. In the left navigation bar click All assets (assets provided by MuleSoft and your own master organization), Provided by MuleSoft, or a business group scope. User belonging to one Business Group can see assets related to his group only Reference: https://docs.mulesoft.com/exchange/to-find-info https://docs.mulesoft.com/exchange/asset-details Correct answer is The business groups to which the user belongs

To meet the requirements of enriching logging with more context and improving throughput while reducing latency, the customer should use an asynchronous logging approach. Here's why option B is correct:

Async Logger: Asynchronous logging helps in improving the performance by decoupling the logging from the main thread of execution. This reduces the latency of message processing since logging operations are offloaded to a separate thread.

Logging Level Greater than INFO: Logging at levels such as WARN, ERROR, or FATAL ensures that only essential logs are written asynchronously, further enhancing performance. Avoiding DEBUG or TRACE levels unless necessary reduces the overhead of logging.

Pattern Layout with [%MDC]: Using the pattern layout with [%MDC] in the log4j2.xml configuration file allows the inclusion of mapped diagnostic context in the logs. MDC is a feature that provides context-specific information, such as transaction IDs or user IDs, which helps in tracing and debugging.

Example configuration in log4j2.xml:

This configuration ensures that the logs are enriched with context information provided by MDC and processed asynchronously to maintain high throughput and low latency.

References

Log4j2 Asynchronous Logging

Mapped Diagnostic Context (MDC) in Log4j2

Explanation

* Shared load balancers don’t allow you to configure custom SSL certificates or proxy rules

* Dedicated Load Balancer are optional but you need to purchase them additionally if needed.

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

* The CloudHub Shared Load Balancer terminates TLS connections and uses its own server-side certificate.

* Only a DLB allows the configuration of a custom TLS server certificate

* DLB enables you to define SSL configurations to provide custom certificates and optionally enforce two-way SSL client authentication.

* To use a DLB in your environment, you must first create an Anypoint VPC. Because you can associate multiple environments with the same Anypoint VPC, you can use the same dedicated load balancer for your different environments.

* MuleSoft Reference: https://docs.mulesoft.com/runtime-manager/dedicated-load-balancer-tutorial

Additional Info on SLB Vs DLB:

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.

To support the company's goals of unlocking key systems and data, quickly deploying scalable APIs, and connecting to on-premises systems, while also preparing for future migrations, the best runtime deployment option is using Runtime Fabric on self-managed Kubernetes. Here's why:

Scalability: Kubernetes is designed to scale applications easily and efficiently. By deploying Mule runtimes on a self-managed Kubernetes cluster, the company can dynamically scale its APIs based on demand, ensuring performance and reliability.

Flexibility: Running on self-managed Kubernetes allows the company to have control over the infrastructure. They can customize the environment to meet their specific needs, integrate with existing on-premises systems, and support their microservices architecture running in Docker containers.

Future-Proofing: Kubernetes supports hybrid and multi-cloud deployments, making it easier to migrate workloads between different environments as needed. This aligns with the company's goal of being able to migrate their systems as part of their strategic approach.

Efficiency: By leveraging Kubernetes, the company can automate deployment, scaling, and management of containerized applications, reducing the burden on IT and DevOps teams.

MuleSoft Documentation on Runtime Fabric: https://docs.mulesoft.com/runtime-fabric/1.9/

Kubernetes Documentation: https://kubernetes.io/docs/home/

Try-Catch Scope for Data Fetching:

Implement a try-catch scope to handle any errors that may occur while fetching account balances from the backend application. This ensures that the main process flow can handle exceptions gracefully without failing entirely.

Async Scope for Inserting Records into Audit Database:

Use the Async scope within the try-catch block to insert records into the audit database. The Async scope allows operations to be performed asynchronously, ensuring that the insertion process does not block the main thread of execution.

By doing this, the primary flow of fetching account balances remains unaffected and can achieve higher throughput as the auditing process runs concurrently.

Ensuring Better Throughput:

The async processing ensures that the time-consuming database insertion for auditing purposes does not impede the performance of the main flow, which is crucial for real-time or near-real-time systems.

To securely consume compressed and digitally signed files from a partner's FTPS server, the following inputs are required:

PGP Public Key of the Partner:

Purpose: Used to verify the digital signature of the files received from the partner. This ensures that the files were indeed sent by the partner and have not been tampered with.

Implementation: Import the partner’s PGP public key into the Mule application.

PGP Private Key for the Company:

Purpose: Used to decrypt the files that were encrypted by the partner using the company's public key. This ensures that only the intended recipient (the company) can access the contents of the files.

Implementation: Configure the Mule application to use the company’s PGP private key for decryption.

FTP Username and Password:

Purpose: Used to authenticate and establish a connection to the partner's FTPS server. The credentials ensure that only authorized users can access the server.

Implementation: Provide the FTP credentials in the Mule application's FTPS connector configuration.

By using these inputs, the Mule application can securely connect to the FTPS server, verify the integrity and authenticity of the files using PGP, and decrypt the contents for further processing.

References

MuleSoft FTPS Connector

MuleSoft PGP Module

For handling large datasets in a Mule application, streaming is an effective strategy. Streaming allows the application to process large amounts of data in chunks, reducing memory usage and improving performance. Using a file storage repeatable strategy for reading records from the database ensures that the data is read in manageable chunks and stored temporarily in files, which can be re-read if necessary, enhancing reliability.

The batch aggregator with streaming to write to an FTPS server ensures that data is written in chunks, aligning with the processing capabilities of the application running in CloudHub with 0.2 vCore and 8 GB storage. This configuration optimizes performance by balancing the load and managing the dataset size effectively, ensuring that the high rate of records can be processed and written to the FTPS server without overwhelming the system.

MuleSoft Documentation on Streaming

MuleSoft Documentation on Batch Processing