Migrate from Akamai to Azion

A platform migration from Akamai usually starts with an inventory problem. Delivery properties, behaviors, hostnames, Cloudlets, EdgeWorkers, EdgeKV data, security policies, DNS zones, traffic steering rules, storage, and observability streams may be managed across multiple products and operational processes.

For teams using Akamai Ion, App & API Protector, EdgeWorkers, EdgeKV, Cloudlets, Edge DNS, Global Traffic Management, NetStorage, DataStream, mPulse, Prolexic, Image & Video Manager, or related delivery products, Azion provides equivalent capabilities through Applications, Rules Engine, Functions, KV Store, Object Storage, Firewall, Web Application Firewall, DDoS Protection, Bot Manager, Edge DNS, Load Balancer, Data Stream, Edge Pulse, Real-Time Events, and Real-Time Metrics.

The strongest reason to migrate is not simply to replace one vendor with another. It is to consolidate application delivery, compute, storage, security, DNS, and observability into a unified platform designed for globally distributed applications.

How Akamai to Azion Migration Works

Traditional platform migrations often require recreating delivery properties, rebuilding origin behavior, replacing security policies, and changing DNS under pressure. That approach increases operational risk and makes rollback harder.

The Azion migration approach preserves application behavior while moving each Akamai workstream into a unified platform model:

1. Incremental migration path. Start with one representative Akamai property, validate delivery and security behavior on Azion, and expand only after the migration pattern is proven.

2. Preserved application behavior. Hostnames, origins, cache rules, redirects, headers, Cloudlets, EdgeWorkers logic, security controls, storage access, DNS, and observability patterns map to Azion Applications, Workloads, Connectors, Rules Engine, Functions, Firewall, Store, and Observe products.

3. Unified platform model. Instead of operating delivery, compute, security, storage, DNS, and observability as disconnected products, Azion brings these capabilities together with consistent APIs, Console workflows, and deployment patterns.

Feature Mapping

The following table provides a practical mapping of Akamai products and configuration areas to their Azion equivalents. A dash (-) indicates that Azion does not currently offer a direct equivalent.

Migration Strategy

The migration is organized around Azion’s product categories, with DNS and traffic management treated as a controlled cutover workstream:

• Build: migrate Akamai properties, origins, cache behavior, Cloudlets, EdgeWorkers, Image & Video Manager, API acceleration, media, and download delivery patterns.
• Secure: migrate hostnames, certificates, App & API Protector policies, WAF rules, bot controls, Prolexic assumptions, access control, and DDoS workflows.
• Store: migrate NetStorage, Object Storage, EdgeKV, and managed database dependencies to Azion storage services.
• Observe: migrate TrafficPeak, DataStream, mPulse, dashboards, events, alerting, and external log destinations.
• DNS and traffic management: migrate Edge DNS, DNS Manager, Global Traffic Management, and load balancing rules only after delivery and security behavior is validated.

Build

The Build category covers application deployment, property migration, request and response logic, compute, routing, cache, media, image optimization, API acceleration, and origin protection. Start here to recreate the behavior users see before moving security, storage, DNS, and observability layers.

1. Project Setup on Azion

The first step brings one Akamai property into Azion in a controlled way. If your team uses Akamai Property Manager, EdgeWorkers, Cloudlets, and CLI/API activation workflows, the migration pattern is familiar: define configuration, deploy, validate behavior, and move traffic when ready.

Azion follows a similar workflow but consolidates application delivery, Functions, rules, security, and observability in the same platform context.

Key Differences

Connect Your Repository

1. Open Azion Console.
2. Click + Create > Import from GitHub.
3. Authorize the Azion GitHub App.
4. Select the repository you want to migrate.

Configure Your Build

Azion auto-detects your framework and configures build settings. Override the detected preset in azion.config.js when needed:

import { defineConfig } from 'azion'

export default defineConfig({
name: 'my-akamai-migration',
preset: 'nextjs', // Override auto-detection if needed
})

Deploy and Verify

Deploy from the Azion Console or CLI. Your temporary Azion URL follows this pattern:

https://xxxxxxxxxx.map.azionedge.net/

Validate the deployment before moving production hostnames:

curl -I https://xxxxxxxxxx.map.azionedge.net/
curl https://xxxxxxxxxx.map.azionedge.net/health

Reference documentation

• Applications
• Applications first steps
• Azion CLI overview
• Import an existing project from GitHub

2. Converting Property and Build Configuration

An Akamai migration can look complete when the first request returns 200, but fail later when cache behavior, redirect logic, origin routing, headers, or security enforcement differs from the original property. Review active property versions and product dependencies before treating the migration as a simple DNS change.

CLI Quick Reference

Configuration Inventory

Before recreating the property in Azion, inventory:

• Active Akamai properties and property versions.
• Property hostnames, edge hostnames, certificates, and DNS records.
• Origin servers, failover settings, health checks, and shielding patterns.
• Cache keys, TTLs, stale behavior, CP codes, cache tags, and purge workflows.
• Property rules, behaviors, variables, match criteria, and advanced metadata.
• Cloudlets, policies, match rules, and activation dependencies.
• EdgeWorkers bundles, EdgeKV namespaces, and runtime configuration.
• App & API Protector policies, bot controls, API protections, and Prolexic assumptions.
• Edge DNS zones, DNS Manager records, and Global Traffic Management policies.
• DataStream streams, TrafficPeak dashboards, mPulse tags, alerts, and external monitoring dependencies.

Reference documentation

• Azion CLI overview
• azion.config.js reference
• azion deploy command

3. Migrating Ion and Delivery Properties to Applications

Akamai Ion properties deliver websites, applications, APIs, and mobile traffic through hostnames, origins, property rules, cache behavior, and performance optimizations. Azion Applications provide equivalent delivery capabilities with integrated Rules Engine, Cache, Functions, Connectors, and Workloads.

Key Differences

Configuration Steps

curl -X POST 'https://api.azionapi.net/v4/workspace/applications' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "akamai-property-migration",
  "origins": [
    {
      "name": "origin-main",
      "addresses": [
        {
          "address": "origin.example.com",
          "weight": 1
        }
      ]
    }
  ],
  "cache_settings": {
    "default_ttl": 3600
  }
}'

Application Configuration Example

import { defineConfig } from 'azion'

export default defineConfig({
name: 'akamai-property-migration',
applications: [{
  name: 'main-app',
  origins: [{
    name: 'primary-origin',
    type: 'http',
    addresses: [{
      address: 'origin.example.com',
      weight: 1
    }]
  }],
  cache: {
    ttl: 3600,
    staleWhileRevalidate: 300
  },
  rules: {
    request: [{
      name: 'API routes bypass cache',
      criteria: [{
        variable: 'uri',
        operator: 'starts_with',
        argument: '/api/'
      }],
      behavior: {
        bypassCache: true,
        setOrigin: 'primary-origin'
      }
    }]
  }
}]
})

Reference documentation

• Applications
• Applications Main Settings
• Rules Engine for Applications
• Connectors

4. Migrating Rules, Behaviors, Cloudlets, and Headers

Akamai properties often contain business-critical logic in property rules, behaviors, variables, Cloudlets, and EdgeWorkers. Migrate simple logic to Rules Engine and reserve Functions for behavior that needs code, external lookups, custom algorithms, or signed token validation.

Key Differences

Redirect Migration Example

# Akamai-style intent
If the request path matches ^/old/(.*)$, redirect permanently to /new/{capture}.

# Azion Rules Engine
Criteria: ${uri} matches ^/old/(.*)$
Behavior: Redirect To (301): /new/%{capture[1]}

Security Header Migration Example

import type { AzionConfig } from 'azion/config';

const config: AzionConfig = {
applications: [{
  name: 'my-app',
  rules: {
    response: [{
      name: 'Security Headers',
      active: true,
      criteria: [{
        variable: 'uri',
        conditional: 'if',
        operator: 'starts_with',
        argument: '/'
      }],
      behavior: {
        addResponseHeader: [
          'X-Frame-Options: SAMEORIGIN',
          'X-Content-Type-Options: nosniff'
        ]
      }
    }]
  }
}]
};

export default config;

Cloudlet Migration Checklist

• Convert Edge Redirector rules to Rules Engine redirect behaviors.
• Convert Forward Rewrite logic to Rules Engine or Functions when path reconstruction requires code.
• Convert Audience Segmentation criteria to cookie, header, path, and device criteria in Rules Engine.
• Convert Phased Release policies to Rules Engine, Functions, and controlled workload routing.
• Convert Application Load Balancer Cloudlet behavior to Connectors and Load Balancer.
• Convert API Prioritization patterns to Rules Engine, Application Accelerator, and cache policies.

Reference documentation

• Rules Engine for Applications
• Functions
• azion.config.js reference

5. Migrating EdgeWorkers and Akamai Functions to Functions

EdgeWorkers execute JavaScript to customize requests and responses. Azion Functions provide distributed JavaScript execution for request handling, API orchestration, personalization, redirects, authentication, and integration logic.

Key Differences

Update Function Signature

// Before: Akamai EdgeWorkers style
export function onClientRequest(request) {
const path = request.path;
request.setHeader('x-migration-source', 'akamai');
}

// After: Azion Functions
export default {
async fetch(request) {
  const url = new URL(request.url);
  const headers = new Headers(request.headers);
  headers.set('x-migration-source', 'azion');

  return fetch(new Request(url, {
    method: request.method,
    headers,
    body: request.body
  }));
}
};

Update Configuration Access

// Before: Akamai configuration access varies by EdgeWorkers implementation
const apiToken = 'read-from-property-variable-or-secure-store';

// After: Azion Functions
const apiToken = Azion.env.get('API_TOKEN');

Migration Guidance

Reference documentation

• Functions
• Functions Instances
• Runtime APIs
• JavaScript Runtime APIs reference

6. Migrating Load Balancing, Origin Failover, and Cloud Wrapper

Akamai origin configuration can include multiple origin servers, Cloud Wrapper, Origin Shield-like patterns, health checks, failover, and Global Traffic Management dependencies. Azion uses Connectors, Load Balancer, Origin Shield, Tiered Cache, and Rules Engine to recreate origin routing and origin protection behavior.

Key Differences

Configuration Steps

curl -X POST 'https://api.azionapi.net/v4/workspace/connectors' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "origin-pool",
  "type": "http",
  "attributes": {
    "addresses": [
      {
        "address": "origin1.example.com",
        "active": true,
        "modules": {
          "load_balancer": {
            "weight": 3,
            "method": "round_robin"
          }
        }
      },
      {
        "address": "origin2.example.com",
        "active": true,
        "modules": {
          "load_balancer": {
            "weight": 1,
            "method": "round_robin"
          }
        }
      }
    ]
  }
}'

Reference documentation

• Connectors
• Load Balancer
• Origin Shield
• Tiered Cache

7. Migrating Cache Configuration and Purge

Caching configuration determines how content is stored, revalidated, and purged. Akamai cache behavior often combines property behaviors, CP codes, cache tags, advanced metadata, Cloud Wrapper, and purge APIs. Azion provides Cache Settings, Advanced Cache Key, Rules Engine, Tiered Cache, Origin Shield, and Real-Time Purge.

Key Differences

Configuration Steps

curl -X PATCH 'https://api.azion.com/v4/workspace/applications/{application_id}/cache_settings/{cache_setting_id}' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "default-cache",
  "browser_cache": {
    "ttl": 3600
  },
  "modules": {
    "cache": {
      "ttl": 86400
    },
    "tiered_cache": {
      "enabled": true
    }
  }
}'

Akamai Purge to Azion Purge

# After: Azion purge by URL
curl -X POST 'https://api.azion.com/v4/workspace/purge/url' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "items": ["https://www.example.com/images/logo.png"],
  "layer": "cache"
}'

# After: Azion purge by wildcard
curl -X POST 'https://api.azion.com/v4/workspace/purge/wildcard' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "items": ["https://www.example.com/images/*"],
  "layer": "cache"
}'

Reference documentation

• Cache
• Cache Settings
• Advanced Cache Key
• Tiered Cache
• Real-Time Purge

8. Migrating Image, Media, and Download Delivery

Akamai Image & Video Manager, Adaptive Media Delivery, Download Delivery, and Media Services Live are used for bandwidth-heavy and media-rich workloads. Migrate each pattern based on the traffic model: cacheable media, image transformation, live streaming, video-on-demand, or large file delivery.

Capability Mapping

Image URL Format Comparison

# Akamai image transformation patterns vary by implementation
https://www.example.com/image.jpg?width=400&quality=85

# Azion Image Processor
https://www.example.com/image.jpg?ims=400x400

Transformation Parameters

Reference documentation

• Image Processor
• How to process images
• Object Storage
• How to enforce HLS cache for live streaming delivery

9. Migrating API Gateway, API Acceleration, and AI Inference Patterns

Akamai API Gateway and API Acceleration patterns can be recreated with Applications, Rules Engine, Functions, Cache, Firewall, and Application Accelerator. AI inference workloads can combine AI Inference, Functions, Cache, Real-Time Events, and Data Stream depending on whether the goal is inference execution, traffic control, observability, or response caching.

Key Differences

Function Integration Example

export default {
async fetch(request) {
  const url = new URL(request.url);

  if (url.pathname.startsWith('/api/')) {
    const response = await fetch('https://api-origin.example.com' + url.pathname, {
      method: request.method,
      headers: {
        'Authorization': 'Bearer ' + Azion.env.get('API_TOKEN')
      },
      body: request.body
    });

    return response;
  }

  return fetch(request);
}
};

Reference documentation

• Application Accelerator
• AI Inference
• AI Inference models
• Functions
• Cache

Secure

The Secure category covers hostnames, certificates, firewall rules, WAF, bot controls, DDoS protection, network controls, DNS, and traffic steering. Plan these migrations as controlled cutovers because they affect how users reach your application and how traffic is protected in production.

1. Migrating Hostnames, Custom Domains, and TLS

Hostname migration is one of the most sensitive parts of an Akamai-to-Azion migration. It affects users, SEO, brand trust, certificate coverage, and production availability. Plan hostname migration as a controlled cutover, not as a last-minute DNS change.

Migration Strategies

Create the Certificate

Create your SSL/TLS certificate before pointing your hostname to Azion. This ensures users can access the application securely over HTTPS when the domain starts resolving to the new infrastructure.

Azion provides free Let’s Encrypt certificates with automatic renewal.

Configure the Domain

Create a workload in Azion Console and associate your custom domain. See Workloads Documentation.

Point the Domain to Azion

www CNAME xxxxxxxxxx.map.azionedge.net

ns1.aziondns.net
ns2.aziondns.com
ns3.aziondns.org

Verify Propagation

dig www.yourdomain.com CNAME +short
curl -I https://www.yourdomain.com/

Reference documentation

• Workloads
• Create an Azion custom domain
• Edge DNS
• Certificate Manager

2. Migrating App & API Protector to Web Application Firewall

App & API Protector protects applications and APIs against malicious traffic, vulnerabilities, automated abuse, and distributed attacks. Migrating WAF rules requires careful mapping of match conditions, managed protections, tuning, exceptions, API paths, and enforcement modes.

Key Differences

Migration Steps

curl -X POST 'https://api.azion.com/v4/workspace/wafs' --header 'Accept: application/json' --header 'Authorization: Token [TOKEN]' --header 'Content-Type: application/json' --data '{
  "active": true,
  "name": "Akamai Migration WAF",
  "product_version": "1.0",
  "engine_settings": {
    "engine_version": "2021-Q3",
    "type": "score",
    "attributes": {
      "rulesets": [1],
      "thresholds": [
        { "threat": "sql_injection", "sensitivity": "medium" }
      ]
    }
  }
}'

Rule Migration Example

# Akamai-style intent
Block requests to /admin unless the client IP is in an approved network.

# Azion criteria
Variable: ${uri}
Operator: matches
Argument: /admin

AND

Variable: ${remote_addr}
Operator: does not match
Argument: 10.0.0.0/8

Behavior: Deny (403)

Reference documentation

• Web Application Firewall
• WAF Rule Sets
• Rules Engine for Firewall
• Functions for Firewall

3. Migrating Bot, Account, and Content Protection

Akamai Bot Manager, Account Protector, and Content Protector address automated abuse, credential attacks, scraping, and abusive access patterns. Azion Bot Manager provides detection and response controls, and Bot Manager Lite is available through Marketplace for simpler use cases.

Key Differences

Custom Bot Rules

Criteria: ${user_agent} contains "BadBot"
Behavior: Deny (403)

Criteria: ${user_agent} contains "Googlebot"
Behavior: Allow

Verification

curl -A "BadBot/1.0" https://yourdomain.com/
curl -A "Mozilla/5.0" https://yourdomain.com/

Reference documentation

• Bot Manager
• Bot Manager Lite
• Bot Manager Lite integration kit

4. Migrating Prolexic and DDoS Protection

DDoS protection guards against volumetric attacks, protocol attacks, and application-layer floods. Azion provides automatic DDoS protection and Network Shield capabilities for network-layer controls.

Key Differences

Migration Steps

1. Document current Prolexic assumptions, protected prefixes, routing model, support processes, and escalation paths.
2. Confirm the Azion workload, Firewall, and Network Shield configuration.
3. Recreate application-layer controls using Rules Engine for Firewall.
4. Validate observability through Real-Time Metrics, Real-Time Events, and Data Stream.
5. Keep rollback and escalation procedures ready during the cutover window.

Reference documentation

• DDoS Protection
• DDoS Mitigation
• Network Shield

5. Migrating Access Control, Input Validation, and Request Control

Input Validation Cloudlet, Request Control Cloudlet, and related Akamai policy logic often enforce route protection, form validation, header checks, method control, and allowlists. Recreate simple rules with Firewall Rules Engine and reserve Functions for dynamic or external validation.

Key Differences

Firewall-Based Control Example

curl -X POST 'https://api.azionapi.net/v4/workspace/firewalls/{firewall_id}/request_rules' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "Protect API Admin Routes",
  "criteria": [[{"variable": "${uri}", "operator": "starts_with", "argument": "/api/admin"}]],
  "behaviors": [
    {"type": "deny", "attributes": {"status_code": 403}}
  ]
}'

Reference documentation

• Rules Engine for Firewall
• Functions for Firewall
• Network Lists

6. Migrating Edge DNS and Global Traffic Management

Akamai Edge DNS, DNS Manager, and Global Traffic Management control authoritative DNS and traffic steering. Migrate DNS after the target Azion Applications, Workloads, certificates, and security policies are ready.

Key Differences

DNS Migration Checklist

1. Export current zones, records, TTLs, DNSSEC settings, and traffic steering rules.
2. Recreate the zone in Azion Edge DNS.
3. Lower TTLs before the cutover window.
4. Validate records with dig and application checks.
5. Move nameservers or CNAME records only after Applications and Workloads are ready.
6. Monitor Real-Time Metrics, Real-Time Events, and origin health after the switch.

Reference documentation

• Edge DNS
• How to configure Edge DNS main settings
• How to add DNS records
• Load Balancer

Store

The Store category covers data services. Migrate object, key-value, and relational data with attention to consistency, access patterns, object naming, permissions, and application compatibility.

1. Migrating NetStorage and Object Storage to Object Storage

NetStorage and object storage services power images, documents, static assets, media files, downloads, uploads, and generated content. Azion Object Storage is S3-compatible and can be used as an origin for Applications.

Key Differences

Update Configuration

import { S3Client } from '@aws-sdk/client-s3';

const client = new S3Client({
region: 'us-east-005',
endpoint: 'https://s3.us-east-005.azionstorage.net',
credentials: {
  accessKeyId: Azion.env.get('AZION_ACCESS_KEY'),
  secretAccessKey: Azion.env.get('AZION_SECRET_KEY')
}
});

Migrate Data with S3-Compatible Tools

Use tools such as s3cmd, rclone, or AWS CLI to move objects when the source supports S3-compatible access. For NetStorage-specific workflows, export to a local or intermediate bucket before importing to Azion Object Storage.

Reference documentation

• Object Storage
• Use S3-compatible tools with Object Storage
• Create and modify a bucket
• Upload and download objects
• Use a bucket as origin

2. Migrating EdgeKV to KV Store

EdgeKV is commonly used with EdgeWorkers for configuration, feature flags, personalization, authorization metadata, and lightweight state. Azion KV Store provides distributed key-value storage accessible from Functions.

Key Differences

API Comparison

// Before: Akamai EdgeKV-style pseudocode
const value = await edgeKv.getText({ namespace: 'config', group: 'features', item: 'checkout' });

// After: Azion KV Store
const kv = await Azion.KV.open('config');
const value = await kv.get('features:checkout');
await kv.put('features:checkout', 'enabled');

Create a KV Store Namespace

curl -X POST 'https://api.azionapi.net/v4/workspace/kv/namespaces' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "akamai-migration-kv"
}'

Migration Checklist

• Export namespaces, groups, items, metadata, and expiration rules from Akamai.
• Decide how EdgeKV group and item naming maps to Azion keys.
• Preserve key prefixes and naming conventions where possible.
• Document default behavior for missing keys.
• Validate value encoding, JSON serialization, and binary data handling.
• Test read and write paths before moving production traffic.

Reference documentation

• KV Store
• How to manage KV Store with Functions
• KV Store API
• Functions

3. Migrating Managed Databases to SQL Database

Akamai managed database workloads, including workloads inherited from Linode environments, can be evaluated for migration to Azion SQL Database when the application needs a relational database close to application logic.

Key Differences

Migration Checklist

1. Export schema, data, indexes, users, and extension requirements from the source database.
2. Create the target SQL Database database.
3. Import data and validate row counts.
4. Update application connection settings or Functions integrations.
5. Run application-level read and write tests before cutover.

Reference documentation

• SQL Database
• How to create and query data on SQL Database
• How to import data to SQL Database
• How to retrieve data from a database with SQL Database and Functions

Observe

The Observe category covers metrics, events, real-user monitoring, logs, and external streaming destinations. Migrating observability ensures you keep production visibility, troubleshooting capability, and compliance reporting after cutover.

1. Migrating TrafficPeak and Reporting to Real-Time Metrics

Akamai TrafficPeak and reporting workflows provide operations and security visibility. Azion Real-Time Metrics provides dashboards and GraphQL access for requests, bandwidth, status codes, latency, cache, and origin behavior.

Key Differences

Available Metrics

Azion Real-Time Metrics tracks:

• Request metrics: total requests, requests by status code, requests by HTTP method.
• Performance metrics: response time, upstream header time, origin response time.
• Bandwidth metrics: data transferred and data saved by cache.
• Cache metrics: hit ratio, miss ratio, expired objects.
• Error metrics: 4xx errors, 5xx errors, origin errors.

Access Real-Time Metrics

query HttpMetricsQuery {
httpMetrics(
  limit: 10,
  filter: {
    tsRange: {begin: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00"}
  }
  aggregate: {sum: requests}
  groupBy: [ts]
) {
  ts
  sum
}
}

Reference documentation

• Real-Time Metrics
• Real-Time Metrics first steps
• Analyze metrics
• Grafana plugin custom dashboards

2. Migrating DataStream to Data Stream

Akamai DataStream exports logs to downstream destinations. Azion Data Stream exports logs continuously to external destinations for long-term storage, analytics, SIEM, and operational monitoring.

Key Differences

Configure Data Stream

curl -X POST 'https://api.azion.com/v4/workspace/stream/streams' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "Akamai Migration Log Stream",
  "source": {
    "type": "applications"
  },
  "template_id": 12345,
  "endpoint": {
    "type": "s3",
    "name": "my-s3-endpoint",
    "bucket": "my-logs-bucket",
    "region": "us-east-1",
    "access_key": "YOUR_ACCESS_KEY",
    "secret_key": "YOUR_SECRET_KEY"
  },
  "active": true
}'

Supported Destinations

Data Stream supports multiple destination patterns:

• Cloud Storage: Amazon S3, Azure Blob Storage, Azion Object Storage.
• Monitoring: Datadog, Splunk, Elasticsearch, Azure Monitor.
• Streaming: AWS Kinesis Data Firehose, Apache Kafka.
• Analytics: Google BigQuery.
• Security: IBM QRadar.
• Custom: HTTP Webhook, Standard HTTP/HTTPS POST.

Reference documentation

• Data Stream
• Data Stream first steps
• Use Data Stream
• How to configure sampling on Data Stream
• How to select variables on Data Stream

3. Migrating mPulse to Edge Pulse

Akamai mPulse provides real-user monitoring and digital experience analytics. Azion Edge Pulse collects navigation data and real-user performance signals through a JavaScript tag and makes the data available for analysis through Observe products.

Key Differences

Migration Checklist

1. Identify every page template, tag manager rule, or application shell where mPulse is installed.
2. Document the metrics, dimensions, dashboards, and alerts your team uses.
3. Add the Edge Pulse JavaScript tag to representative pages.
4. Validate navigation data in Real-Time Events.
5. Recreate dashboards and alerts using Real-Time Metrics, Real-Time Events, Data Stream, or Grafana.

Reference documentation

• Edge Pulse
• Edge Pulse first steps
• How to analyze navigation data from Edge Pulse
• Real-Time Events

4. Migrating Investigation Workflows to Real-Time Events

Log data is essential for debugging, security analysis, incident response, and compliance. Real-Time Events provides immediate log access through Console or GraphQL API for troubleshooting and investigation.

Key Differences

Access Real-Time Events

query HttpEvents {
workloadEvents(
  limit: 100,
  filter: {
    tsRange: {begin: "2024-01-01T00:00:00", end: "2024-01-01T01:00:00"}
  }
) {
  ts
  remoteAddress
  requestUri
  status
  upstreamResponseTime
}
}

Reference documentation

• Real-Time Events
• Real-Time Events first steps
• Investigate requests with the GraphQL API
• Understand Real-Time Events logs

Troubleshooting

Common Issues

Key Advantages After Migration

Migrating from Akamai to Azion is strongest when the team treats the first cutover as a repeatable migration pattern. The immediate goal is continuity: users keep reaching the same domains, critical routes continue working, security controls remain active, and observability is ready before traffic moves.

The larger value comes after migration, when teams operate delivery, compute, storage, security, DNS, traffic management, and observability in one platform model.

With Azion, teams can build and run applications on globally distributed infrastructure while combining compute, delivery, storage, security, DNS, and observability capabilities in one environment. This reduces the fragmentation that often appears when modern applications depend on many separate services and configuration patterns.

Next Steps

After your migration is complete:

• Review Real-Time Metrics to monitor application performance.
• Set up Real-Time Events for production visibility.
• Configure Web Application Firewall for production security.
• Review the individual feature guides for advanced configuration.

Get Started with a Small Property

The best way to begin is not with the most complex Akamai property in your portfolio. Start with a property that is meaningful enough to validate the migration path, but small enough to move quickly and safely.

Choose a property that includes representative pieces of your architecture: one or two hostnames, a few origins, cache rules, redirects, headers, maybe one Cloudlet or EdgeWorker, and one logging destination. Use that property to validate the workflow, document the process, and identify internal patterns your team can reuse.

From there, expand gradually. Migrate more complex property rules. Move additional EdgeWorkers. Bring over storage and key-value data. Add observability. Review security rules. Then prepare production cutovers with greater confidence.

Recommended Next Steps

• Create your free Azion account
• Read the Applications documentation
• Explore the Azion CLI
• Review Data Stream

Need Help?

Get help from the Azion Support team, or join our Discord community to see how others are using Azion.