AD0-E134 Sample Questions Answers

To resolve the domain name by the dispatcher, you should configure it in the vhosts file. The vhosts file is part of the Apache HTTP server configuration and allows you to define how requests for different domain names are handled. This is crucial for setting up virtual hosts, which is essential for resolving domain names and directing them to the appropriate content served by your AEM instance.

Here are the detailed steps to configure domain name resolution in the vhosts file:

Locate the vhosts file: The file is typically located in the conf directory of your Apache HTTP server installation. Common paths are:

/etc/httpd/conf/httpd.conf (on many Linux systems)

/usr/local/apache2/conf/httpd.conf (if installed from source)

Edit the vhosts file: Open the file with a text editor. You might need superuser permissions to edit this file.

Add a VirtualHost directive: Define a new VirtualHost block for your domain. For example:

ServerName www.example.com

ServerAlias example.com

DocumentRoot "/path/to/your/document/root"

# Dispatcher configuration

SetHandler dispatcher-handler

ModMimeUsePathInfo On

AllowOverride None

Options FollowSymLinks

Require all granted

 ServerName specifies the primary domain name.

ServerAlias allows you to specify additional names that should resolve to the same content.

DocumentRoot specifies the directory from which the content should be served.

The section includes the Dispatcher handler configuration.

 Restart Apache: After saving the changes to the vhosts file, restart the Apache server to apply the changes.

sudo systemctl restart httpd

# or

sudo service apache2 restart

References:

Adobe Experience Manager Dispatcher Configuration

Apache HTTP Server Documentation on VirtualHost

The includeCommerce property is a boolean flag that indicates whether to include Commerce Core Components in the project or not. If set to y, the command will generate a commerce module that contains specific Commerce Core Components and their dependencies. These components can be used to integrate AEM with Adobe Commerce platform or other commerce solutions. References: https://experienceleague.adobe.com/docs/experience-manager-core-components/using/developing/archetype/using.html?lang=en#properties https://experienceleague.adobe.com/docs/experience-manager-core-components/using/components/commerce.html?lang=en

The aemanalyser-maven-plugin is a Maven plugin that checks if all the requirements declarations made in OSGi bundles are satisfied by the capabilities declarations of other bundles included in the Maven project. This plugin ensures that the OSGi bundles are consistent and can be resolved at runtime. The plugin also checks for other issues such as API compatibility, package versioning, and bundle start order. References: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/developing/aem-project-content-package-structure.html?lang=en#build-analyzer-maven-plugin https://github.com/adobe/aemanalyser-maven-plugin

To push a code fix into the current release candidate, the best practice is to cherry-pick the fix commit into the release candidate branch. Cherry-picking allows you to apply specific changes from one branch to another, ensuring that only the necessary fixes are included without introducing unrelated changes.

Here’s how to cherry-pick a commit:

Identify the Commit: Locate the commit hash of the fix you need to apply. This can be found in your version control system (e.g., Git).

Checkout the Release Candidate Branch:

git checkout release-candidate-branch

Cherry-pick the Commit:

git cherry-pick

Resolve Conflicts(if any): If there are conflicts, resolve them manually and then continue the cherry-pick process:

git add

git cherry-pick --continue

 Test the Changes: Ensure that the changes are tested thoroughly in the release candidate environment to confirm the fix works as expected.

 Push the Changes:

git push origin release-candidate-branch

Cherry-picking ensures that only the required changes are applied to the release candidate, maintaining the stability and integrity of the codebase.

References:

Git Cherry-pick Documentation

A content fragment is a reusable piece of content that can be authored and managed independently from a page. Content fragments are based on structured data models that define the elements and data types of the content. Content fragments can be delivered as JSON using various APIs, such as Assets HTTP API, Content Fragments REST API, or Content Fragments GraphQL API. Content fragments are suitable for creating multi-channel applications that use AEM as a headless CMS. References: https://experienceleague.adobe.com/docs/experience-manager-learn/foundation/headless/introduction-to-headless.html?lang=en https://experienceleague.adobe.com/docs/experience-manager-65/assets/fragments/content-fragments.html?lang=en

Embedding client libraries is a technique that allows combining code from multiple client libraries into a single file. This reduces the number of network requests and improves performance. Embedding client libraries can be done by using the embed property of the cq:ClientLibraryFolder node and specifying the categories of the client libraries to be embedded. References: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/content/implementing/developing/full-stack/clientlibs.html?lang=en#embed https://experienceleague.adobe.com/docs/experience-manager-65/developing/introduction/clientlibs.html?lang=en#embedded-files

Code Quality testing and UI testing are two types of testing that are available OOB in AEM Cloud Manager Pipeline. Code Quality testing checks the code quality of the project using SonarQube and reports any issues or vulnerabilities. UI testing checks the functionality and usability of the project using Selenium WebDriver and reports any errors or failures. References: https://experienceleague.adobe.com/docs/experience-manager-cloud- service/implementing/testing/testing-overview.html?lang=en#testing-types https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/testing/code-quality-testing.html?lang=en https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/testing/ui-testing.html?lang=en

Maximum Parallel Jobs is a configuration property that controls how many workflows can run concurrently on an AEM instance. Reducing this value can help to avoid overloading the server with too many workflows.

The recommended path to override /libs standard functionality is /apps. The /apps folder contains application-specific code and configuration that can extend or override the default functionality provided by /libs. The /apps folder has precedence over the /libs folder, meaning that if there are two resources with the same path under both folders, the one under /apps will be used. References: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/developing/aem-project-content-package-structure.html?lang=en#repository-restrictions https://experienceleague.adobe.com/docs/experience-manager-learn/foundation/development/set-up-a-local-aem-development-environment.html?lang=en#the-aem-repository

When building out a project using the most recent AEM Archetype, the ui.frontend module is optional. The ui.frontend module is typically used for integrating front-end build processes, such as those involving npm, Webpack, or other front-end tooling. If your project does not require such front-end tooling, you can omit this module.

Here is a breakdown of the archetype modules:

it.launcher: This module is used for integration tests and is required if you need to run automated tests as part of your build process.

ui.frontend: This module includes front-end tooling and build processes. It is optional and can be omitted if your project does not involve complex front-end development.

ui.tests: This module includes unit and integration tests for the UI part of your AEM project. It is often required for testing purposes.

ui.content: This module includes the content structures and initial content for your AEM project. It is generally required to set up the content for your project.

References:

AEM Project Archetype

AEM Development Best Practices

The aemVersion property specifies the target AEM version for the project. To create a project based on AEM as a Cloud Service SDK, the value should be set to cloud. The sdkVersion property specifies the AEM as a Cloud Service SDK version to use for local development. To use a specific SDK version, the value should be set to the exact version number, such as 2022.5.7575.20220530T152407Z-220401. References: https://experienceleague.adobe.com/docs/experience-manager-core-components/using/developing/archetype/using.html?lang=en#properties https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/developing/aem-as-a-cloud-service-sdk.html?lang=en#sdk-versions

Using transient workflows is a key factor in optimizing the design for processing a high volume of content ingestion on the author server. Transient workflows do not persist their state to the repository, which significantly reduces the overhead on the JCR (Java Content Repository). This leads to improved performance and efficiency, especially under high-content ingestion scenarios.

Here’s why transient workflows are beneficial:

Reduced Repository Writes: Since transient workflows do not persist intermediate states, the number of writes to the repository is minimized. This reduces the I/O load and speeds up the processing.

Improved Performance: By avoiding the persistence of states, transient workflows execute faster, leading to quicker content processing and less latency.

Resource Efficiency: Transient workflows consume fewer resources compared to their non-transient counterparts, making them more efficient in handling large volumes of content.

Steps to create a transient workflow:

Define Workflow Model: Create a new workflow model or edit an existing one in AEM Workflow console.

Set Workflow to Transient: In the workflow model editor, set the workflow model to be transient by marking the relevant option in the workflow properties.

Implement Workflow Logic: Add the necessary steps and logic to the workflow model, keeping in mind that intermediate states will not be saved.

Deploy and Test: Deploy the workflow and test it under high-content ingestion scenarios to ensure optimal performance.

References:

Adobe Experience Manager Workflows

Best Practices for AEM Workflows

Creating a heap dump and a thread dump are two steps that should be taken after confirming the problem is related to a memory issue. A heap dump is a snapshot of the memory usage of the Java Virtual Machine (JVM) at a given point in time. A heap dump can be used to identify memory leaks, memory consumption patterns, and objects that occupy large amounts of memory. A thread dump is a snapshot of the state of all threads that are part of the JVM process. A thread dump can be used to identify deadlocks, blocked threads, and CPU-intensive threads. References: https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/memory-analysis.html?lang=en https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/thread-dump-analysis.html?lang=en

To debug a CQ HTML client library in the AEM author instance, you need to add the query parameter debugClientLibs set to true. This parameter instructs AEM to include additional debugging information for client libraries, making it easier to troubleshoot issues with JavaScript, CSS, and other assets.

Steps to enable client library debugging:

Open the AEM Page: Navigate to the AEM page where you want to debug the client libraries.

Append the Query Parameter: Add ?debugClientLibs=true to the URL. For example:

http://localhost:4502/content/we-retail/us/en.html?debugClientLibs=true

Reload the Page: Refresh the browser page. AEM will now include debugging information for client libraries.

This parameter helps in identifying issues with client library loading, dependencies, and other client-side resources.

References:

Debugging Client Libraries in AEM

The warning WARN* Traversed 1000 nodes with filter Filter (query=select…) indicates that the query is performing a traversal instead of using an index. This results in poor performance, especially when the client has a large number of nodes (e.g., more than 100,000).

To resolve this issue, you should create a custom Oak index for the custom page property. This ensures that the queries can leverage the index for efficient data retrieval.

Steps to create a custom Oak index:

Define the Oak Index:

Navigate to the /oak:index node in CRXDE Lite (http://localhost:4502/crx/de).

Create a new node of type oak:QueryIndexDefinition.

Configure the Index:

Set the properties of the new index node to define the indexing rules for the custom page property.

{

"jcr:primaryType": "oak:QueryIndexDefinition",

"type": "property",

"propertyNames": ["customPageProperty"],

"reindex": true,

"async": "async"

}

Deploy and Reindex:

Save the changes and initiate a reindexing process.

Ensure that the reindex flag is set to true for the newly created index.

Validate the Index:

Use the Index Manager or the AEM Web Console to validate that the new index is enabled and functioning correctly.

By creating a custom Oak index for the custom page property, the queries will be optimized to use the index, significantly improving the search performance and resolving the client's issue.

References:

Adobe Experience Manager - Oak Indexing

Apache Jackrabbit Oak - Indexing

The Auto Replicate via On Off Trigger Configuration is a feature that allows content to be replicated as soon as the On Time and Off Times are reached. This feature can be enabled by creating an OSGi configuration for the com.day.cq.wcm.core.impl.servlets.OnOffTimeServlet service. This service listens for changes in the On Time and Off Time properties of pages and triggers replication accordingly. References: https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/replication.html?lang=en#on-off-time https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/replication.html?lang=en#auto-replication

To implement a new component called "Page Headline" which takes the text from the current page title instead of jcr:title, you should create a proxy component from the core title component and implement a Sling Model accordingly. Option C demonstrates the correct approach to achieve this functionality.

Here is a detailed explanation of Option C:

Create Proxy Component:

Create a new component in your project that will act as a proxy to the core title component. This involves creating a new component node in the repository that inherits from the core title component.

Example path: /apps/myproject/components/pageHeadline with sling:resourceSuperType set to core/wcm/components/title/v2/title.

Implement Sling Model:

Implement a Sling Model that adapts from SlingHttpServletRequest and Title.class, ensuring it overrides the text fetching logic to retrieve the title from the current page's title.

The model will use @ScriptVariable to inject the current page and @Self to access the core title component's logic.

@Model(adaptables = SlingHttpServletRequest.class, adapters = Title.class, resourceType = "myproject/components/pageHeadline")

public class PageHeadline implements Title {

@ScriptVariable

private Page currentPage;

@Self @Via(type = ResourceSuperType.class)

private Title title;

@Override

public String getText() {

return currentPage.getTitle();

}

@Override

public String getType() {

return title.getType();

}

}

@Model Annotation: Specifies that this class is a Sling Model and adapts from SlingHttpServletRequest. It is also an adapter for Title.class and applies to the myproject/components/pageHeadline resource type.

@ScriptVariable: Injects the current Page object, which allows access to the current page's properties.

@Self @Via(type = ResourceSuperType.class): Injects the core title component, allowing the reuse of existing logic.

getText() Method: Overrides the getText() method to return the title from the current page instead of the jcr:title.

getType() Method: Delegates to the core title component's getType() method to maintain existing functionality.

This approach leverages the power of Sling Models and the core components to extend functionality while keeping the implementation clean and maintainable.

References:

Adobe Experience Manager - Core Components

Sling Models Documentation

The order of resolution for OSGi configurations at runtime in AEM is as follows:

Web Console Configuration:

Changes made through the OSGi Web Console take immediate effect and have the highest precedence. This is because these configurations are considered the most direct way to adjust OSGi settings at runtime.

References:OSGi Configuration in AEM

/apps Configuration:

Configurations in the /apps directory take precedence over those in the /libs directory. This allows custom configurations to override the default configurations provided by AEM.

References:AEM Project Structure

/libs Configuration:

Configurations in the /libs directory are the default configurations provided by AEM. They are overridden by any configurations in the /apps directory.

References:AEM Configuration

By understanding this order, developers can effectively manage and prioritize their OSGi configurations to ensure the desired behavior of their AEM instances.