Migrate from Cloudflare to Azion

A platform migration usually begins long before the first configuration file is changed. It starts when a team notices that its current environment no longer gives the same level of clarity, speed, or control it once did.

Maybe deployments still work, but the process requires too much manual coordination. Maybe the application has grown beyond the original architecture. Maybe the team needs stronger compliance alignment, more predictable runtime behavior, or a more unified way to manage compute, storage, databases, delivery, and security.

For teams currently using Cloudflare Pages, Workers, Workers KV, R2, D1, redirects, custom headers, DNS, WAF, logs, or analytics, Azion provides equivalent capabilities through Applications, Functions, KV Store, Object Storage, SQL Database, Rules Engine, Edge DNS, Web Application Firewall, Real-Time Events, and Real-Time Metrics.

The strongest reason to migrate is not simply to replace one vendor with another. It is to modernize your application platform without restarting your architecture from zero.

How Cloudflare to Azion Migration Works

Traditional platform migrations often require rewriting application logic, reconfiguring infrastructure from scratch, and managing multiple disconnected services. This approach creates operational risk, extends timelines, and fragments team knowledge across different configuration patterns.

The Azion migration approach preserves your application logic while transitioning to a unified platform:

1. Incremental migration path. Start with a single project, validate each layer independently, and expand with confidence. No need to migrate everything at once.

2. Preserved application logic. Functions, redirects, headers, and data services map directly to Azion equivalents with minimal code changes—primarily syntax updates for environment access and service imports.

3. Unified platform model. Instead of managing compute, storage, databases, security, and observability as disconnected layers, Azion brings these capabilities together with consistent APIs and configuration patterns.

Feature Mapping

The following table provides a comprehensive mapping of Cloudflare products to their Azion equivalents. A dash (-) indicates that Azion does not currently offer a direct equivalent.

¹ Orchestrator includes Edge Services and Edge Node as integrated modules for orchestrating containerized workloads on private edge infrastructure.

² Functions can be instantiated within Firewall to transform requests and responses at the edge.

Migration Strategy

The migration is organized around Azion’s four product categories, allowing teams to plan and execute each layer independently:

• Build: deploy applications, configure builds and environment variables, migrate Functions, routing, headers, load balancing, cache, image optimization, and AI workloads.
• Secure: migrate custom domains, DNS, SSL/TLS certificates, WAF, DDoS protection, bot management, and rate limiting.
• Store: migrate key-value data, object storage, and SQL databases.
• Observe: migrate analytics, metrics, and logs to Azion’s real-time observability stack.

Build

The Build category covers application deployment, compute, routing, and configuration. Start here to bring your application onto Azion and establish the foundation for the rest of the migration.

1. Project Setup on Azion

The first step brings your application into Azion in a way that feels familiar to teams that deploy modern web projects. If you have used Cloudflare Pages, you already understand the pattern: connect a repository, define framework settings, run a build, deploy the output, and validate the generated URL.

Azion follows a similar workflow but with a broader platform context. Your project becomes part of an environment where application delivery, Functions, rules, security, and observability can be managed together.

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:

import { defineConfig } from 'azion'

export default defineConfig({
name: 'my-project',
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:

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

Reference documentation

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

2. Converting Build Configuration

A migration can appear successful when the build passes but fail later when runtime behavior differs. Review build and deployment configuration carefully instead of treating it as a mechanical command replacement.

CLI Quick Reference

Reference documentation

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

3. Migrating Environment Variables

Environment variables contain API keys, database credentials, authentication secrets, service endpoints, feature flags, and environment-specific configuration. Migrating them incorrectly causes runtime failures even when deployment succeeds.

Key Differences

Evaluate Your Variables

Before changing code, identify every variable in:

• Cloudflare Pages: Dashboard > Settings > Environment variables
• Cloudflare Workers: wrangler.toml
• CLI-managed secrets
• CI/CD environment settings
• Runtime configuration in source code

Create Variables in Azion

curl -X POST 'https://api.azionapi.net/variables' --header 'Accept: application/json; version=3' --header 'Authorization: Token [TOKEN VALUE]' --header 'Content-Type: application/json' --data '{
"key": "key-test",
"value": "value-test"
}'

Update Your Code

// Before: Cloudflare
const apiKey = env.API_KEY;

// After: Azion
const apiKey = Azion.env.get('API_KEY');

Reference documentation

• Environment Variables
• Working with variables
• Azion runtime environment variables reference

4. Migrating Rewrite and Redirect URLs

Redirects protect years of SEO value, campaign links, backlinks, bookmarks, and user expectations. When redirects break, the impact shows up as lost traffic, lower rankings, and poor user experience.

Key Differences

Pattern Conversion

Create Redirect Rules

Navigate to Rules Engine and configure:

Criteria:

${uri} matches ^/old-blog/(.*)$

Behavior:

Redirect To (301): /blog/%{capture[1]}

Verify Redirects

curl -I https://yourdomain.com/old-blog/post

Reference documentation

• Rules Engine for Applications
• Rules Engine variables and operators
• Applications reference

5. Migrating Custom Headers

HTTP headers control caching, security, and browser behavior. Azion gives teams a more flexible model through azion.config.js and Rules Engine, allowing rules that respond to request characteristics.

Key Differences

Example: Security Headers

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;

Reference documentation

• Rules Engine for Applications
• azion.config.js reference
• Applications main settings

6. Migrating Workers to Functions

Functions are the computational engine of modern distributed applications. They often contain the most business-critical logic: authentication, personalization, API orchestration, and integrations with third-party systems.

Key Differences

Update Function Signature

// Before: Cloudflare
export default {
async fetch(request, env, ctx) {
  const apiKey = env.API_KEY;
  return fetch(apiUrl, { headers: { 'Authorization': `Bearer ${apiKey}` }});
}
};

// After: Azion
export default {
async fetch(request, env, ctx) {
  const apiKey = Azion.env.get('API_KEY');
  return fetch(apiUrl, { headers: { 'Authorization': `Bearer ${apiKey}` }});
}
};

Update Geo Metadata

// Before: Cloudflare
const country = request.cf.country;

// After: Azion
const country = request.metadata['geoip_country_code'];

Update Service Imports

Azion provides two SQL interfaces:

• Runtime API (azion:sql) — for querying databases from Functions
• Azion Lib SDK (azion/sql) — for managing databases via API (build tools, scripts)

import { Database } from 'azion:sql';

// Open connection (async)
const db = await Database.open('my-database');

// Query and iterate results
const rows = await db.query('SELECT * FROM users');
let row = await rows.next();
while (row) {
const name = row.getString(0); // access column by index
console.log(name);
row = await rows.next();
}

Reference documentation

• Functions
• Functions Instances
• Runtime APIs
• JavaScript Runtime APIs reference
• SQL Database API (Runtime)
• Azion Lib SQL (SDK)

7. Migrating Load Balancing

Load balancing distributes traffic across multiple origins for high availability and performance. Azion Load Balancer provides health checks, steering policies, and origin failover.

Key Differences

Configuration Steps

# Create a Connector (origin) with load balancing configured at the address level
curl -X POST 'https://api.azionapi.net/v4/workspace/connectors' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "Origin-US-East",
  "type": "http",
  "attributes": {
    "addresses": [
      {
        "address": "origin1.example.com",
        "active": true,
        "modules": {
          "load_balancer": {
            "weight": 3
          }
        }
      },
      {
        "address": "origin2.example.com",
        "active": true,
        "modules": {
          "load_balancer": {
            "weight": 1
          }
        }
      }
    ]
  }
}'

Load Balancer Module Configuration

// Load balancer settings within address modules
{
"weight": 3,                    // Relative weight for weighted distribution
"method": "round_robin",        // Options: "round_robin", "least_conn", "ip_hash"
"max_retries": 3,               // Maximum retry attempts
"connection_timeout": 10,       // Connection timeout in seconds
"read_write_timeout": 30        // Read/write timeout in seconds
}

Reference documentation

• Load Balancer
• Connectors

8. Migrating Cache Configuration

Caching configuration determines how content is stored and served from distributed locations. Azion Cache provides fine-grained control over cache behavior with Tiered Cache support.

Key Differences

Cache Settings Migration

# Update cache settings for a specific cache setting within an application
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": "my-cache-setting",
  "browser_cache": {
    "ttl": 3600
  },
  "modules": {
    "cache": {
      "ttl": 86400
    },
    "tiered_cache": {
      "enabled": true
    }
  }
}'

Tiered Cache

Enable Tiered Cache to improve cache hit ratio:

// Tiered cache is configured within cache settings modules
{
"name": "my-cache-setting",
"modules": {
  "tiered_cache": {
    "enabled": true
  }
}
}

Cache Key Customization

Cache key customization uses Advanced Cache Key in Cache Settings combined with Adaptive Delivery for device-based variations:

Example: Vary cache by device group

1. In Cache Settings, enable Adaptive Delivery
2. Select “Content varies by some Device Groups (Whitelist)“
3. Choose device groups (e.g., Mobile, Desktop)
4. Apply via Rules Engine:

Criteria: ${uri} starts with /images/
Behavior: Set Cache Policy → [cache-setting-name]

Cache Purge

# 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://example.com/image.jpg",
    "https://example.com/styles.css"
  ],
  "layer": "cache"
}'

# 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://example.com/images/*"],
  "layer": "cache"
}'

Reference documentation

• Cache
• Cache Settings
• Tiered Cache
• Real-Time Purge
• Application Accelerator

9. Migrating Image Optimization

Image optimization reduces image file sizes while maintaining visual quality. Azion Image Processor transforms, optimizes, and delivers images from distributed node locations.

Key Differences

Configuration Steps

# Enable Image Processor within application modules
curl -X PATCH 'https://api.azionapi.net/v4/workspace/applications/{application_id}' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "modules": {
    "image_processor": {
      "enabled": true
    }
  }
}'

URL Format

Transform images via query string parameters:

# Cloudflare format
https://example.com/cdn-cgi/image/width=400,quality=85/image.jpg

# Azion format
https://example.com/image.jpg?ims=400x400

Transformation Parameters

Azion Image Processor uses the ims query parameter for transformations:

Reference documentation

• Image Processor
• How to process images
• Object Storage

10. Migrating AI Workloads (Workers AI to AI Inference)

AI inference enables low-latency AI-powered features in applications. Azion AI Inference provides GPU-backed inference for text and visual models, allowing you to run AI workloads close to your users.

Key Differences

Using AI Inference

// AI inference in Functions
export default {
async fetch(request) {
  const response = await fetch('https://ai-inference.example.com/v1/predict', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${Azion.env.get('AI_API_KEY')}`
    },
    body: JSON.stringify({
      model: 'text-generation',
      prompt: await request.text()
    })
  });
  return response;
}
};

AI Starter Kit

Use the AI Inference Starter Kit template:

# Deploy via CLI
azion deploy --template ai-inference-starter-kit

Reference documentation

• AI Inference
• AI Inference models
• AI Inference Starter Kit

Secure

The Secure category covers domains, DNS, certificates, firewall rules, and protection against malicious traffic. Plan these migrations as controlled cutovers, since they affect how users reach your application and how it is protected in production.

1. Migrating Custom Domains

Custom domain migration is one of the most sensitive parts of any platform transition. It affects users, SEO, brand trust, and production availability. Plan domain migration as a controlled cutover, not a last-minute DNS change.

Migration Strategies

Create the Certificate

Create your SSL/TLS certificate before pointing your domain 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

Reference documentation

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

2. Migrating DNS to Edge DNS

DNS configuration is foundational to application delivery. Migrating DNS requires careful planning to avoid downtime during the nameserver switch.

Key Differences

Migration Steps

# Create a DNS zone
curl -X POST 'https://api.azionapi.net/v4/workspace/dns/zones' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "my-zone",
  "domain": "example.com",
  "active": true
}'

# Add DNS records
curl -X POST 'https://api.azionapi.net/v4/workspace/dns/zones/{zone_id}/records' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "record_type": "A",
  "entry": "www",
  "ttl": 3600,
  "rdata": ["192.168.1.1"]
}'

Record Type Mapping

DNSSEC Configuration

To enable DNSSEC:

1. Navigate to your zone in Edge DNS.
2. Go to DNSSEC tab.
3. Enable DNSSEC.
4. Copy the DS record to your registrar.

# Verify DNSSEC
dig example.com DNSSEC +dnssec

Verify Propagation

# Check nameserver propagation
dig example.com NS +short

# Check specific record
dig www.example.com A +short

# Check from specific DNS server
dig @ns1.aziondns.net example.com A

Reference documentation

• Edge DNS
• DNSSEC compatibility
• Run the dig command
• Run the traceroute command

3. Migrating SSL/TLS to Certificate Manager

SSL/TLS certificates ensure secure communication between clients and your application. Azion provides automatic certificate provisioning and supports custom certificates.

Key Differences

Automatic Certificate Provisioning

Azion automatically provisions Let’s Encrypt certificates for custom domains:

# Create a workload with TLS configuration
# First, create a certificate via Certificate Manager, then reference it by ID
curl -X POST 'https://api.azionapi.net/v4/workspace/workloads' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "my-workload",
  "domains": ["www.example.com"],
  "tls": {
    "certificate": 12345,
    "minimum_version": "tls12",
    "ciphers": 1
  },
  "active": true,
  "infrastructure": 1
}'

Custom Certificate Upload

For organizations with existing certificates:

# Upload custom certificate
curl -X POST 'https://api.azionapi.net/v4/workspace/tls/certificates' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "name": "my-custom-cert",
  "certificate": "-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----",
  "private_key": "-----BEGIN PRIVATE KEY-----
...
-----END PRIVATE KEY-----"
}'

mTLS Configuration

For mutual TLS authentication:

1. Navigate to Certificate Manager.
2. Upload your CA certificate as a Trusted CA.
3. Configure your workload to require client certificates.
4. See the mTLS configuration guide for detailed steps.

Reference documentation

• Certificate Manager
• Firewall Certificate Manager
• Create a digital certificate
• mTLS

4. Migrating WAF to Web Application Firewall

Web Application Firewall protects applications from malicious traffic, SQL injection, cross-site scripting (XSS), and other application-layer attacks. Migrating WAF rules requires careful mapping of rule logic and understanding differences in rule construction.

Key Differences

Migration Steps

# Create a WAF instance
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": "My 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

Convert Cloudflare firewall rule to Azion Rules Engine:

Cloudflare expression:

(http.request.uri.path contains "/admin" and not ip.src in {10.0.0.0/8})

Azion criteria:

Variable: ${uri}
Operator: matches
Argument: /admin

AND

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

Reference documentation

• Web Application Firewall
• Rules Engine for Firewall
• Functions for Firewall

5. Migrating DDoS Protection

DDoS protection guards against volumetric attacks, protocol attacks, and application layer attacks. Azion provides automatic DDoS mitigation with no configuration required for most attack types.

Key Differences

Automatic Protection

Azion DDoS Protection activates automatically for all applications. No manual configuration is required for standard protection against:

• Volumetric attacks (UDP floods, ICMP floods)
• Protocol attacks (SYN floods, packet fragmentation)
• Application layer attacks (HTTP floods, slowloris)

Advanced Configuration

For applications requiring specific DDoS policies:

# DDoS protection is configured as a module within Firewall
# Update the Firewall with DDoS module settings
curl -X PATCH 'https://api.azion.com/v4/workspace/firewalls/{firewall_id}' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data '{
  "modules": {
    "ddos_protection": {
      "enabled": true,
      "sensitivity": "high"
    }
  }
}'

Network Shield

For network-layer protection, use Azion Network Shield:

• Provides L3/L4 DDoS protection
• Works with Edge DNS for traffic filtering
• Integrates with Firewall for unified security

Reference documentation

• DDoS Protection
• DDoS Mitigation
• Network Shield

6. Migrating Bot Management

Bot management protects applications from automated threats while allowing legitimate bots. Azion Bot Manager provides detection, challenge, and mitigation capabilities.

Key Differences

Bot Manager Lite (Marketplace)

For basic bot protection, install Bot Manager Lite from Azion Marketplace:

Custom Bot Rules

Create custom rules to handle specific bots:

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

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

Verification

# Test bot detection
curl -A "BadBot/1.0" https://yourdomain.com/
# Expected: 403 Forbidden or challenge page

curl -A "Mozilla/5.0" https://yourdomain.com/
# Expected: Normal response

Reference documentation

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

7. Migrating Rate Limiting

Rate limiting protects applications from abuse by limiting request rates per client. Azion provides rate limiting through Firewall rules and Functions.

Key Differences

Firewall-Based Rate Limiting

Configure rate limiting in Firewall Rules Engine:

# Create rate limiting rule
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": "Rate Limit API",
  "criteria": [[{"variable": "${uri}", "operator": "starts_with", "argument": "/api/"}]],
  "behaviors": [
    {"type": "rate_limit", "attributes": {"rps": 100, "window": 60, "action": "block"}}
  ]
}'

Reference documentation

• Rules Engine for Firewall
• Functions for Firewall
• Functions Instances for Firewall

Store

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

1. Migrating Workers KV with KV Store

Key-value storage is used for fast access to configuration, user preferences, session metadata, feature flags, and personalization data. The migration should preserve data consistency and application compatibility.

API Comparison

// Before: Cloudflare
await env.MY_KV_NAMESPACE.put('key1', 'value1');
const value = await env.MY_KV_NAMESPACE.get('key1');

// After: Azion
import { KVStore } from 'azion:kv';

const kv = new KVStore('my-store');
await kv.put('key1', 'value1');
const value = await kv.get('key1');

Export and Import

Export existing KV data through Cloudflare’s API. Before importing, review:

• Key naming conventions and prefixes
• Expiration logic
• Value formats and serialized object structure
• Missing-key and default value behavior

Reference documentation

• KV Store (azion
  module)
• Functions
• Runtime APIs

2. Migrating R2 with Object Storage

Object storage powers files that matter to users and business operations: images, documents, static assets, media files, uploads, and generated content.

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 s3cmd

s3cmd is a command-line tool for managing S3-compatible storage services. It’s an effective option for migrating data from Cloudflare R2 to Azion Object Storage.

1. Install s3cmd and run s3cmd --configure to set up your Azion credentials:

• Access Key / Secret Key: Enter the keys generated for Azion Object Storage.
• Default Region: us-east-005 (s3cmd also accepts us-east for interactive configuration).
• S3 Endpoint: s3.us-east-005.azionstorage.net.
• DNS template: %(bucket).s3.us-east-005.azionstorage.net.
• Use HTTPS protocol: true.

2. Use the following commands to migrate your data:

Reference documentation

• Object Storage
• How to access Object Storage using the S3 protocol
• Create and modify a bucket
• Upload and download objects
• Use a bucket as origin
• Storage library reference

3. Migrating D1 with SQL Database

Database migration touches the core of application state. Azion SQL Database is SQLite-compatible, ACID-compliant, and uses a distributed Main/Replicas architecture.

Key Differences

Update Your Code

// Before: Cloudflare
const result = await env.DB
.prepare('SELECT * FROM users WHERE id = ?')
.bind(1)
.first();

// After: Azion
import { Database } from 'azion:sql';

const db = new Database('my-database');
const result = await db
.prepare('SELECT * FROM users WHERE id = ?')
.bind(1)
.first();

Export and Import

# Export from D1
wrangler d1 export my-db --output=dump.sql

# Import to Azion (via SQL Shell CLI or migration workflow)

Reference documentation

• SQL Database
• Vector Search
• Create a database
• Install SQL Shell
• SQL Database Shell commands
• Import data into SQL Database

Observe

The Observe category covers analytics, metrics, and logs. Migrating observability ensures you keep production visibility, troubleshooting capabilities, and compliance reporting after the cutover.

1. Migrating Analytics to Real-Time Metrics

Analytics provide visibility into application performance, traffic patterns, and user behavior. Azion offers comprehensive observability through Real-Time Metrics, Real-Time Events, and GraphQL API.

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 (equivalent to TTFB), origin response time
• Bandwidth metrics: Data transferred, data saved by cache
• Cache metrics: Hit ratio, miss ratio, expired objects
• Error metrics: 4xx errors, 5xx errors, origin errors

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
• Historical Real-Time Metrics
• Analyze metrics
• Grafana plugin custom dashboards
• Grafana plugin pre-built dashboards
• Edge Pulse

2. Migrating Logs to Real-Time Events

Log data is essential for debugging, security analysis, and compliance. Real-Time Events provides immediate log access through Console or GraphQL API for real-time 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
• Configure sampling

3. Migrating Logs to Data Stream

Data Stream exports logs continuously to external destinations for long-term storage, analysis, and integration with external monitoring and security systems.

Key Differences

Configure Data Stream

# Create a 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": "My 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 10+ destinations:

• 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
• Connectors: Amazon S3, Azion Object Storage, Datadog, Splunk, Elasticsearch, Kinesis, BigQuery

Troubleshooting

Common Issues

Key Advantages After Migration

Migrating from Cloudflare to Azion is straightforward for most modern applications, especially those using Workers, KV, R2, or D1. The immediate goal of migration is continuity—your application should keep working, users should keep accessing the same experiences, and critical business flows should remain stable.

But the larger value comes after the migration, when the team starts operating on a more unified platform.

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

Functions can interact with platform services such as KV Store and SQL Database. Applications can use Rules Engine for routing, redirects, and headers. Object Storage can support static assets, media, and user-generated files. Security capabilities can protect workloads. Real-Time Metrics and Events can give teams visibility into what is happening in production.

For engineering leaders, this means more operational clarity. For developers, it means a more cohesive workflow. For infrastructure and security teams, it means stronger control over how applications are delivered and protected. For the business, it means a platform foundation that can support growth without adding unnecessary complexity to every release cycle.

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 Project

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

Choose an application or workload that includes representative pieces of your architecture: a build process, a few redirects, environment variables, maybe one function, and a manageable amount of data. Use that project to validate the workflow, document the process, and identify internal patterns your team can reuse.

From there, expand gradually. Migrate more complex routes. Move additional functions. Bring over storage and database workloads. 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
• Join the Azion community

Need Help?

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