Free AD0-E137 Practice Test

This option provides a functionally correct implementation for the requested servlet. The @SlingServletResourceTypes annotation correctly registers the servlet, binding it to the specified resource type (/my/resourcetype) and HTTP method (GET). While SlingSafeMethodsServlet is often considered a best practice for read-only operations, extending SlingAllMethodsServlet is a perfectly valid and functional approach. Most importantly, this option correctly overrides the doGet method with the proper case and the required (SlingHttpServletRequest, SlingHttpServletResponse) signature, making it the only fully working solution among the choices.

A: This option is incorrect because the method name is doGET. Java method names are case-sensitive, and the correct method to override from the SlingSafeMethodsServlet class is doGet. C: This option is incorrect because the doGet method signature uses the standard HttpServletRequest and HttpServletResponse types. To correctly override the method from the Sling base servlet, it must use SlingHttpServletRequest and SlingHttpServletResponse.

1. Apache Sling Documentation, "Servlets and Scripts": This official documentation outlines the registration of servlets using OSGi Declarative Services annotations like @SlingServletResourceTypes. It also clarifies the base servlet classes available.

Reference: Apache Sling Project, "Servlets and Scripts", Section: "Registering a Servlet". Available at: https://sling.apache.org/documentation/bundles/servlets.html

2. Apache Sling API Documentation (Javadoc) for SlingSafeMethodsServlet: The official Javadoc specifies the exact method signature to be implemented for handling GET requests.

Reference: org.apache.sling.api.servlets.SlingSafeMethodsServlet, Method Detail: protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response). Available at: https://sling.apache.org/apidocs/sling11/org/apache/sling/api/servlets/SlingSafeMethodsServlet.html

3. Adobe Experience League, "Servlets in AEM": This official Adobe guide provides examples and best practices for creating servlets in AEM, reinforcing the use of Sling's base classes and correct method overriding.

Reference: Adobe Experience League, "Servlets", Section: "Creating a simple servlet". The examples consistently show public class MySafeMethodServlet extends SlingSafeMethodsServlet { ... protected void doGet(...) ... }. Available at: https://experienceleague.adobe.com/docs/experience-manager-65/developing/introduction/servlets.html?lang=en

To make a query on a custom property performant and avoid repository traversal, the property must be added to an Apache Oak index definition. The query specifically targets nodes of type dam:Asset. AEM provides a specialized, out-of-the-box Lucene index for assets located at /oak:index/damAssetLucene. The correct procedure is to overlay this index definition and add a new property node representing the custom property (foo:bar) under the path indexRules/dam:Asset/properties. This configuration instructs the damAssetLucene indexer to include the foo:bar property in the index, allowing the query engine to resolve the constraint efficiently.

B. Modifying the generic /oak:index/lucene index is not the best practice. The damAssetLucene index is specifically configured and optimized for dam:Asset nodes.
C. This is incorrect because the node added to the index definition must be named after the property (foo:bar), not its value (Hello).

1. Adobe Experience League, "Best Practices for Queries and Indexing": This document outlines the need to customize indexes for custom properties. It states, "The OOTB index damAssetLucene has most of the common properties... If you are querying for a property that is not in the OOTB list, add it to the list under .../damAssetLucene/indexRules/dam:Asset/properties." This directly supports adding the custom property to the damAssetLucene index structure as described in option A.

Source: Adobe Experience League Documentation, Best Practices for Queries and Indexing. Section: "Customizing the damAssetLucene Index".

2. Adobe Experience League, "Oak Queries and Indexing": This guide details the structure of Lucene index definitions in AEM. It shows that to index a property for a specific node type, a node representing the property must be created under /oak:index//indexRules//properties. This confirms the hierarchical path used in option A is the correct method for adding a property to an index rule.

Source: Adobe Experience League Documentation, Oak Queries and Indexing. Section: "Lucene Index".

3. Apache Oak Documentation, "Lucene Index": The official Oak documentation specifies the structure for Lucene property indexes. It details that the indexRules node contains child nodes for each indexed jcr:primaryType, which in turn contain a properties node where individual property configurations are defined. This foundational documentation validates the structure indexRules/dam:Asset/properties for defining an indexed property on a dam:Asset.

Source: Apache Jackrabbit Oak Documentation, Query -> Lucene Index. Section: "Index Definition Structure".

The "Generic Analytics Snippet" is the standard AEM as a Cloud Service feature designed for this exact purpose. It leverages Context-Aware Configurations, allowing authorized users to add and modify third-party scripts directly through the AEM user interface. This decouples the script management from the development cycle, fulfilling the requirement that the script can be edited on a separate schedule without requiring a code deployment. This method is specifically intended for integrating external services like analytics tools.

A. Add a new component with the script in the HTL. Placing the script directly in a component's HTL file would require a code deployment to modify it, which contradicts the requirement for edits outside the development cycle.
B. Add the script to the page policy on the template. Page policies are for defining design properties and client library includes for a template. They are not intended for managing arbitrary, editable script snippets that change frequently.

1. Adobe Experience League. (2023). Integrating with Third-Party Services.

Reference: In the section "Generic Analytics Snippet," the documentation states, "The Generic Analytics Snippet lets a user configure a snippet of analytics code to be easily added to the pages of a site... This is done by using Context-Aware Configurations." This confirms it is the designated feature for adding editable, third-party scripts.

Source: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/sites/integrations/integrating-third-party-services.html?lang=en

2. Adobe Experience League. (2023). Context-Aware Configurations.

Reference: The overview explains that Context-Aware Configurations are "configurations that are related to a content resource... This allows you to... manage configurations for your sites in one place without being a developer." This supports the requirement that the script be editable outside the development cycle by non-developers.

Source: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/sites/developing/context-aware-configurations.html?lang=en

To fulfill the requirement of fetching only a specific property (jcr:title) for a filtered set of pages, the QueryBuilder API must use the p.hits=selective predicate. This predicate instructs the query to return only the properties specified in the p.properties parameter. The query correctly filters for nodes of type cq:Page and uses the property and property.value predicates to filter by the specific homepage template located at jcr:content/cq:template. Option A is the only query that correctly combines all these predicates to produce the desired, efficient result.

Option B: This option is incorrect because it omits the p.hits=selective predicate. Without it, the p.properties predicate is ignored, and the query returns full node data.
Option C: This option is incorrect because p.hits=full explicitly requests all properties for each node in the result, directly contradicting the requirement to fetch only the title.
Option D: This option is incorrect because it uses p.hits=selective but fails to specify which properties to return by omitting the mandatory p.properties predicate.

1. Adobe Experience Manager as a Cloud Service Documentation, Query Builder API: This official guide details the available predicates. It specifies that p.hits=selective must be used to "return only the properties specified by the p.properties parameter." It also defines p.properties as the parameter that "Specifies a list of properties to be returned for each result when p.hits=selective." This directly supports the combination used in the correct answer.

2. Adobe Experience Manager 6.5 Documentation, Querying and Indexing Best Practices: In the "Restrict the properties in the result" section, the documentation advises, "Return only the properties that are needed in the results. Use the p.hits=selective and p.properties parameters to specify the properties to be returned." This confirms that the approach in Option A is the correct and recommended best practice for this scenario.

In Adobe Experience Manager (AEM) as a Cloud Service, OSGi configurations are managed as code within the ui.config project. To apply a configuration to a specific service and environment, a runmode-specific folder structure is used. The standard naming convention is /apps//osgiconfig/config... The Preview service is a type of publish tier, intended for content review before final publication. Although the dedicated runmode for the Preview service is preview, among the choices provided, publish is the most closely related service tier. Option B correctly places the configuration in the ui.config project and uses the standard runmode syntax to target a publish-like service for the specified uat environment.

A. OSGi configurations must be placed in the ui.config project. The ui.apps.structure project is used to define repository structures (e.g., empty folders), not to deploy configuration files.
C. This option incorrectly targets the author service, which is used for content creation, not for previewing. Additionally, the runmode folder format config.uat.author is non-standard; the service should precede the environment name.

1. Adobe Experience League - AEM Project Structure: This document specifies the purpose of different sub-packages in an AEM project. It states, "The ui.config project contains OSGi configurations..." This confirms that options A is incorrect as it places the configuration in the wrong project (ui.apps.structure).

Source: Adobe Experience League, "AEM Project Structure," Section: ui.config.

2. Adobe Experience League - Configuring OSGi for AEM as a Cloud Service: This official documentation details the runmode resolution and folder naming conventions. It specifies the format config.., where can be author, publish, or preview. This confirms the syntax used in option B is correct, while the syntax in option C is incorrect.

Source: Adobe Experience League, "Configuring OSGi for AEM as a Cloud Service," Section: "Runmode Resolution."

3. Adobe Experience League - Preview Service: This document describes the Preview service, noting that "The Preview service is a type of publish tier..." and that its specific runmode is preview. This supports the reasoning that, in the absence of a preview option, targeting the publish tier is the most logical choice for a publish-like function.

Source: Adobe Experience League, "Previewing Content," Section: "Preview Service."

The Content Copy feature in Cloud Manager is designed to transfer content from higher-level environments to lower-level ones for realistic testing and development. According to the official Adobe Experience Manager (AEM) as a Cloud Service documentation, when using this feature, the source environment can only be Production or Stage. Since the question specifies that the destination environment is Stage, the only valid source environment from the options provided is Production. This process allows teams to validate code changes on Stage using a recent snapshot of production content.

A. Development: A Development environment is designated as a destination for content copies, not a source for copying content to a higher environment like Stage.
B. Integration: "Integration" is not a standard, persistent environment type in the AEM as a Cloud Service topology from which a content copy operation can be initiated.

1. Adobe Experience League. (2024). Using Content Copy. AEM as a Cloud Service User Guide. Retrieved from https://experienceleague.adobe.com/docs/experience-manager-cloud-service/content/operations/content-copy.html?lang=en.

Reference Specifics: In the "Source and Destination Environments" section, the documentation explicitly states: "The source environment can only be production or stage. The destination environment can only be stage or a development environment." This directly confirms that to copy to Stage, the source must be Production.

The question specifies a requirement for "true multi-tenancy" with zero shared code, content, or authors. This level of strict isolation cannot be achieved within a single AEM instance. A single instance inherently shares the underlying JCR repository, the OSGi container, the codebase under /apps, and the user management system under /home. While ACLs (Option C) and component properties (Option B) provide logical separation for content authors, they do not prevent shared code or a shared user base. Therefore, the only architecture that satisfies the requirement for complete independence and zero knowledge between tenants is to provision entirely separate author and publish instances for each client project.

B: Component groups and allowedPaths are content governance features for organizing templates and components. They do not provide any isolation for code, users, or the underlying repository. C: This describes AEM's standard multi-tenancy model within a shared instance. It fails to meet the explicit requirements of "no shared code" and "no shared authors," as the instance itself is a shared resource.

1. Adobe Experience League, "AEM Multi Site Management Best Practices". This document outlines different approaches to multi-tenancy. It implicitly supports the concept of separate instances for maximum isolation by stating: "When you need to share nothing, not even the user accounts, the solution is to set up separate AEM instances." This directly validates that for zero sharing, separate instances are the required solution. (Accessed under AEM 6.5 Assets documentation).

2. Adobe Experience League, "AEM 6.5 Security Checklist - Segregation of Duties". This guide details how to use privileges and ACLs to create separation within an instance. It highlights that this is for separating roles and access to content paths, not for isolating entire codebases or user populations from each other, which is a key requirement of the question. This explains why Option C is insufficient for "true" multi-tenancy as defined in the scenario.

3. Adobe Experience League, "Recommended Deployments". The documentation on deployment architectures for AEM 6.5 shows that provisioning separate, independent environments (Author/Publish pairs) is a standard deployment pattern. This architectural choice is precisely what is needed to achieve the complete tenant isolation described in the question, where each tenant operates as a distinct entity.

The correct JCR node structure for defining a list of style options is shown in Option A. This structure uses a parent node, cq:styles, to contain the list of available styles. Each individual style is then defined as a separate child node (e.g., item0, item1). This indexed-node pattern is a standard convention in AEM and JCR for representing ordered lists of complex items. Each item node contains properties that define the style, specifically cq:styleId for the CSS class name and cq:styleLabel for the user-friendly name displayed to authors in the UI. This structure is consistent with how style lists are defined in modern AEM Style System policies.

Option B: This is incorrect. It improperly attempts to define multiple styles by placing comma-separated values into the properties of a single node, which is not a valid JCR structure for this purpose.
Option C: This is incorrect. It uses non-standard, pluralized property names (cq:styleIds, cq:styleLabels) and an invalid comma-separated value format for defining multiple styles.
Option D: This is incorrect. While using the ID as the node name is a possible JCR pattern, the standard AEM convention for ordered lists, including Style System configurations, is to use indexed item nodes (item0, item1, etc.).

1. Adobe Experience Manager as a Cloud Service Documentation, "Style System": This official documentation, in the section "Defining Styles on a Policy," illustrates the JCR structure for defining styles. It shows a cq:styles node containing multiple item... child nodes, each with cq:styleId and cq:styleLabel properties. This confirms the pattern in Option A is the correct AEM standard.

Source: Adobe Experience League, Developing > Components > Style System.

2. Adobe Experience Manager 6.5 Documentation, "Using and Extending the Style System": This document reinforces the standard structure for defining styles. The JCR examples for policy configurations clearly show the use of indexed item nodes under a cq:styles parent node, which directly validates the structure presented in Option A.

Source: Adobe Experience League, Developing AEM Sites > Templates > Style System > Using and Extending the Style System.

3. JCR 2.0 Specification (JSR 283): The specification for Java Content Repository API outlines the fundamental principles of node and property structures. The pattern in Option A, where a list of complex objects is represented by a parent node with multiple child nodes, is a standard and robust way to model list-like data in a hierarchical repository, adhering to JCR best practices.

Source: JSR 283: JavaTM Content Repository API Version 2.0, Section 3.6 "Node Type".

To configure the SAML Authentication Handler for a specific site path, the path property must be set to that content path (e.g., /content/siteB). This ensures the handler is only invoked for requests under that path. The idpUrl property must be configured with the URL of the Identity Provider (IDP) to which AEM will send authentication requests. Option B correctly uses these two essential properties to meet the customer's requirement of scoping a specific IDP to a particular site within AEM.

A. The assertionConsumerServiceURL is the endpoint on AEM (the Service Provider) that receives the SAML response from the IDP; it should not be the IDP's URL.
C. The serviceProviderEntityId is the unique identifier for the AEM instance itself, not the URL of the Identity Provider. The userIntermediatePath specifies where user nodes are created, it does not scope the handler.

1. Adobe Experience Manager 6.5 Documentation, Security Guide, SAML 2.0 Authentication Handler: This official guide details the configuration properties for the SAML handler.

Section: "Configuring the SAML 2.0 Authentication Handler"

Details: The documentation explicitly states:

Path (path): "Repository path for which this authentication handler should be used by Sling. If this is empty, the authentication handler is disabled." This confirms its use for scoping the handler to /content/siteB.

IDP URL (idpUrl): "URL of the IDP where the SAML Authentication Request is sent." This confirms its value should be https://www.idpB.com.

Assertion Consumer Service URL (assertionConsumerServiceURL): "URL on the SP which will receive the SAML response." This confirms it is an AEM-side URL, invalidating option A.

Service Provider Entity ID (serviceProviderEntityId): "The ID which uniquely identifies this service provider with the IDP." This confirms it is the AEM instance's ID, invalidating option C.

The correct configuration is /apps//osgiconfig/config.uat.author/.cfg.json in the ui.apps project. This structure adheres to the standard AEM project conventions for OSGi configurations. The path /apps//... is managed by the ui.apps module. The folder naming convention config.. (e.g., config.uat.author) is the correct syntax for applying configurations to an instance where multiple run modes are active. Finally, the .cfg.json extension is the required format for JSON-based OSGi configurations to be recognized by the JCR Installer. This configuration would correctly apply to an author instance within the UAT environment.

A. The ui.config project is designated for repository paths under /apps/system/config, not /apps//.... This option incorrectly places an application-specific path within the ui.config project's scope.
C. The file extension .json is incorrect. For the OSGi installer to process the file as a configuration, it must have the .cfg.json extension. A file with a .json extension will be ignored.

1. Adobe Experience Manager as a Cloud Service Documentation, "OSGi for AEM as a Cloud Service": This document outlines the recommended project structure. It specifies that the ui.config project contains mutable configurations under /apps/system/config., while the ui.apps project contains immutable application code and configurations under /apps/. This supports why option A is incorrect and option B's location in ui.apps is valid.

Reference Section: "OSGi Configurations" and "Immutable versus Mutable Content".

2. Adobe Experience Manager as a Cloud Service Documentation, "Deploying to AEM as a Cloud Service": This guide details the structure of AEM projects. It confirms that OSGi configurations are part of the code packages (ui.apps and ui.config) and explains their respective JCR paths.

Reference Section: "Project Structure".

3. Apache Sling Documentation, "OSGi Installer": This documentation specifies the file formats and naming conventions recognized by the OSGi installer, which AEM uses. It explicitly states that JSON-formatted configurations must use the .cfg.json extension. This directly invalidates option C.

Reference Section: "Providing OSGi Configurations".