Migrate from Fastly to Azion

A platform migration usually begins long before the first service is cloned or the first domain is cut over. It starts when a team notices that delivery, compute, cache, security, and observability workflows are spread across too many configuration surfaces.

For teams using Fastly, this moment often appears after years of accumulated delivery logic: services with multiple origins, VCL snippets, Compute packages, dictionaries, cache overrides, TLS automation, WAF policies, logging endpoints, and inspector dashboards. Each layer may work independently, but the combined operational model can slow releases and make changes harder to validate.

For teams currently using Fastly Full-Site Delivery, Compute, Edge Data Storage, Object Storage, Image Optimizer, Fastly Next-Gen WAF, DDoS Protection, Bot Management, Platform TLS, High Volume Logging, Domain Inspector, Origin Inspector, or Log Explorer & Insights, Azion provides equivalent capabilities through Applications, Functions, KV Store, Object Storage, Image Processor, Firewall, Web Application Firewall, DDoS Protection, Bot Manager, Certificate Manager, Data Stream, 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, and observability into a unified platform designed for globally distributed applications.

How Fastly to Azion Migration Works

Traditional platform migrations often require rewriting service logic, reconfiguring origins from scratch, and recreating security and logging behavior under pressure. This approach creates operational risk, extends timelines, and makes rollback harder.

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

1. Incremental migration path. Start with one representative Fastly service, validate delivery and security behavior on Azion, and expand to additional services only after the pattern is proven.

2. Preserved application logic. Origins, cache policies, redirects, headers, security controls, and data access patterns map to Azion Applications, Rules Engine, Functions, Connectors, KV Store, and Object Storage with focused configuration changes.

3. Unified platform model. Instead of managing delivery, compute, storage, security, 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 comprehensive mapping of Fastly 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 four product categories, allowing teams to plan and execute each layer independently:

• Build: migrate delivery services, origins, VCL behavior, Compute code, cache policies, image optimization, streaming, WebSocket, and AI acceleration patterns.
• Secure: migrate domains, certificates, WAF policies, DDoS protection, bot controls, and rate limiting.
• Store: migrate object storage and edge key-value data to Object Storage and KV Store.
• Observe: migrate logging, inspectors, metrics, dashboards, and external log destinations to Azion’s real-time observability stack.

Build

The Build category covers application deployment, delivery configuration, compute, routing, cache, and media optimization. Start here to recreate the application behavior users see before moving security, data, and observability layers.

1. Project Setup on Azion

The first step brings your application into Azion in a way that is familiar to teams that already manage Fastly services and Compute projects. If you have used Fastly service versions, Compute packages, and CLI deployments, you already understand the pattern: define configuration, deploy a version, validate behavior, and promote 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:

import { defineConfig } from 'azion'

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

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 Service and Build Configuration

A migration can appear successful when the first request returns 200, but fail later when cache behavior, redirects, headers, or origin routing differs from Fastly. Review service configuration carefully instead of treating the migration as a simple command replacement.

CLI Quick Reference

Configuration Inventory

Before recreating the service in Azion, inventory:

• Active Fastly services and service versions
• Domains and TLS certificates
• Origins, shielding, health checks, and failover logic
• Cache settings, cache keys, stale behavior, and purge workflows
• Conditions, VCL snippets, custom VCL, and request/response settings
• Compute packages and language runtimes
• Dictionaries, Config Store data, Secret Store values, and Edge Data Storage
• WAF policies, bot controls, DDoS protections, and rate limits
• Logging endpoints, inspector dashboards, and alert dependencies

Reference documentation

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

3. Migrating Environment Variables and Secrets

Environment variables and secrets contain API keys, origin credentials, feature flags, third-party endpoints, and operational settings. Migrating them incorrectly causes runtime failures even when deployment succeeds.

Key Differences

Evaluate Your Variables

Before changing code, identify every variable in:

• fastly.toml and Compute project configuration
• Fastly dictionaries and Config Store entries
• Fastly Secret Store values
• 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": "API_TOKEN",
"value": "token-value"
}'

Update Your Code

// Before: Fastly Compute style configuration access varies by runtime
const apiKey = process.env.API_KEY;

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

Reference documentation

• Environment Variables
• Working with variables
• Functions Instances

4. Migrating Full-Site Delivery to Applications

Fastly Full-Site Delivery services deliver websites, applications, APIs, and mobile traffic through domains, origins, cache rules, and custom delivery logic. Azion Applications provide equivalent delivery capabilities with integrated Rules Engine, Cache, Functions, and Connectors.

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": "fastly-service-migration",
  "origins": [
    {
      "name": "origin-main",
      "addresses": [
        {
          "address": "origin.example.com",
          "weight": 1
        }
      ]
    }
  ],
  "cache_settings": {
    "default_ttl": 3600
  }
}'

Service Configuration Migration

import { defineConfig } from 'azion'

export default defineConfig({
name: 'fastly-service-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

5. Migrating VCL, Conditions, and Headers

Fastly services often contain business-critical behavior in VCL snippets, conditions, and request or response settings. Migrate simple rules to Rules Engine and reserve Functions for behavior that needs code.

Key Differences

Redirect Migration Example

# Fastly VCL pattern
if (req.url.path ~ "^/old/(.*)$") {
set req.http.Location = "/new/" + re.group.1;
error 750 "Moved Permanently";
}

# 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;

Migration Checklist

• Convert path-based conditions to Rules Engine criteria.
• Move simple header additions to response rules.
• Move request header normalization to request rules.
• Rebuild origin selection with Connectors and Rules Engine.
• Use Functions only when conditions require code, external lookups, signed tokens, or custom algorithms.

Reference documentation

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

6. Migrating Compute to Functions

Fastly Compute services run packaged code on Fastly’s network. Azion Functions provide distributed JavaScript execution for request handling, API orchestration, personalization, redirects, authentication, and integration logic.

Key Differences

Update Function Signature

// Before: Fastly Compute JavaScript style
addEventListener('fetch', (event) => {
event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
const url = new URL(request.url);
return new Response('Path: ' + url.pathname, {
  status: 200,
  headers: { 'Content-Type': 'text/plain' }
});
}

// After: Azion Functions
export default {
async fetch(request) {
  const url = new URL(request.url);
  return new Response('Path: ' + url.pathname, {
    status: 200,
    headers: { 'Content-Type': 'text/plain' }
  });
}
};

Update Configuration Access

// Before: Fastly Compute configuration access varies by runtime
const apiToken = process.env.API_TOKEN;

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

Non-JavaScript Compute Code

Fastly Compute projects written in Rust, Go, or other WebAssembly-targeted languages must be rewritten in JavaScript for Azion Functions. During the rewrite, separate generic business logic from platform-specific APIs:

Reference documentation

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

7. Migrating Load Balancing and Origin Failover

Fastly origin configuration can include multiple backends, shielding, health checks, and failover logic. Azion uses Connectors, Load Balancer, and Rules Engine to recreate origin routing and availability 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

8. Migrating Cache Configuration

Caching configuration determines how content is stored, revalidated, and purged. Fastly cache behavior often combines service settings, VCL, surrogate keys, cache overrides, and purge APIs. Azion provides Cache Settings, Rules Engine, Tiered Cache, 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
    }
  }
}'

Fastly Purge to Azion Purge

# Before: Fastly purge by URL
fastly purge --service-id SERVICE_ID https://www.example.com/images/logo.png

# 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
• Tiered Cache
• Real-Time Purge

9. Migrating Image Optimizer to Image Processor

Image optimization reduces file sizes while preserving visual quality. Azion Image Processor transforms, optimizes, and delivers images from distributed locations using URL parameters and application configuration.

Key Differences

Configuration Steps

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 Comparison

# Fastly 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

10. Migrating Streaming, Media Shield, WebSockets, and Fanout

Fastly streaming, Media Shield, WebSocket, and Fanout patterns are used for bandwidth-heavy and real-time workloads. Migrate each pattern based on the traffic model: cacheable media, long-lived connections, or publish-subscribe behavior.

Capability Mapping

WebSocket Migration Checklist

1. Enable WebSocket support on the target Application.
2. Confirm the origin accepts Upgrade: websocket and Connection: upgrade headers.
3. Validate that application routes do not apply cache or image processing to WebSocket traffic.
4. Test successful upgrades with 101 Switching Protocols responses.
5. Monitor WebSocket events and errors after cutover.

WebSocket Function Example

export default {
async fetch(request) {
  if (request.headers.get('upgrade') === 'websocket') {
    const { response, socket } = upgradeWebSocket(request);

    socket.addEventListener('message', (event) => {
      socket.send('received: ' + event.data);
    });

    return response;
  }

  return new Response('Expected WebSocket upgrade', { status: 400 });
}
};

Reference documentation

• WebSocket Proxy
• WebSocket API
• Tiered Cache
• Origin Shield

11. Migrating AI Accelerator Patterns

Fastly AI Accelerator focuses on semantic caching and acceleration for AI API traffic. On Azion, AI 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 prompt = await request.text();

  const response = await fetch('https://ai-provider.example.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ' + Azion.env.get('AI_API_KEY')
    },
    body: JSON.stringify({ prompt })
  });

  return response;
}
};

Reference documentation

• AI Inference
• AI Inference models
• Functions
• Cache

Secure

The Secure category covers domains, certificates, firewall rules, bot controls, DDoS protection, and rate limiting. Plan these migrations as controlled cutovers because they affect how users reach your application and how traffic 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
curl -I https://www.yourdomain.com/

Reference documentation

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

2. Migrating TLS to Certificate Manager

Fastly Platform TLS, TLS Service Options, and Certainly-backed workflows manage certificates and HTTPS service behavior. Azion Certificate Manager manages Let’s Encrypt, custom certificates, Azion SAN certificates, and Trusted CA certificates for mTLS scenarios.

Key Differences

Custom Certificate Upload

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-----"
}'

Reference documentation

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

3. Migrating Fastly Next-Gen WAF to Web Application Firewall

Web Application Firewall protects applications from malicious traffic, SQL injection, cross-site scripting, and other application-layer attacks. Migrating WAF rules requires careful mapping of rule logic, match conditions, 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": "Fastly 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

# Fastly-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

4. Migrating 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 Fastly DDoS assumptions, 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 Bot Management

Bot management protects applications from automated abuse while allowing legitimate bots. 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

6. Migrating Edge Rate Limiting

Rate limiting protects applications from abuse by limiting request rates per client, route, method, token, or custom key. Recreate Fastly rate limiting behavior with Firewall rules and Functions where custom counters or logic are required.

Key Differences

Firewall-Based Rate Limiting

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
• KV Store

Store

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

1. Migrating Fastly Object Storage to Object Storage

Object storage powers files that matter to users and business operations: images, documents, static assets, media files, 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:

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

2. Migrating Edge Data Storage to KV Store

Fastly Edge Data Storage and related key-value patterns are commonly used 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: Fastly data access varies by product and runtime
const value = await edgeData.get('feature:checkout');
await edgeData.put('feature:checkout', 'enabled');

// After: Azion KV Store
const kv = await Azion.KV.open('my-namespace');

const value = await kv.get('feature:checkout');
await kv.put('feature: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": "fastly-migration-kv"
}'

Migration Checklist

• Export keys, values, metadata, and expiration rules from Fastly.
• 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

Observe

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

1. Migrating Domain and Origin Inspector to Real-Time Metrics

Fastly Domain Inspector and Origin Inspector provide traffic and origin 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 Log Explorer & Insights 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 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

3. Migrating High Volume Logging to Data Stream

Fastly High Volume Logging 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": "Fastly 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

Troubleshooting

Common Issues

Key Advantages After Migration

Migrating from Fastly 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, and observability in one platform model.

With Azion, teams can build and run applications on globally distributed infrastructure while combining compute, delivery, storage, 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.

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 Service

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

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

From there, expand gradually. Migrate more complex VCL. Move additional Compute services. 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.