To do this, add Adaptive Acceleration to your Ion property. It syncs with ​Akamai​ real-user monitoring to gather navigation and resource timing data and stores that data in a policy that's associated with your hostname. As requests for your hostname continue, policy data is gathered and reviewed to identify key resources. This allows Adaptive Acceleration to provide these resources to an end user's browser ahead of time, reducing the load and render time for your web pages.

Follow this process to set up this recommended feature.

👍

Prefer an API?

If you'd rather use an API to set up and manage, you can use a combination of ​Akamai​'s Property Manager and Adaptive Acceleration APIs. Check out the tutorial.

Before you begin

Before you can configure Adaptive Acceleration, you need to do a few things:

• Your Ion property needs to be secure. You need to define property hostnames that connect the end user to the ​Akamai​ edge securely via HTTPS. You can use any of the secure methods ​Akamai​ offers: Enhanced TLS, Standard TLS, or the ​Akamai​ shared certificate.

• Enable a beacon source. Timing data is collected in "beacons" and sent to a ​Akamai​'s real-user monitoring source, mPulse. Adaptive Acceleration communicates with mPulse to get this data. To configure it, use the mPulse RUM sub-rule, that's default included in a new Ion property.

• Enable HTTP/3. The HTTP/3 behavior is automatically included and enabled in the Default Rule. It doesn't require any additional configuration. It just needs to be included in your rule tree where it'll be applied to requests that also apply the Adaptive Acceleration behavior.

📘

HTTP/2 is still supported

Older Ion properties automatically included the HTTP/2 behavior and it was required for use with Adaptive Acceleration. You can keep your property configured this way, but we recommend that you update it to use HTTP/3, instead.

• Get access to the Adaptive Acceleration interface in ​Akamai Control Center​ (Optional). This interface lets you view policies of navigation and resource timing data that have been gathered for use with the Automatic Push, Preconnect, and Font Preload services. You can also use it to reset the data gathering mechanism. You need to have a ​Control Center​ account that's been granted access to this interface. If you're not sure, talk to your local ​Akamai​ admin, or contact your ​Akamai​ account team.

1. Add it in your Ion property

Adaptive Acceleration is added by default to the Accelerate delivery sub-rule in your property.

2. Apply your Beacon Data Source

To start, set Beacon Data Source to mPulse.

3. Set push and preconnect options

These options help optimize delivery using the beacon data gathered from mPulse. Here's roughly how these features interact with mPulse and Adaptive Acceleration:

1. Adaptive Acceleration analyzes mPulse data for the most-visited pages on your site. It identifies the resources and resource domains on the critical rendering paths for those pages and creates a report.

2. When subsequent end users request a page in the report, Adaptive Acceleration sends resources and establishes anticipated connections while the client is waiting for a response.

Set the options here as follows:

4. Optionally add compression

Adaptive Acceleration offers multiple ways to compress and cache resources, such as JavaScript, CSS, and font files, using enhanced compression protocols. This can reduce page weight and potentially improve rendering time for your pages. You can choose from Resource Optimizer or Brotli Compression.

Compression feature comparison

In addition to the compression offered by Adaptive Acceleration, there are other ways to set up compression in your Ion property. Before you apply it here, take a look at this table to see how all of the available methods stack up.

Use Resource Optimizer

To enable this, set it to On. If you also have access to Brotli Compression, set it to Off. You can't use both.

What's compressed

Resource Optimizer compresses .css, .js, and .svg resources up to 10,485,760 bytes in size. This is the maximum decompressed file size supported for CSS and JavaScript files. It only compresses files that include the extensions.

During the compression, Resource Optimizer sets the downstream TTL of the file to 900 seconds (15 minutes).

What's served

Resource Optimizer serves compressed, cached content on HTTP 200 responses to a request. Both the original and the optimized resources are served under the same cache key: /L/origin-www.example.com/path1/path2/someobject.js cid=___RO_ENCODING=br.

Additional requirements

Before you save your property and enable it on any ​Akamai​ network, you need to apply a few more settings in your Ion property to ensure it's compatible with Resource Optimizer.

• You want to use Caching with a Maxage of at least an hour. This applies to the Caching behavior in the Offload Origin rule. Use any of the settings to enable caching—Cache, Honor origin Cache-Control and Expires, Honor origin Cache-Control, or Honor origin Expires— and set its "maxage" field to at least one hour.

📘

There are several other caching-related sub-rules in the Offload Origin rule, too.

• CSS and Javascript
• Fonts
• Images
• Files
• Other static objects

They're used to override the generic Caching maxage for these specific file types, based on recognized best practices. They all include a default maxage in excess of one hour. For best results with Resource Optimizer, keep these maxage settings as is.

• Only use Resource Optimizer for GET requests. It should only initiate compression and serve compressed content for requests that use the GET method.

• Remove Resource Optimizer from the failover actions. This will prevent JavaScript failover pages from being cached.

• Ensure the Cache-Control header doesn’t contain a private directive. The Cache-Control header on your origin server can be used determine how caching should be applied. You can add the Private directive to it to block the caching of personally identifiable information (PII). This header can't contain this directive if you want to use Resource Optimizer. You can apply this as a setting when configuring Downstream Cacheability.

Add Resource Optimizer Extended Compatibility (optional)

In most cases, the standard Resource Optimizer feature provides the compression you'll need. We also offer this behavior to add more compression and to address some compatibility issues.

📘

This behavior needs to be added to your contract. Talk to your ​Akamai​ account team for details.

Latest Features

Enable this option to add more support and error handling. Features of note include the following:

• Support for Fast Purge using Cache Tags. You can generate purges via our Fast Purge application using any Cache Tags you've configured in your Ion property.

• Obey your time to live settings. Resource Optimizer uses its own time to live (TTL) threshold for content it caches. If you've set your own TTL for your content in cache, we'll honor that value. The standard Resource Optimizer feature in Adaptive Acceleration will ignore a custom TTL and apply its own value.

• It helps to prevent 404 errors from Resource Optimizer back-end requests in ​Akamai​ traffic reports.

• It can help optimize the final resource when using redirects.

Caveats and requirements

Consider these points when adding this behavior:

• Put it in the same rule tree as Adaptive Acceleration. For the easiest application, include it as a behavior in the same rule to have it applied in place of the standard Resource Optimizer support. Or, include it in a child rule to the rule that includes Adaptive Acceleration. In this case, you can set it to a specific match criterion to apply its extended support for specific requests.

• Resource Optimizer Extended Compatibility overrides standard Resource Optimization. Even if you disable the standard Resource Optimization feature in the Adaptive Acceleration behavior, adding a standalone Resource Optimizer Extended Compatibility behavior overrides these settings. This could also impact Brotli Compression if you have it enabled in the Adaptive Acceleration behavior. Either Resource Optimization Extended Compatibility or Brotli Compression will apply, as a single request can't use both features. ​Akamai​ will only execute the last behavior that matches the incoming request.

• Resource Optimizer and Cloudlets. All forms of Resource Optimizer do not work with Cloudlets that modify the forward origin path.

• Test this after you add it. If you're already delivering your site using the standard Resource Optimizer feature, you should thoroughly test your Ion property after adding this behavior.

Use Brotli Compression

To add this support:

1. Set Brotli Compression to On.
2. Select Enable for Non-Cacheable if you also want to your non-cacheable content to be Brotli-compressed.
3. Ensure that Resource Optimizer is set to Off and you don't have any instances of the standalone Resource Optimizer Extended Compatibility behavior in your property. Both of these features are mutually exclusive with Brotli Compression.

📘

You may experience a slight increase in latency if you've checked Enable for Non-cacheable and you're using any of these content injection behaviors on your page:

• Bot Manager
• mPulse
• Script Management

This is because the compression-algorithm for Brotli is executed after its JavaScript object is included in your page. Cacheable objects are Brotli-compressed after they're first requested and then held in cache, so this latency doesn't occur.

What's compressed

Brotli Compression targets text-based content. Compressible content is identified in the Content-Type header of the metadata, or by the file extension. It returns Brotli-encoded responses to compatible browsers for resources with .css, .js, and .svg file extensions. It also returns Brotli-encoded responses for the following content-types:

• application/+json*
• application/+xml*
• application/font-sfnt*
• application/javascript*
• application/json*
• application/protobuffer*
• application/text*
• application/vnd.microsoft.icon*
• application/vnd-ms-fontobject*
• application/x-font-eot*
• application/x-font-opentype*
• application/x-font-truetype*
• application/x-font-ttf*
• application/x-javascript*
• application/x-json*
• application/xml*
• application/x-mpegurl*
• application/x-tgif*
• font/eot*
• font/eot*
• font/opentype*
• font/otf*
• font/ttf*
• image/svg+xml*
• image/vnd.microsoft.icon*
• image/x-icon*
• text/*

5. Optionally enable A/B testing

You can use A/B testing to compare two versions of a webpage or app against each other to determine which one performs better. If you'd like to include Adaptive Acceleration-related data in your A/B testing model, enable it based on how you've set it up in your Ion property.

Method 1: Enable using Cloudlets

Cloudlets bring a site's business logic closer to the end user by placing it on the edge of the content delivery platform. ​Akamai​ offers several Cloudlets you can configure to support A/B testing:

• Audience Segmentation (AS)
• Phased Release (PR)
• Application Load Balancer (ALB)

If you've set up A/B testing using any of these Cloudlets:

1. Select Enabled using Cloudlets from the drop-down.

2. If you have multiple Cloudlets set in your Ion property, ensure that the Cloudlet you want to use for A/B testing is set lowest in the rule order. With Property Manager and these three Cloudlets, the last one in the list takes priority.

Method 2: Enable Manually

This applies A/B testing by redirecting a request to one of two origin servers, based on the contents of a cookie file included with the request. The cookie will use the same file name, but its content will vary, based on the desired site experience. So, when the cookie file is read, origin "A" or origin "B" is contacted to deliver the appropriate site experience.

Before you begin

This process assumes you already have an A/B testing model in place using a cookie in the request. You'll need to know the name of this cookie file.

Set up process

1. Open the Accelerate delivery sub-rule in the Default Rule.
2. Click the Adaptive acceleration child rule.
3. Set A/B Testing Method to Enabled manually.
4. In the Cookie Name field that's revealed, enter the name of the cookie file that you've configured for use in your A/B testing model.

6. Finish your property, test it, and go live

Continue configuring your Ion property, considering features that are incompatible with Adaptive Acceleration. Then you can finalize it, test it, and go live to deliver your site.

Incompatible features

Adaptive Acceleration isn't compatible or has known issues with other features offered in Property Manager.

7. Wait for data to be gathered and used

With your property live and mPulse enabled as your beacon data source, give it some time to gather data. Data for the Automatic Push, Automatic Preconnect, and Automatic Font Preload settings is gathered and stored in a "property report." This report is used to determine "high usage" assets for your site or app, for use with Adaptive Acceleration.

Additional resources

​Akamai​ offers additional services you can use with Adaptive Acceleration.

The Adaptive Acceleration interface, API, and CLI

You can use these tools to interact with the beacon data collected in the policies for the Automatic Push, Preconnect, and Font Preload features.

• View the policy data. See what Adaptive Acceleration has identified in your policies for early delivery. The Adaptive Acceleration interface on ​Akamai Control Center​ also lets you view warnings and event logs for the policy for troubleshooting.

• Reset the policy. If you've changed your site or you don't want to wait for earlier data to drop out of the analysis, you can manually reset the data-gathering mechanism.

View reports

Check out the mPulse reports to access monitoring and reporting tools for beacon data used by Adaptive Acceleration.