When AEM as a Cloud Service was first released, CDN behavior could only be controlled (in a very limited extent) through Apache configurations for cache-control. If you needed further customization, your only option was to bring your own CDN: meaning, to layer on an additional CDN like Cloudflare, Akamai or a self-configured Fastly, on-top of the inbuilt Adobe-managed Fastly CDN.

Introduction to Adobe Managed CDN for AEM as a Cloud Service

Last year, however, Adobe rolled out a new Managed CDN feature for AEM Cloud Service, greatly simplifying hybrid setups with Edge Delivery Services (aka Helix) or with JCR-based AEM. We've got some architecture diagrams and other config examples for that here.

Configuration is done by creating a /config/cdn.yaml file in your AEM project and deploying it via a dedicated Config pipeline to manage environment-specific settings (e.g., DEV, STG, PROD). These lightweight pipelines typically run in just 1–2 minutes, allowing for efficient iteration and safe testing of new CDN logic before deploying to production.

However, deployments to an AEM as a Cloud Service Development Environment requires running a Cloud Manager pipeline, and running a Cloud Manager pipeline requires a git commit. You don't want to be debugging your syntax AND testing your configuration logic all with repeated git pushes to your develop branch, that's just messy (never mind absurdly time-consuming). Luckily there is a way to test this locally with minimal setup so you can have even more fun testing the same thing forty times to hopefully get your syntax right.

The secret to this is Adobe's Rapid Development Environments, or RDEs.

Setting Up & Testing CDN Configurations on an AEM RDE

The key difference between RDEs and the Dev, Stage and Production environments in an AEM as a Cloud Service environment is the RDE is meant to be deployed-to from an individual developer's workstation directly using the aio command line interface, as opposed to via a git-controlled Cloud Manager pipeline. These are intended for rapid iteration and debugging, but are shared environments - so changes can be validated and go through appropriate review processes before going into the Dev -> Stage -> Prod release cycle.

Set Up an RDE Environment with a CDN

In order to test your CDN configurations on an RDE, you'll first need to ensure that you have a hostname and SSL certificate configured in front of the RDE env in question, so that you have a CDN environment to configure. Note too that most AEMaaCS environments only have a single RDE environment provisioned, but that multiple environments can be provisioned for an extra cost, and may have done so as part of your company's AEM Cloud Service contract.

To set this up for an Edge Delivery Services domain, do the following:

(1) Create domain in Cloud Manager: In your Adobe Cloud Manager UI, go to Domain Settings on the left-hand nav rail, and then click Add Domain in the

You'll want to set this up with an Adobe-managed certificate, which will then generate a verification code that you'll need to put in as a CNAME in your DNS provider in order to verify the certificate. Until that verification step is done, your certificate will show as "NOT VERIFIED"

Once it's verified, you can move on to the next step.

(2) Add the SSL Certificate: Once you've verified ownership on a domain, you can add an SSL certificate for that domain. You can use either an Adobe-managed certificate, or your own cert if you prefer such. Note that Cloud Manager will only populate domains that you've verified.

(3) Map the domain to your RDE environment in Cloud Manager: You'll then need to map your domain to the RDE environment in Cloud Manager. In the left rail navigation, click on DOMAIN MAPPINGS, and then select "Adobe Managed CDN" as the CDN type, and chose the name of your RDE environment as the origin, publish as the tier, and select the domain and SSL certificate you created for this RDE env.

(4) Map the domain to Adobe in DNS: In your DNS, create a CNAME record to map your RDE domain to cdn.adobeaemcloud.com. This will allow Adobe to pick up & route that domain accordingly.

(5) Ensure your config.yml manages RDE environments: Lastly, if you followed this how-to on setting up Adobe Managed CDN, when you configured your cdn.yml, make sure that the RDE is listed as one of the environments the config pertains to:

kind: "CDN"
version: "1"
metadata:
  envTypes: ["rde", "dev", "stage", "prod"]
data:

Using the AIO CLI to Push Configs to the RDE's CDN

Once you have an RDE set up and ready to accept your CDN configuration, you're ready to set up your workstation to be able to push CDN configs to the RDE.

1. Get NPM, Node and NVM on your machine. You'll want to use nodejs 20

2. install the Adobe I/O runtime with npm install -g @adobe/aio-cli

3. install and update your AIO plugins:
aio plugins:install @adobe/aio-cli-plugin-cloudmanager

aio plugins:install @adobe/aio-cli-plugin-aem-rde aio plugins:update

4. Authenticate with aio login which will pop a browser window - make sure you use your IMS profile for the AEMaaCS account you're working with, otherwise you may need to aio logout and re-select.

1. Set your organization with aio cloudmanager:org:select

5. Set your program ID to your org's ID with aio config:set cloudmanager_programid {YOUR PROGRAM ID GOES HERE}

1. If you want to see the environments you have access to, use aio cloudmanager:list-environments .This will show you which environment the RDE is located in
2. Use this to set the CloudManager EnvironmentID. This can be done by using aio config:set cloudmanager_environmentID {YOUR ENVIRONMENT ID GOES HERE}

6. Initiate your RDE setup with aio aem:rde:setup - it will ask if you want to store locally, say yes please

7. Try aio aem:rde:status and see if it lets you use the RDE. It should respond like this:

PS C:\Users\Noah\Desktop\my-aemaacs> aio aem:rde:status
Running aem:rde:status on cm-p104400-e1291792
Info for cm-p104400-e1291743
Environment: Ready

Once you have set this up, you are ready to begin testing your config. If you have not already, now would be a good time to create a new branch that will reflect your changes. Then you will need to ensure you are in the proper directory of the config you would like to test. After that is done you can use aio aem:rde:install -t env-config ./config to install your CDN config to the directory. This will list any syntax errors you might have.

PS C:\Users\Noah\Desktop\my-aemaacs> aio aem:rde:install -t env-config ./config
Running aem:rde:status on cm-p104400-e1291743
Zipped file /tmp/aio-rde-RF1WAb/config.zip of 2584 total bytes
Uploading ████████████████████████████████████████ 100% | ETA: 0s | 3/3 KB
#42: deploy completed for env-config config.zip on author,publish - done by 66E11EA86517050C0A495EAB@c23e2a2e64229a46495fae.e at 2025-10-24T21:15:59.387Z
Logs:
> State: complete

Testing something like a CDN config can be tricky sometimes, but there are ways to do so locally. Even though testing will be done locally, we still need to utilize the backend logic that will be used by the CDN. If done properly, this will let us see how the CDN config is interacting with the test URLs without the need to push it to a development branch.

Your next step will likely be to create a pull request to get approval for pushing you changes into dev, based on the branching strategy in-use in your organization. When your PR has been approved, the configs can be pushed to the repository configured for your Cloud Manager pipelines, where it can then be pushed to the development environment for further testing, and then on to Prod!

Using this approach, individual developers can be entirely productive in developing and testing CDN configurations confidently, knowing they have a very good chance of working in production!

About the Author

Like what you heard? Have questions about what’s right for you? We’d love to talk! Contact Us

Podcast Episodes