Migre da AWS para a Azion | Guia completo

Aprenda a migrar da AWS para a Azion com menos risco operacional. Migre CloudFront, Lambda, S3, DynamoDB, Route 53, WAF e outros serviços AWS para Azion Applications, Functions, Object Storage, KV Store, Edge DNS e produtos de segurança. A Azion oferece um caminho completo de migração de serviços de compute, storage, banco de dados, segurança e observabilidade da AWS para uma plataforma de edge unificada.

Ver como Markdown

Migre da AWS para a Azion

Uma migração de plataforma geralmente começa muito antes de o primeiro arquivo de configuração ser alterado. Começa quando uma equipe percebe que seu ambiente atual não oferece mais o mesmo nível de clareza, velocidade ou controle que antes.

Para equipes que usam AWS, esse momento costuma vir depois de anos de complexidade acumulada: distribuições CloudFront com comportamentos de cache em camadas, funções Lambda com dependências de runtime, buckets S3 com políticas de acesso em evolução, tabelas DynamoDB com capacidade provisionada, zonas Route 53 com health checks, regras WAF com grupos de regras gerenciadas e alarmes CloudWatch com métricas customizadas. Cada serviço funciona, mas em conjunto eles criam overhead operacional que desacelera o desenvolvimento.

Para equipes que usam Amazon CloudFront, AWS Lambda, Amazon S3, Amazon DynamoDB, Amazon Route 53, AWS WAF, AWS Shield, Amazon CloudWatch ou outros serviços AWS, a Azion oferece recursos equivalentes por meio de Applications, Functions, Object Storage, KV Store, Edge DNS, Web Application Firewall, DDoS Protection, Real-Time Metrics e Real-Time Events.

O motivo mais forte para migrar não é simplesmente substituir um fornecedor por outro. É consolidar compute, storage, banco de dados, entrega, segurança e observabilidade em uma plataforma unificada projetada para aplicações distribuídas globalmente.

Como Funciona a Migração da AWS para a Azion

Migrações de plataforma tradicionais frequentemente exigem reescrever a lógica da aplicação, reconfigurar a infraestrutura do zero e gerenciar múltiplos serviços desconectados. Essa abordagem cria risco operacional, estende prazos e fragmenta o conhecimento da equipe entre diferentes padrões de configuração.

A abordagem de migração da Azion preserva a lógica da sua aplicação enquanto faz a transição para uma plataforma unificada:

Caminho de migração incremental. Comece com um único projeto, valide cada camada independentemente e expanda com confiança. Não é necessário migrar tudo de uma vez.
Lógica de aplicação preservada. Functions, políticas de cache, configurações de origem e serviços de dados mapeiam diretamente para equivalentes na Azion com mudanças mínimas de código, principalmente atualizações de sintaxe para acesso a ambiente e imports de serviços.
Modelo de plataforma unificado. Em vez de gerenciar compute, storage, bancos de dados, segurança e observabilidade como camadas desconectadas, a Azion reúne esses recursos com APIs consistentes e padrões de configuração.

Mapeamento de Recursos

As tabelas a seguir fornecem um mapeamento abrangente dos produtos AWS para seus equivalentes na Azion. Um traço (-) indica que a Azion atualmente não oferece um equivalente direto.

Produto AWS	Descrição	Equivalente Azion
Amazon CloudFront	CDN da AWS para entregar conteúdo estático, conteúdo dinâmico, APIs, aplicações e vídeo globalmente.	Applications
CloudFront Distributions	Recurso principal de entrega do CloudFront para domínios, origens, comportamento de cache, certificados, segurança e configurações de entrega no edge.	Applications
CloudFront Alternate Domain Names	Configura domínios customizados para distribuições CloudFront.	Workloads
CloudFront Cache Behaviors	Comportamento de entrega baseado em caminho, política de cache, política de requisição à origem, métodos permitidos e associações de edge function.	Rules Engine para Applications
CloudFront Cache Policies	Controla cache keys, TTLs, cabeçalhos, cookies, query strings e compressão.	Cache
CloudFront Origin Request Policies	Controla quais valores da requisição o CloudFront encaminha para a origem.	Rules Engine
CloudFront Response Headers Policies	Adiciona ou modifica cabeçalhos de resposta, como cabeçalhos de segurança e CORS.	Rules Engine para Applications
CloudFront Origin Shield	Camada adicional de cache centralizado para reduzir carga na origem e melhorar cache hit ratio.	Tiered Cache
CloudFront Invalidation	Remove conteúdo dos caches de edge do CloudFront antes da expiração.	Real-Time Purge
CloudFront Functions	Execução leve de JavaScript no edge para redirects, rewrites, cabeçalhos e normalização de cache key.	Functions para Applications
Lambda@Edge	Funções Node.js ou Python acionadas por eventos do CloudFront para customizar a entrega.	Functions para Applications
Lambda@Edge for security logic	Usa funções acionadas pelo CloudFront para validação de requisições, autenticação ou lógica de bloqueio.	Functions para Firewall
CloudFront Device Detection	Detecta tipo de dispositivo e encaminha metadados de dispositivo para a origem.	Device Groups
AWS Elemental MediaLive	Codificação de vídeo ao vivo em tempo real.	Live Ingest
AWS Elemental MediaPackage	Empacota e origina streams de vídeo ao vivo para HLS, DASH e formatos relacionados.	Live Ingest + Applications
CloudFront for live streaming	Entrega vídeo ao vivo globalmente usando CloudFront com AWS Media Services.	Applications + Live Ingest
AWS Lambda	Compute serverless de uso geral para execução de código orientada a eventos.	Functions para Applications
Amazon API Gateway	Cria e gerencia APIs REST, HTTP e WebSocket com integrações de backend.	Applications + Functions
API Gateway request validation / throttling	Aplica controles, throttling e regras de validação a requisições de API.	Rules Engine + Firewall
AWS Amplify Hosting	CI/CD baseado em Git e hospedagem para aplicações web estáticas e server-side rendered.	Applications + Azion CLI
AWS App Runner	Faz deploy de código fonte ou imagens de container para aplicações web gerenciadas.	Applications + Orchestrator
Amazon Bedrock	Acesso a foundation models e desenvolvimento de aplicações de IA generativa.	AI Inference
Amazon Bedrock model inference	Invoca foundation models para texto, imagem, embedding e casos de uso de IA generativa.	AI Inference
Amazon Bedrock Fine-Tuning	Customiza foundation models com fine-tuning para casos de uso específicos.	LoRA Fine-Tune
Amazon Bedrock Custom Model Import	Importa foundation models customizados para o Bedrock.	AI Inference + LoRA Fine-Tune
Amazon SageMaker AI Real-Time Inference	Faz deploy de modelos de ML em endpoints gerenciados de inferência em tempo real.	AI Inference
Amazon S3	Armazenamento de objetos para dados não estruturados, assets estáticos, backups, arquivos e sites.	Object Storage
Amazon S3 Static Website Hosting	Hospeda sites estáticos a partir de buckets S3.	Object Storage + Applications
S3 Object Lambda	Transforma objetos S3 com Lambda antes de retorná-los ao solicitante.	Object Storage + Functions
S3 Object Lambda for image transformation	Redimensiona, aplica marca d’água, redige ou transforma conteúdo recuperado do S3.	Image Processor + Functions
Amazon Aurora DSQL	Banco de dados SQL relacional distribuído e serverless para workloads transacionais.	SQL Database
Amazon DynamoDB	Banco de dados serverless key-value e de documentos.	KV Store
DynamoDB Global Tables	Replicação multi-Region para dados NoSQL distribuídos globalmente.	KV Store
AWS WAF	Web application firewall para proteger aplicações e APIs.	WAF / Firewall
AWS Managed Rules for AWS WAF	Grupos de regras gerenciadas para vulnerabilidades comuns e tráfego indesejado.	WAF Rule Sets
AWS WAF custom rules	Cria condições de correspondência e ações customizadas para requisições web.	Rules Engine para Firewall
AWS WAF Bot Control	Detecção e mitigação gerenciadas de bots.	Bot Manager
AWS WAF Rate-Based Rules	Limita taxas de requisições com base em IP, cabeçalhos, URI, método ou outras chaves.	Rules Engine + Network Shield
AWS WAF IP Sets	Listas reutilizáveis de IP/CIDR para regras de allow ou block.	Network Lists
AWS Shield Standard	Proteção DDoS padrão para recursos AWS.	DDoS Protection
AWS Shield Advanced	Proteção DDoS avançada com visibilidade e opções adicionais de mitigação.	DDoS Protection
AWS Network Firewall	Firewall de rede VPC gerenciado.	Network Shield
Elastic Load Balancing	Distribui tráfego entre múltiplos destinos e zonas de disponibilidade.	Load Balancer
Application Load Balancer	Load balancing HTTP/HTTPS de camada 7 com roteamento em nível de aplicação.	Load Balancer
Network Load Balancer	Load balancing TCP/UDP/TLS de camada 4.	Load Balancer
AWS Global Accelerator	IPs Anycast globais e roteamento otimizado na rede global da AWS.	Applications + Load Balancer
Amazon Route 53	DNS autoritativo, registro de domínio, políticas de roteamento e health checks.	Edge DNS
AWS Certificate Manager	Provisiona, importa, gerencia, faz deploy e renova certificados SSL/TLS.	Certificate Manager
Amazon CloudWatch Metrics	Coleta, consulta, visualiza e cria alarmes para métricas de serviço e aplicação.	Real-Time Metrics
Amazon CloudWatch Logs	Coleta, monitora, consulta e analisa logs.	Real-Time Events
Amazon Data Firehose	Entrega dados de streaming para destinos como S3, Redshift, OpenSearch e endpoints HTTP.	Data Stream
CloudWatch RUM	Monitoramento de usuário real para performance de aplicações browser e mobile.	Edge Pulse
AWS Management Console	Interface web para acessar e gerenciar serviços AWS.	Azion Console
AWS APIs	Interface programática para operações de serviços AWS.	Azion API
AWS CLI	Interface de linha de comando para gerenciar serviços AWS.	Azion CLI
AWS SDKs	SDKs específicos por linguagem para criar integrações com serviços AWS.	SDK
AWS CloudFormation	Serviço de Infrastructure as Code para modelar e provisionar recursos AWS.	Terraform Provider
Lambda runtime environment	Camada de runtime usada por funções Lambda.	Azion Runtime

Estratégia de Migração

A migração é organizada em torno das quatro categorias de produtos da Azion, permitindo que as equipes planejem e executem cada camada independentemente:

Build: faça deploy de aplicações, configure builds e variáveis de ambiente, migre funções Lambda, comportamentos CloudFront, roteamento, cabeçalhos, load balancing, cache, otimização de imagens e workloads de IA.
Secure: migre domínios customizados, DNS Route 53, certificados SSL/TLS, regras WAF, proteção DDoS, gerenciamento de bots e rate limiting.
Store: migre objetos S3, tabelas DynamoDB e bancos Aurora para Object Storage, KV Store e SQL Database.
Observe: migre métricas, logs e alarmes CloudWatch para a stack de observabilidade em tempo real da Azion.

Se você não precisa de tempo de inatividade próximo de zero, pode migrar em fases com janelas de manutenção. Isso permite parar escritas durante cada etapa de migração sem exigir sincronização paralela de dados.

Build

A categoria Build cobre deployment de aplicações, compute, roteamento e configuração. Comece aqui para trazer sua aplicação para a Azion e estabelecer a fundação para o resto da migração.

1. Configuração do Projeto na Azion

O primeiro passo traz sua aplicação para a Azion de uma forma familiar para equipes que fazem deploy de projetos web modernos na AWS. Se você usou AWS CloudFormation, SAM ou CDK, já entende o padrão: definir infraestrutura como código, configurar build, fazer deploy do output e validar a URL gerada.

Diferenças Principais

Aspecto	AWS	Azion
Arquivo de config	`template.yaml` (SAM) / `cdk.json` (CDK)	`azion.config.js` (JavaScript)
Detecção de framework	Configuração manual	20+ frameworks com auto-detecção
Cold starts	Comuns (Lambda regional)	Minimizados (nós distribuídos)
Conformidade	SOC 2, ISO 27001, HIPAA	PCI DSS 4.0.1 Level 1, SOC 2 Type II

Conecte Seu Repositório

Abra o Azion Console.
Clique em + Create > Import from GitHub.
Autorize o GitHub App da Azion.
Selecione o repositório que deseja migrar.

Mantenha o primeiro deployment intencionalmente pequeno. Não tente migrar todas as distribuições, funções, API gateways, dependências de storage e bancos de dados de uma vez. Comece provando que a aplicação consegue fazer build e rodar na Azion.

Configure Seu Build

A Azion detecta automaticamente seu framework e configura as definições de build. Sobrescreva o preset detectado em azion.config.js:

import { defineConfig } from 'azion'

export default defineConfig({

name: 'my-project',

preset: 'nextjs', // Sobrescreva a auto-detecção se necessário

})

Faça Deploy e Verifique

Faça deploy pelo Azion Console ou CLI. Sua URL temporária da Azion segue este padrão:

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

Valide o deployment:

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

Documentação de referência

2. Convertendo Configuração de Build

Uma migração pode parecer bem-sucedida quando o build passa, mas falhar depois quando o comportamento de runtime difere. Revise cuidadosamente a configuração de build e deployment em vez de tratá-la como uma substituição mecânica de comandos.

Referência Rápida de CLI

Tarefa	AWS CLI	Azion CLI
Instalar	`pip install awscli`	`curl -fsSL https://cli.azion.app/install.sh \| bash`
Login	`aws configure`	`azion login`
Dev local	`sam local start-api`	`azion dev`
Deploy	`sam deploy --guided` ou `cdk deploy`	`azion deploy`
Ver logs	`aws logs tail /aws/lambda/my-function`	`azion logs`

Comparação de Configuração de Build

Aspecto	AWS SAM/CDK	Azion
Infrastructure as Code	Templates YAML/TypeScript	Configuração JavaScript
Testes locais	Emulador SAM local	Servidor dev integrado
Deployment	Stacks CloudFormation	Deployment direto
Rollback	Stack rollback	Histórico de versões

Documentação de referência

3. Migrando Variáveis de Ambiente

Variáveis de ambiente contêm API keys, credenciais de banco de dados, secrets de autenticação, endpoints de serviços, feature flags e configuração específica de ambiente. Migrá-las incorretamente causa falhas de runtime mesmo quando o deployment é bem-sucedido.

Diferenças Principais

Aspecto	AWS	Azion
Acesso	`process.env.VARIABLE`	`Azion.env.get('VARIABLE')`
Gerenciamento de secrets	AWS Secrets Manager / Systems Manager Parameter Store	Variáveis em Functions Instances
Estágios de ambiente	Nome do estágio no ARN da função	Contexto de ambiente na configuração

Avalie Suas Variáveis

Antes de mudar o código, identifique todas as variáveis em:

AWS Lambda: variáveis de ambiente na configuração da função
AWS Secrets Manager: valores de secret e políticas de rotação
Systems Manager Parameter Store: parâmetros e caminhos
Elastic Beanstalk: propriedades de ambiente
Configurações de ambiente CI/CD (CodePipeline, CodeBuild)
Configuração de runtime no código fonte

Crie Variáveis na Azion

Acesse o Azion Console.
Navegue para Build > Variables.
Clique em Add Variable.
Insira o nome e valor da variável.
Clique em Save.

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"

}

A Azion gerencia variáveis de ambiente no nível da instância de Function, não por meio de uma API de variáveis standalone. Variáveis são configuradas como pares key-value no campo vars ao criar ou atualizar uma instância de function. Veja a documentação de Functions Instances para detalhes.

Atualize Seu Código

// Antes: AWS Lambda / Node.js

const apiKey = process.env.API_KEY;

const dbHost = process.env.DB_HOST;

// Antes: AWS com Secrets Manager (async)

const { SecretsManager } = require('@aws-sdk/client-secrets-manager');

const client = new SecretsManager();

const secret = await client.getSecretValue({ SecretId: 'my-secret' });

const secretValue = JSON.parse(secret.SecretString);

// Depois: Azion

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

const dbHost = Azion.env.get('DB_HOST');

aviso — Evite copiar secrets em notas locais, tickets, mensagens de chat ou documentos temporários. Mantenha secrets em sistemas aprovados e limite o acesso a processos que precisam deles.

Documentação de referência

4. Migrando CloudFront para Applications

Distribuições CloudFront entregam conteúdo a partir de edge locations com cache e configuração de origem. Azion Applications oferecem recursos semelhantes com Rules Engine integrado para manipulação de requisições e respostas.

Diferenças Principais

Aspecto	AWS CloudFront	Azion Applications
Configuração da distribuição	XML/JSON em CloudFormation	Configuração JavaScript ou Console
Origens	S3, ALB, origens customizadas	Connectors (HTTP, Object Storage)
Comportamentos	Cache behaviors com caminhos	Rules Engine com critérios
Certificados SSL	ACM (somente us-east-1)	Digital Certificates
Lambda@Edge	Edge functions (4 triggers)	Functions (fases de requisição/resposta)

Passos de Configuração

Acesse o Azion Console.
Navegue para Build > Applications.
Clique em Add Application.
Configure suas Main Settings:
- Nomeie sua aplicação
- Defina o tipo de origem (HTTP, Object Storage)
- Configure o endereço da origem
Configure Cache Settings para TTL.
Configure Rules Engine para roteamento baseado em caminho.
Adicione Custom Domains quando estiver pronto.

curl -X POST 'https://api.azionapi.net/v4/workspace/applications' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "my-app",

"origins": [

{

"name": "origin-main",

"addresses": [

{

"address": "origin.example.com",

"weight": 1

}

]

}

],

"cache_settings": {

"default_ttl": 3600

}

Migração de Configuração de Distribuição

// Configuração de distribuição CloudFront (CloudFormation YAML convertido para Azion JS)

import { defineConfig } from 'azion'

export default defineConfig({

name: 'my-distribution',

applications: [{

name: 'main-app',

origins: [{

name: 's3-origin',

type: 'object_storage',

addresses: [{

address: 'my-bucket.azionedge.net',

weight: 1

}]

}],

cache: {

ttl: 86400,

staleWhileRevalidate: 300

},

rules: {

request: [{

name: 'API Routes',

criteria: [{

variable: 'uri',

operator: 'starts_with',

argument: '/api/'

}],

behavior: {

bypassCache: true,

runFunction: 'api-handler'

}

}]

}

}]

})

Origin Request vs Viewer Request

No CloudFront, funções Lambda@Edge são acionadas em pontos diferentes. A Azion mapeia isso para fases do Rules Engine:

Trigger CloudFront	Equivalente Azion
Viewer Request	Rules Engine > Request Phase
Origin Request	Rules Engine > Request Phase (após verificação de cache)
Origin Response	Rules Engine > Response Phase
Viewer Response	Rules Engine > Response Phase

Documentação de referência

5. Migrando API Gateway para Applications + Functions

API Gateway oferece gerenciamento de APIs REST e HTTP com authorizers, throttling e gerenciamento de stages. Azion Applications combinadas com Functions entregam recursos semelhantes com execução distribuída.

Diferenças Principais

Aspecto	AWS API Gateway	Azion Applications + Functions
Tipos de API	REST API, HTTP API	Functions com roteamento
Authorizers	Lambda, Cognito, JWT	Functions com lógica customizada
Stages	Variáveis de stage e deployments	Configuração de ambiente
Throttling	Usage plans + rate limiting	Regras de Rate Limit
Domínios customizados	Mapeamentos de domínio	Domínios de Application

Passos de Configuração

Acesse o Azion Console.
Navegue para Build > Functions.
Crie Functions para cada endpoint de API.
Navegue para Build > Applications.
Crie uma Application para sua API.
Configure Rules Engine para rotear caminhos para Functions.
Configure regras de rate limiting.
Adicione autenticação via Functions.

# Crie uma Function

curl -X POST 'https://api.azionapi.net/v4/workspace/functions' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "api-handler",

  "code": "export default { async fetch(request) { return new Response(JSON.stringify({ message: "Hello" }), { headers: { "Content-Type": "application/json" } }); } }"

}

# Crie Application com regras de roteamento

curl -X POST 'https://api.azionapi.net/v4/workspace/applications' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "api-gateway",

"rules": {

"request": [{

"name": "API Route",

"criteria": [{ "variable": "uri", "operator": "starts_with", "argument": "/api/" }],

"behavior": { "runFunction": "api-handler" }

}]

}

Migração de API Gateway Authorizer

// Antes: AWS Lambda Authorizer

exports.handler = async (event) => {

const token = event.authorizationToken;

try {

const decoded = jwt.verify(token, process.env.JWT_SECRET);

return {

principalId: decoded.sub,

policyDocument: {

Version: '2012-10-17',

Statement: [{

Action: 'execute-api:Invoke',

Effect: 'Allow',

Resource: event.methodArn

}]

}

};

} catch (err) {

throw new Error('Unauthorized');

}

};

// Depois: Azion Function para autorização

export default {

async fetch(request) {

const authHeader = request.headers.get('Authorization');

if (!authHeader) {

return new Response('Unauthorized', { status: 401 });

}

const token = authHeader.replace('Bearer ', '');

try {

const secret = Azion.env.get('JWT_SECRET');

const decoded = await verifyJWT(token, secret);

// Armazene informações do usuário em metadados da requisição para funções downstream

request.metadata['user_id'] = decoded.sub;

return request; // Continue para o próximo handler

} catch (err) {

return new Response('Unauthorized', { status: 401 });

}

};

Exemplo de Migração de Rotas

// Rotas API Gateway → Azion Rules Engine

// Antes: caminhos de recursos do API Gateway

// GET /users/{id}

// POST /users

// PUT /users/{id}

// DELETE /users/{id}

// Depois: configuração do Azion Rules Engine

import { defineConfig } from 'azion'

export default defineConfig({

applications: [{

name: 'api-app',

rules: {

request: [

{

name: 'GET /users/:id',

criteria: [

{ variable: 'uri', operator: 'matches_regex', argument: '^/users/([0-9]+)$' },

{ variable: 'request_method', operator: 'equals', argument: 'GET' }

],

behavior: { runFunction: 'get-user' }

},

{

name: 'POST /users',

criteria: [

{ variable: 'uri', operator: 'equals', argument: '/users' },

{ variable: 'request_method', operator: 'equals', argument: 'POST' }

],

behavior: { runFunction: 'create-user' }

}

]

}

}]

})

Documentação de referência

6. Migrando Lambda para Functions

Functions são o motor computacional de aplicações distribuídas modernas. Frequentemente contêm a lógica mais crítica do negócio: autenticação, personalização, orquestração de API e integrações com sistemas de terceiros.

Diferenças Principais

Aspecto	AWS Lambda	Azion Functions
Assinatura da função	`exports.handler = async (event) => {}`	`export default { async fetch(request) {} }`
Runtime	Node.js, Python, Java, Go, .NET, Ruby	JavaScript (V8 isolates)
Memória	128 MB - 10.240 MB	512 MB (padrão)
Timeout	1 s - 15 min	Configurável por execução
Cold starts	Comuns (regional, VPC-cold)	Minimizados (nós distribuídos)
Fontes de evento	SQS, SNS, Kinesis, DynamoDB, API Gateway	Requisições HTTP, triggers agendados

Atualize Assinatura da Função

// Antes: AWS Lambda

exports.handler = async (event) => {

const body = JSON.parse(event.body);

const pathParams = event.pathParameters;

const queryParams = event.queryStringParameters;

// Processe a requisição

return {

statusCode: 200,

headers: { 'Content-Type': 'application/json' },

body: JSON.stringify({ message: 'Hello', data: body })

};

// Depois: Azion Functions

export default {

async fetch(request) {

const body = await request.json();

const url = new URL(request.url);

const queryParams = Object.fromEntries(url.searchParams);

// Processe a requisição

return new Response(JSON.stringify({ message: 'Hello', data: body }), {

status: 200,

headers: { 'Content-Type': 'application/json' }

});

}

};

Migração de Contexto de Evento

// Antes: contexto de evento AWS Lambda

exports.handler = async (event, context) => {

const requestId = context.awsRequestId;

const functionName = context.functionName;

const remainingTime = context.getRemainingTimeInMillis();

// Metadados de requisição do API Gateway

const sourceIp = event.requestContext.identity.sourceIp;

const userAgent = event.requestContext.identity.userAgent;

const country = event.headers['CloudFront-Viewer-Country'];

return { statusCode: 200, body: 'OK' };

};

// Depois: Azion Functions

export default {

async fetch(request, env, ctx) {

// Metadados da requisição

const requestId = request.headers.get('x-request-id');

const userAgent = request.headers.get('user-agent');

const country = request.metadata['geoip_country_code'];

const city = request.metadata['geoip_city'];

// Metadados geo disponíveis diretamente

const region = request.metadata['geoip_region'];

return new Response('OK', { status: 200 });

}

};

Migração de Variáveis de Ambiente

// Antes: AWS Lambda

const dbUrl = process.env.DATABASE_URL;

const apiKey = process.env.API_KEY;

// Depois: Azion Functions

const dbUrl = Azion.env.get('DATABASE_URL');

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

Comparação de Cold Start

AWS Lambda cold starts variam significativamente com runtime, alocação de memória e configuração de VPC. Azion Functions minimizam cold starts por meio de distribuição em nós:

Cenário	Cold Start AWS Lambda	Cold Start Azion Functions
Node.js (sem VPC)	100-300ms	Mínimo
Node.js (com VPC)	500ms-2s	N/A (sem conceito de VPC)
Java/Spring	1-5s	N/A
Python	100-500ms	N/A

Azion Functions usam V8 isolates (runtime JavaScript), fornecendo performance consistente sem a variabilidade de cold start de Lambda baseado em containers. Se você tem funções Lambda em Java, Python ou outros runtimes, será necessário reescrevê-las em JavaScript.

Documentação de referência

7. Migrando Load Balancing (ALB/NLB para Load Balancer)

Load balancing distribui tráfego entre múltiplas origens para alta disponibilidade e performance. O Azion Load Balancer fornece health checks, políticas de steering e failover de origem na infraestrutura distribuída.

Diferenças Principais

Aspecto	AWS ALB/NLB	Azion Load Balancer
Health checks	HTTP, HTTPS, TCP	HTTP, HTTPS, TCP
Políticas de steering	Round-robin, Least connections, IP hash	Round-robin, Least connections, Geo
Failover	Failover de target group	Failover em nível de origem
Afinidade de sessão	Cookie, IP hash	Cookie, IP hash
Targets	EC2, Lambda, endereços IP	Connectors (origens)
Protocolo	Camada 4 (NLB), Camada 7 (ALB)	Camada 7 (HTTP/HTTPS)

Passos de Configuração

Acesse o Azion Console.
Vá para Products menu > Connectors.
Crie um Connector para cada servidor de origem.
Configure health checks para cada origem.
Na sua Application, configure origens com definições de load balancing.
Defina pesos de origem para distribuição ponderada.
Habilite afinidade de sessão se necessário.

# Crie um Connector com múltiplos endereços para load balancing

curl -X POST 'https://api.azionapi.net/v4/workspace/connectors' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "Origin-Pool-US",

"type": "http",

"attributes": {

"addresses": [

{

"address": "us-east-origin1.example.com",

"active": true,

"modules": {

"load_balancer": {

"weight": 3,

"method": "round_robin"

}

},

{

"address": "us-east-origin2.example.com",

"active": true,

"modules": {

"load_balancer": {

"weight": 1,

"method": "round_robin"

}

]

}

Configuração do Módulo Load Balancer

// Configurações de load balancer dentro dos módulos de endereço do Connector

{

"weight": 3, // Peso relativo para distribuição ponderada

"method": "round_robin", // Opções: "round_robin", "least_conn", "ip_hash"

"max_retries": 3, // Máximo de tentativas em caso de falha

"connection_timeout": 10, // Timeout de conexão em segundos

"read_write_timeout": 30 // Timeout de leitura/escrita em segundos

}

Migração de Target Group ALB

Config AWS ALB	Equivalente Azion
Target Group	Connector
Health Check Path	Caminho de health check do Connector
Health Check Interval	Intervalo de health check do Connector
Healthy Threshold	Limite de sucesso do health check
Unhealthy Threshold	Limite de falha do health check

Documentação de referência

8. Migrando Configuração de Cache

A configuração de cache determina como o conteúdo é armazenado e servido a partir de localizações de nós. O Azion Cache fornece controle granular com suporte a Tiered Cache para melhorar hit ratios.

Diferenças Principais

Aspecto	AWS CloudFront Cache	Azion Cache
Níveis de cache	Regional edge caches + Edge locations	Tiered Cache + Cache + Browser Cache
Cache key	Política de cache + política de requisição à origem	Customizável via Rules Engine
Purge	Invalidations (baseadas em caminho)	Purge por URL, Cache Key, Wildcard
Conteúdo stale	Origin shield, stale-while-revalidate	Stale-while-revalidate
Limites de TTL	Padrão 24h, máximo 1 ano	Configuração por regra

CloudFront Cache Policies para Azion Cache Settings

CloudFront Cache Policy	Equivalente Azion
CachingOptimized	Default Cache Settings com TTL alto
CachingDisabled	Comportamento Bypass Cache no Rules Engine
Elemental-MediaPackage	Cache Settings customizadas para streaming
Política customizada	Cache Settings + Rules Engine

Passos de Configuração

Acesse o Azion Console.
Edite sua Application.
Navegue para Cache Settings.
Configure TTL de cache padrão.
Habilite Tiered Cache para melhorar hit ratio.
Adicione regras de cache customizadas via Rules Engine.

# Atualize configurações de cache para uma aplicação

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

}

Configurações de cache são gerenciadas como sub-recursos sob aplicações. Você deve especificar tanto o application_id quanto o cache_setting_id para atualizar a configuração de cache.

Customização de Cache Key

No CloudFront, cache keys são definidas por políticas de cache. Na Azion, use Advanced Cache Key em Cache Settings:

Exemplo: Variar cache por query strings

// Em Cache Settings

{

"name": "api-cache",

"cache_key": {

"query_string": {

"include_all": false,

"include": ["version", "lang"]

}

CloudFront Invalidation para Azion Purge

# Antes: invalidation do AWS CloudFront

aws cloudfront create-invalidation --distribution-id E123456789ABCD --paths "/images/*" "/css/*"

# Depois: purge de cache na Azion

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/*",

"https://example.com/css/*"

],

"layer": "cache"

}

Documentação de referência

9. Migrando Otimização de Imagens

A otimização de imagens reduz tamanhos de arquivos mantendo a qualidade visual. O Azion Image Processor transforma, otimiza e entrega imagens a partir de localizações distribuídas com seleção automática de formato.

Diferenças Principais

Aspecto	AWS CloudFront + Lambda@Edge	Azion Image Processor
Storage	Origem S3	Integração com Object Storage
Transformações	Lambda@Edge customizado	Transformações integradas
Formato de URL	Implementação customizada	Parâmetro de query `?ims=<OPTIONS>`
Suporte de formato	Implementação customizada	WebP, AVIF, JPEG, PNG
URLs assinadas	CloudFront signed URLs	Secure Token

Comparação de Formato de URL

# AWS CloudFront (requer Lambda@Edge ou origem customizada)

# Geralmente usa estrutura de URL customizada:

https://d12345.cloudfront.net/images/photo.jpg?w=400&q=80

# Azion Image Processor

https://example.com/images/photo.jpg?ims=400x400

Parâmetros de Transformação

O Azion Image Processor usa o parâmetro de query ims para transformações:

Sintaxe	Descrição	Exemplo
`?ims=WxH`	Redimensiona para largura x altura	`?ims=400x300`
`?ims=Wx`	Redimensiona para largura (altura automática)	`?ims=400x`
`?ims=xH`	Redimensiona para altura (largura automática)	`?ims=x300`
`?ims=WxH:fill`	Crop para dimensões exatas	`?ims=400x300:fill`
`?ims=WxH:fit`	Ajusta dentro das dimensões	`?ims=400x300:fit`

Passos de Configuração

Acesse o Azion Console.
Edite sua Application.
Navegue para configurações de Image Processor.
Habilite Image Processor.
Configure qualidade padrão e configurações de formato.
Configure Object Storage como fonte de imagens (opcional).

# Habilite Image Processor dentro dos módulos da aplicação

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

}

A configuração image_processor deve estar aninhada sob modules no corpo da requisição. Configurações do Image Processor são gerenciadas no nível da aplicação.

O Azion Image Processor otimiza automaticamente o formato da imagem baseado no cabeçalho Accept do cliente, servindo WebP ou AVIF para browsers suportados.

Documentação de referência

10. Migrando Workloads de IA (Bedrock para AI Inference)

Inferência de IA habilita recursos alimentados por IA com baixa latência em aplicações. O Azion AI Inference fornece inferência com suporte a GPU para modelos de texto e visuais na infraestrutura distribuída.

Diferenças Principais

Aspecto	AWS Bedrock	Azion AI Inference
Acesso a modelos	Foundation models gerenciados	Deployment de modelos customizados
API de inferência	Bedrock Runtime API	REST API + Functions
Tipos de modelos	Claude, Llama, Titan, Stable Diffusion	Modelos customizados, LLMs
Suporte a GPU	Infraestrutura gerenciada	Instâncias de GPU dedicadas
Preço	Por token / por imagem	Por inferência

Passos de Configuração

Acesse o Azion Console.
Vá para AI Inference (via Marketplace ou Functions).
Faça deploy de um modelo ou use templates prontos.
Configure o endpoint de inferência.
Integre com sua aplicação via Functions.

// Inferência de IA em Azion Functions

export default {

async fetch(request) {

const body = await request.json();

// Chame o endpoint de inferência de IA

const response = await fetch('https://ai-inference.azion.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: body.prompt,

max_tokens: 100

})

});

return response;

}

};

Exemplo de Migração de Bedrock para Azion

// Antes: AWS Bedrock

import { BedrockRuntime } from '@aws-sdk/client-bedrock-runtime';

const client = new BedrockRuntime({ region: 'us-east-1' });

const response = await client.invokeModel({

modelId: 'anthropic.claude-3-sonnet-20240229-v1:0',

contentType: 'application/json',

accept: 'application/json',

body: JSON.stringify({

anthropic_version: 'bedrock-2023-05-31',

max_tokens: 1024,

messages: [{ role: 'user', content: 'Hello, world!' }]

})

});

// Depois: Azion AI Inference

export default {

async fetch(request) {

const response = await fetch('https://ai-inference.azion.com/v1/chat/completions', {

method: 'POST',

headers: {

'Content-Type': 'application/json',

'Authorization': `Bearer ${Azion.env.get('AI_API_KEY')}`

},

body: JSON.stringify({

model: 'claude-3-sonnet',

messages: [{ role: 'user', content: 'Hello, world!' }],

max_tokens: 1024

})

});

return response;

}

};

Documentação de referência

11. Migrando Orquestração (Step Functions, EventBridge)

AWS Step Functions e EventBridge oferecem orquestração de workflows e roteamento de eventos. A Azion alcança padrões semelhantes por meio de encadeamento de Functions e Data Streaming para arquiteturas orientadas a eventos.

Diferenças Principais

Aspecto	AWS Step Functions	Encadeamento de Azion Functions
Definição de workflow	ASL (Amazon States Language)	JavaScript/TypeScript
Gerenciamento de estado	State machine integrado	Implementação customizada
Tratamento de erro	Retry, catch, fallback	Try/catch em Functions
Visualização	Workflow Studio	Baseada em código

Aspecto	AWS EventBridge	Azion Data Streaming
Roteamento de eventos	Rules e targets	Data Streaming + Functions
Padrões de evento	Pattern matching	Lógica customizada em Functions
Targets	100+ serviços AWS	Endpoints HTTP, Functions

Step Functions para Encadeamento de Functions

// Antes: AWS Step Functions (ASL)

{

"Comment": "Order processing workflow",

"StartAt": "ValidateOrder",

"States": {

"ValidateOrder": {

"Type": "Task",

"Resource": "arn:aws:lambda:us-east-1:123456789:function:validate-order",

"Next": "ProcessPayment"

},

"ProcessPayment": {

"Type": "Task",

"Resource": "arn:aws:lambda:us-east-1:123456789:function:process-payment",

"Catch": [{

"ErrorEquals": ["PaymentFailed"],

"Next": "NotifyFailure"

}],

"Next": "FulfillOrder"

},

"FulfillOrder": {

"Type": "Task",

"Resource": "arn:aws:lambda:us-east-1:123456789:function:fulfill-order",

"End": true

},

"NotifyFailure": {

"Type": "Task",

"Resource": "arn:aws:lambda:us-east-1:123456789:function:notify-failure",

"End": true

}

// Depois: Azion Functions (padrão orquestrador)

export default {

async fetch(request) {

const order = await request.json();

try {

// Etapa 1: Validar

const validated = await validateOrder(order);

// Etapa 2: Processar pagamento

const payment = await processPayment(validated);

// Etapa 3: Realizar fulfillment do pedido

const fulfillment = await fulfillOrder(payment);

return new Response(JSON.stringify(fulfillment), {

headers: { 'Content-Type': 'application/json' }

});

} catch (error) {

// Tratamento de erro

await notifyFailure({ order, error: error.message });

return new Response(JSON.stringify({ error: error.message }), {

status: 500,

headers: { 'Content-Type': 'application/json' }

});

}

};

EventBridge para Data Streaming

// Antes: regra AWS EventBridge

{

"source": ["com.mycompany.orders"],

"detail-type": ["OrderCreated"],

"detail": {

"amount": [{ "numeric": [">", 100] }]

}

// Target: função Lambda para processamento

// Depois: Azion Data Streaming + Functions

// Configure Data Streaming para enviar eventos ao endpoint da sua Function

// Então processe na Function:

export default {

async fetch(request) {

const events = await request.json();

for (const event of events) {

if (event.source === 'com.mycompany.orders' &&

event.type === 'OrderCreated' &&

event.data.amount > 100) {

// Processe pedido de alto valor

await processHighValueOrder(event.data);

}

return new Response('OK');

}

};

Documentação de referência

Secure

A categoria Secure cobre domínios, DNS, certificados, regras de firewall e proteção contra tráfego malicioso. Planeje essas migrações como cutovers controlados, já que afetam como os usuários acessam sua aplicação e como ela é protegida em produção.

1. Migrando Domínios Customizados

A migração de domínios customizados é uma das partes mais sensíveis de qualquer transição de plataforma. Afeta usuários, SEO, confiança na marca e disponibilidade de produção. Planeje a migração de domínio como um cutover controlado, não uma mudança de DNS de última hora.

Estratégias de Migração

Estratégia	Melhor Para	Controle de DNS
CNAME	Migração rápida de subdomínio	Mantenha Route 53 como provedor de DNS
Nameserver	Controle total de DNS e domínios apex	Transfira DNS para a Azion

Crie o Certificado

Crie seu certificado SSL/TLS antes de apontar seu domínio para a Azion. Isso garante que os usuários possam acessar a aplicação de forma segura via HTTPS quando o domínio começar a resolver para a nova infraestrutura.

A Azion fornece certificados Let’s Encrypt gratuitos com renovação automática.

Configure o Domínio

Crie um workload no Azion Console e associe seu domínio customizado. Veja a documentação de Workloads.

Aponte o Domínio para a Azion

Atualize sua hosted zone do Route 53 para apontar o subdomínio para a Azion:

www CNAME xxxxxxxxxx.map.azionedge.net

Isso mantém Route 53 como seu provedor de DNS enquanto roteia o tráfego através da Azion.

Configure seu domínio para usar os nameservers DNS da Azion no seu registrador de domínios:

ns1.aziondns.net

ns2.aziondns.com

ns3.aziondns.org

Isso dá à Azion controle total de DNS, necessário para domínios apex.

Verifique Propagação

dig www.yourdomain.com CNAME +short

aviso — Antes de trocar tráfego de produção, confirme: certificado está ativo, domínio está associado ao workload correto, registros DNS estão prontos, rotas críticas foram testadas, redirects se comportam como esperado e monitoramento está configurado para validação pós-cutover.

Documentação de referência

2. Migrando DNS para Edge DNS

A configuração de DNS é fundamental para a entrega de aplicações. Migrar de Route 53 para Edge DNS requer planejamento cuidadoso para evitar tempo de inatividade durante a troca de nameservers.

Diferenças Principais

Aspecto	Route 53	Azion Edge DNS
Nameservers	Atribuídos por hosted zone	`ns1.aziondns.net`, `ns2.aziondns.com`, `ns3.aziondns.org`
Tipos de registro	A, AAAA, CNAME, MX, TXT, SRV, NS, SOA, PTR, CAA	A, AAAA, CNAME, MX, TXT, SRV, NS, CAA, PTR
Políticas de roteamento	Simple, Weighted, Latency, Failover, Geolocation	Round-robin, Geo
Health checks	Route 53 health checks	Connector health checks
DNSSEC	Suportado	Suportado
API	REST API	REST API v4
Anycast	Global Anycast	Global Anycast

Passos de Migração

Acesse o Azion Console.
Vá para Products menu > Edge DNS.
Clique em + Zone para criar uma nova zona DNS.
Insira o nome do seu domínio.
Adicione registros DNS correspondentes à sua configuração Route 53.
Anote os nameservers Azion atribuídos à sua zona.
Atualize os nameservers no seu registrador de domínios (não no Route 53).

# Crie uma zona DNS

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

}

# Adicione registros DNS

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"]

}

Zonas DNS requerem campos name, domain e active. Registros DNS usam rdata como um array de strings (ex: ["192.168.1.1"] para registros A, ["mail.example.com"] para CNAME). O campo entry especifica o prefixo do nome do registro.

Mapeamento de Tipos de Registro

Registro Route 53	Azion Edge DNS	Notas
A	A	Mapeamento direto de IP
AAAA	AAAA	Endereço IPv6
CNAME	CNAME	Alias para outro domínio
MX	MX	Mail exchange (incluir prioridade)
TXT	TXT	Registros de texto (SPF, DKIM)
SRV	SRV	Registros de serviço
CAA	CAA	Certificate Authority Authorization
NS	NS	Delegação de nameserver
PTR	PTR	Reverse DNS lookup

Migração de Política de Roteamento

Política Route 53	Equivalente Azion	Implementação
Simple	Registro padrão	Registro único com um ou mais valores
Weighted	Não suportado diretamente	Use Functions para lógica customizada
Latency	Não suportado diretamente	Applications lida com roteamento
Failover	Não suportado diretamente	Configure via Rules Engine
Geolocation	Roteamento Geo	Disponível em Edge DNS

Configuração de DNSSEC

Para habilitar DNSSEC:

Navegue para sua zona no Edge DNS.
Vá para a aba DNSSEC.
Habilite DNSSEC.
Copie o registro DS para seu registrador de domínios.

# Verifique DNSSEC

dig example.com DNSSEC +dnssec

Verifique Propagação

# Verifique propagação de nameserver

dig example.com NS +short

# Verifique registro específico

dig www.example.com A +short

# Verifique de servidor DNS específico

dig @ns1.aziondns.net example.com A

# Compare registros Route 53 e Azion

dig @ns-1234.awsdns-12.com example.com A

dig @ns1.aziondns.net example.com A

Documentação de referência

3. Migrando SSL/TLS para Certificate Manager

Certificados SSL/TLS garantem comunicação segura entre clientes e sua aplicação. A Azion fornece provisionamento automático de certificados e suporta certificados customizados do AWS Certificate Manager (ACM).

Diferenças Principais

Área	AWS Certificate Manager	Azion Certificate Manager
Tipos de certificado	Público, privado, importado	Let’s Encrypt, Custom, Azion SAN
Validação	DNS, email	DNS-01, HTTP-01
Renovação	Automática	Automática (Let’s Encrypt)
Escopo	Regional (us-east-1 para CloudFront)	Rede global
mTLS	Suportado (Private CA)	Suportado (Trusted CA)
Custo	Gratuito para recursos AWS	Gratuito (Let’s Encrypt)

Provisionamento Automático de Certificado

A Azion provisiona automaticamente certificados Let’s Encrypt para domínios customizados:

Acesse o Azion Console.
Crie ou edite um Workload.
Adicione seu domínio customizado.
A Azion provisiona automaticamente um certificado Let’s Encrypt.
Verifique a propriedade do domínio (se necessário).
Aguarde ativação do certificado (tipicamente 5-15 minutos).

# Crie um workload com configuração TLS

# Primeiro, crie um certificado via Certificate Manager, depois referencie-o por 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

}

O campo tls.certificate referencia um ID de certificado existente do Certificate Manager. Use o Console para provisionar certificados Let’s Encrypt automaticamente, ou envie certificados customizados via API do Certificate Manager.

Upload de Certificado Customizado

Para organizações com certificados existentes do ACM ou CAs externas:

Exporte seu certificado do ACM (se aplicável).
Vá para Products menu > Certificate Manager.
Clique em + Certificate.
Selecione Custom Certificate.
Faça upload do seu certificado (formato PEM).
Faça upload da sua chave privada.
Faça upload da cadeia CA intermediária (se aplicável).
Associe o certificado ao seu workload.

# Upload de certificado customizado

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-----\n...\n-----END CERTIFICATE-----",

"private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----"

}

O endpoint de certificados é /v4/workspace/tls/certificates. O certificado e a chave privada devem estar em formato PEM. Certificados CA intermediários podem ser anexados ao campo de certificado se necessário.

Configuração de mTLS

Para autenticação mutual TLS:

Navegue para Certificate Manager.
Faça upload do seu certificado CA como Trusted CA.
Configure seu workload para requerer certificados de cliente.
Veja o guia de configuração mTLS para passos detalhados.

Certificados ACM Private CA podem ser exportados e enviados para a Azion como certificados Trusted CA para configuração de mTLS.

Documentação de referência

4. Migrando WAF para Web Application Firewall

Web Application Firewall protege aplicações contra tráfego malicioso, injeção SQL, cross-site scripting (XSS) e outros ataques de camada de aplicação. Migrar regras AWS WAF requer mapeamento cuidadoso da lógica das regras e compreensão das diferenças na construção de regras.

Diferenças Principais

Aspecto	AWS WAF	Azion WAF
Linguagem de regras	Regras baseadas em JSON	Critérios do Rules Engine
Regras gerenciadas	AWS Managed Rules, regras de Marketplace	Rulesets gerenciados pela Azion
Regras customizadas	Web ACL com regras	Rules Engine para Firewall
Cobertura OWASP	Core rule set via regras gerenciadas	Cobertura OWASP Top 10
Escopo	Regional ou CloudFront	Rede global
Opções de modo	Count, Block	Learning, Blocking

Passos de Migração

Acesse o Azion Console.
Vá para Products menu > Firewall.
Selecione ou crie uma instância de Firewall.
Navegue para a aba WAF.
Habilite os rulesets gerenciados desejados (SQL Injection, XSS etc.).
Configure o nível de sensibilidade por ruleset.
Crie regras customizadas na aba Rules Engine.
Associe o Firewall à sua aplicação.

# Crie uma instância WAF

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

]

}

Instâncias WAF são criadas pelo endpoint /v4/workspace/wafs. A configuração engine_settings define rulesets de detecção de ameaças e limites de sensibilidade. Para regras WAF customizadas, use o Firewall Rules Engine.

Exemplo de Migração de Regra

Converta uma regra AWS WAF para Azion Rules Engine:

Regra JSON AWS WAF:

{

"Name": "BlockAdminAccess",

"Priority": 1,

"Statement": {

"AndStatement": {

"Statements": [

{

"ByteMatchStatement": {

"SearchString": "/admin",

"FieldToMatch": { "UriPath": {} },

"PositionalConstraint": "CONTAINS"

}

},

{

"NotStatement": {

"Statement": {

"IPSetReferenceStatement": { "IPSet": "allowed-ips" }

}

]

}

},

"Action": { "Block": {} }

}

Critérios Azion:

Variable: ${uri}

Operator: matches

Argument: /admin

AND

Variable: ${remote_addr}

Operator: does not match

Argument: 10.0.0.0/8

O Azion WAF opera em modo Learning por padrão, analisando padrões de tráfego antes do bloqueio ativo. Use esse modo para validar o comportamento das regras antes de mudar para modo Blocking.

Mapeamento de AWS Managed Rules para Rulesets Azion

Grupo de Regras Gerenciadas AWS	Equivalente Azion
AWSManagedRulesCommonRuleSet	General Attack Detection
AWSManagedRulesSQLiRuleSet	SQL Injection ruleset
AWSManagedRulesXSSRuleSet	XSS ruleset
AWSManagedRulesLinuxRuleSet	OS Command Injection
AWSManagedRulesPHPAppRuleSet	Incluído em General Detection

Documentação de referência

5. Migrando DDoS Protection

DDoS Protection protege contra ataques volumétricos, ataques de protocolo e ataques de camada de aplicação. A Azion fornece mitigação DDoS automática sem configuração necessária para a maioria dos tipos de ataque.

Diferenças Principais

Aspecto	AWS Shield	Azion DDoS Protection
Proteção padrão	Automática, sem custo	Automática, sem custo
Proteção avançada	AWS Shield Advanced (custo adicional)	Regras gerenciadas + Rules Engine
Cobertura de camadas	L3, L4, L7	L3, L4, L7
Equipe de resposta DDoS	Somente Shield Advanced	Suporte Enterprise
Proteção de custo	Shield Advanced inclui proteção de custo	Proteção padrão

Proteção Automática

O Azion DDoS Protection é ativado automaticamente para todas as aplicações. Nenhuma configuração manual é necessária para proteção padrão contra:

Ataques volumétricos (UDP floods, ICMP floods)
Ataques de protocolo (SYN floods, fragmentação de pacotes)
Ataques de camada de aplicação (HTTP floods, slowloris)

Configuração Avançada

Para aplicações que exigem políticas DDoS específicas:

Acesse o Azion Console.
Vá para Products menu > Firewall.
Selecione sua instância de Firewall.
Navegue para a aba DDoS Protection.
Configure limites.
Habilite/desabilite regras específicas de mitigação.
Configure notificações de alerta.

# DDoS protection é configurado como módulo dentro de Firewall

# Atualize o Firewall com configurações do módulo DDoS

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"

}

DDoS protection é um módulo configurado dentro do recurso Firewall, não um endpoint separado. Configure-o por meio do campo modules.ddos_protection ao criar ou atualizar uma instância de Firewall.

Network Shield

Para proteção de camada de rede, use o Azion Network Shield:

Fornece proteção DDoS L3/L4
Trabalha com Edge DNS para filtragem de tráfego
Integra-se com Firewall para segurança unificada

Documentação de referência

6. Migrando Bot Management

Bot management protege aplicações contra ameaças automatizadas enquanto permite bots legítimos. O Azion Bot Manager fornece detecção, challenge e recursos de mitigação.

Diferenças Principais

Aspecto	AWS Bot Control	Azion Bot Manager
Detecção	Machine learning, heurísticas, fingerprinting	Machine learning, análise comportamental, fingerprinting, Reputation Intelligence
Challenge	CAPTCHA, silent challenge	Injeção JavaScript (fingerprinting), ALTCHA (via redirect)
Ações	Allow, Count, Block, CAPTCHA	Allow, Deny, Drop, Redirect, Custom HTML, Random Delay, Hold Connection
Versão Lite	Não disponível	Bot Manager Lite (Marketplace)

Bot Manager Lite (Marketplace)

Para proteção básica contra bots, instale o Bot Manager Lite pelo Azion Marketplace:

Acesse o Azion Console.
Vá para Marketplace.
Pesquise por Bot Manager Lite.
Clique em Install.
Configure a sensibilidade de detecção.
Configure ações de resposta (challenge, block).
Associe à sua instância de Firewall.

Regras Customizadas de Bot

Crie regras customizadas para tratar bots específicos:

Criteria: ${user_agent} contains "BadBot"

Behavior: Deny (403)

Criteria: ${user_agent} contains "Googlebot"

Behavior: Allow

Verificação

# Teste detecção de bot

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

# Esperado: 403 Forbidden ou página de challenge

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

# Esperado: resposta normal

Documentação de referência

7. Migrando Rate Limiting

Rate limiting protege aplicações contra abuso limitando taxas de requisições por cliente. A Azion fornece rate limiting por meio de regras de Firewall e Functions.

Diferenças Principais

Aspecto	AWS WAF Rate Limiting	Azion Rate Limiting
Configuração	Regras rate-based em Web ACL	Regras de Firewall + Functions
Granularidade	Caminho, método, IP, cabeçalho	Caminho, método, IP, customizado
Ações	Block, Count	Block, Log
Janela	1 minuto a 1 hora	Customizável
Escopo	Regional ou CloudFront	Rede global

Rate Limiting Baseado em Firewall

Configure rate limiting no Firewall Rules Engine:

Acesse o Azion Console.
Vá para Firewall > Rules Engine.
Crie uma nova regra.
Defina critérios (caminho, método etc.).
Adicione o comportamento Rate Limit.
Configure requisições por segundo/minuto.
Defina a ação (Block, Log).

# Crie regra de 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"}}

]

}

Regras de Firewall são criadas em /v4/workspace/firewalls/{firewall_id}/request_rules. O caminho segue o padrão de recursos de workspace.

Documentação de referência

8. Migrando Serviços de Segurança

A AWS fornece múltiplos serviços de segurança para detecção de ameaças e gerenciamento de vulnerabilidades. A Azion oferece proteção comparável por meio de Firewall e Network Lists.

Diferenças Principais

Aspecto	Serviços de Segurança AWS	Equivalente Azion
Detecção de ameaças	GuardDuty	Firewall + Network Lists
Varredura de vulnerabilidades	Inspector	Varredura externa + Firewall
Security Hub	Findings centralizados	Real-Time Events + logs de Firewall
Threat intelligence	Feeds de ameaça do GuardDuty	Network Lists (Tor, IPs maliciosos conhecidos)

Network Lists para Threat Intelligence

A Azion fornece Network Lists que incluem dados de threat intelligence:

Acesse o Azion Console.
Vá para Products menu > Network Lists.
Veja listas mantidas pela Azion disponíveis:
- Tor Nodes: nós de saída Tor conhecidos
- Malicious IPs: endereços IP maliciosos conhecidos
- Geo-blocking: listas baseadas em país
Crie listas customizadas para suas necessidades específicas.
Referencie listas em regras de Firewall.

# Crie uma network list customizada

curl -X POST 'https://api.azionapi.net/v4/workspace/network_lists' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "Blocked IPs",

"list_type": "ip_cidr",

"items": ["192.168.1.0/24", "10.0.0.1"]

}

# Use network list em regra de firewall

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": "Block Malicious IPs",

"criteria": [[{"variable": "${remote_addr}", "operator": "is_in_network_list", "argument": "network_list_id"}]],

"behaviors": [{"type": "deny", "attributes": {"status_code": 403}}]

}

Network Lists são criadas via /v4/workspace/network_lists. Use o ID da lista em regras de Firewall com o operador is_in_network_list para bloquear tráfego de fontes maliciosas conhecidas.

Considerações de Migração

Ao migrar de serviços de segurança AWS:

Findings do GuardDuty: exporte findings e crie regras Firewall correspondentes para ameaças baseadas em IP.
Vulnerabilidades do Inspector: corrija vulnerabilidades da aplicação antes da migração; o Azion WAF fornece proteção de runtime.
Logs CloudTrail: configure Real-Time Events para visibilidade comparável.
Security Hub: use Azion Real-Time Events e integração externa com SIEM.

Documentação de referência

Store

A categoria Store cobre serviços de dados. Migre objetos, dados key-value e bancos relacionais com atenção a consistência, padrões de acesso e compatibilidade da aplicação.

1. Migrando S3 para Object Storage

Object storage alimenta arquivos importantes para usuários e operações de negócio: imagens, documentos, assets estáticos, arquivos de mídia, uploads e conteúdo gerado. O Azion Object Storage fornece armazenamento compatível com S3 com custo zero de transferência de dados para fora.

Diferenças Principais

Aspecto	Amazon S3	Azion Object Storage
Endpoint	`https://s3.amazonaws.com/bucket`	`https://s3.us-east-005.azionstorage.net`
Endpoint S3	`s3.amazonaws.com`	`s3.us-east-005.azionstorage.net`
Região	Múltiplas regiões	`us-east-005`
Transferência para fora	Cobrada por GB	Custo zero
Classe de storage	Standard, Intelligent-Tiering, Glacier	Standard
Limites de bucket	100 por conta (padrão)	100 por conta (padrão)

Atualize a Configuração

Atualize a configuração do seu cliente S3 para usar Azion Object Storage:

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

// Antes: AWS S3

const s3Client = new S3Client({

region: 'us-east-1',

credentials: {

accessKeyId: process.env.AWS_ACCESS_KEY_ID,

secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY

}

});

// Depois: Azion Object Storage

const s3Client = 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')

}

});

Crie Credenciais S3

Acesse o Azion Console.
Vá para Object Storage.
Navegue para a aba S3 Credentials.
Clique em + Credential.
Selecione o escopo de bucket ou conta.
Configure capacidades (read, write, delete, list).
Salve a access key e a secret key com segurança.

# Crie credenciais S3

curl -X POST 'https://api.azionapi.net/v4/workspace/storage/s3_credentials' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"bucket": "my-bucket",

"capabilities": ["readFiles", "writeFiles", "deleteFiles", "listFiles"]

}

Credenciais S3 são criadas via endpoint /v4/workspace/storage/s3_credentials. O campo capabilities define quais operações a credencial pode executar. Salve a secret_key retornada imediatamente, pois ela não poderá ser recuperada depois.

Migre Dados com s3cmd

s3cmd é uma ferramenta de linha de comando para gerenciar serviços de storage compatíveis com S3. É uma opção eficaz para migrar dados do Amazon S3 para Azion Object Storage.

Instale s3cmd e execute s3cmd --configure para configurar suas credenciais Azion:

Access Key / Secret Key: insira as chaves geradas para Azion Object Storage.
Default Region: us-east-005 (s3cmd também aceita us-east para configuração interativa).
S3 Endpoint: s3.us-east-005.azionstorage.net.
DNS template: %(bucket).s3.us-east-005.azionstorage.net.
Use HTTPS protocol: true.

Use os comandos a seguir para migrar seus dados:

Comando	Descrição
`s3cmd ls`	Lista todos os buckets.
`s3cmd put file.png s3://my-bucket/`	Faz upload de um objeto.
`s3cmd get s3://my-bucket/file.png`	Faz download de um objeto.
`s3cmd sync s3://aws-bucket/ s3://azion-bucket/`	Sincroniza entre buckets.

Migre Dados com AWS CLI

Configure AWS CLI com credenciais Azion:

# Configure perfil AWS CLI para Azion

aws configure --profile azion

# Access Key: [your Azion access key]

# Secret Key: [your Azion secret key]

# Region: us-east-005

# Liste buckets

aws s3 ls --profile azion --endpoint-url https://s3.us-east-005.azionstorage.net

# Sincronize de AWS S3 para Azion

aws s3 sync s3://source-bucket/ s3://dest-bucket/ --profile azion --endpoint-url https://s3.us-east-005.azionstorage.net

Migre Dados com rclone

rclone suporta sincronização entre diferentes provedores de storage:

# Configure rclone para AWS S3 (origem)

rclone config

# Name: aws-s3

# Storage: s3

# Provider: AWS

# env_auth: true

# Configure rclone para Azion (destino)

rclone config

# Name: azion

# Storage: s3

# Provider: Other

# endpoint: https://s3.us-east-005.azionstorage.net

# acl: private

# Sincronize de AWS para Azion

rclone sync aws-s3:source-bucket azion:dest-bucket --progress

Migre dados usando ferramentas familiares como s3cmd, rclone ou AWS CLI. Antes da migração, mapeie buckets, prefixos de objetos, assets públicos/privados, padrões de acesso e lógica de signed URL.

Use Bucket como Origem

Configure Object Storage como origem para sua Application:

Acesse o Azion Console.
Vá para Connectors.
Crie um novo Connector com tipo Object Storage.
Selecione seu bucket.
Configure o prefixo (opcional).
Associe o Connector à sua Application.

# Crie um Connector usando Object Storage como origem

curl -X POST 'https://api.azionapi.net/v4/workspace/connectors' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "My Object Storage Origin",

"type": "object_storage",

"attributes": {

"bucket": "my-bucket",

"prefix": "assets/"

}

Connectors são criados via /v4/workspace/connectors. Use type: "object_storage" e especifique o nome do bucket. O campo opcional prefix limita objetos servidos a um caminho específico dentro do bucket.

Documentação de referência

2. Migrando DynamoDB para KV Store / SQL Database

DynamoDB é um banco de dados serverless key-value e de documentos. O destino de migração depende do seu caso de uso: operações key-value mapeiam para KV Store, enquanto consultas complexas mapeiam para SQL Database.

Diferenças Principais

Aspecto	Amazon DynamoDB	Azion KV Store	Azion SQL Database
Modelo de dados	Key-value, documento	Key-value	Relacional (SQLite)
Capacidade de consulta	Key lookups, queries, scans	Key lookups, operações hash	SQL completo
Replicação global	Global Tables (multi-Region)	Global por padrão	Arquitetura Main/Replicas
Consistência	Eventual, forte	Eventual	Forte (ACID)
Indexação	GSI, LSI	Não suportado	Indexação SQL completa
Modo de capacidade	On-demand, provisionado	Serverless	Serverless

Guia de Decisão de Migração

Recurso DynamoDB	Serviço Azion Recomendado
Consultas por chave primária	KV Store
Operações key-value simples	KV Store
Storage de sessão	KV Store
Feature flags, configuração	KV Store
Consultas complexas com filtros	SQL Database
Consultas por índice secundário	SQL Database
Agregações, joins	SQL Database
Modelo de dados relacional	SQL Database

Migre para KV Store

Para workloads key-value, use KV Store com API similar a Redis:

import { createClient } from 'azion/kv';

// Crie cliente KV

const client = await createClient({

namespace: 'my-namespace'

})

.on('error', (err) => console.error('KV Error:', err))

.connect();

// Antes: DynamoDB GetItem

// const result = await dynamodb.getItem({

// TableName: 'Users',

// Key: { userId: { S: '123' } }

// }).promise();

// Depois: KV Store get

const userData = await client.get('user:123');

// Antes: DynamoDB PutItem

// await dynamodb.putItem({

// TableName: 'Users',

// Item: { userId: { S: '123' }, name: { S: 'John' } }

// }).promise();

// Depois: KV Store set

await client.set('user:123', JSON.stringify({ name: 'John' }), {

expiration: { type: 'EX', value: 3600 } // TTL de 1 hora

});

Crie um KV Store

Acesse o Azion Console.
Vá para KV Store.
Clique em + Store.
Insira um nome para seu store.
Configure as definições.
Clique em Save.

# Crie um KV Store

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

"name": "my-kv-store",

"description": "Migrated from DynamoDB"

}

Namespaces de KV Store são criados via /v4/workspace/kv/namespaces. Use o nome do namespace em suas Functions para interagir com o store.

Migre para SQL Database

Para workloads de consulta complexa, migre para SQL Database:

import { Database } from 'azion:sql';

// Abra conexão com o banco de dados

const db = await Database.open('my-database');

// Antes: consulta DynamoDB com filtro

// const result = await dynamodb.query({

// TableName: 'Orders',

// IndexName: 'CustomerIdIndex',

// KeyConditionExpression: 'customerId = :cid',

// FilterExpression: 'orderDate > :date'

// }).promise();

// Depois: consulta SQL Database

const orders = await db.query(

'SELECT * FROM orders WHERE customer_id = ? AND order_date > ?',

['customer-123', '2024-01-01']

);

// Itere resultados

let row = await orders.next();

while (row) {

console.log(row.getString(0)); // acessa coluna por índice

row = await orders.next();

}

Crie um SQL Database

Acesse o Azion Console.
Vá para SQL Database.
Clique em + Database.
Insira um nome para seu banco de dados.
Crie tabelas usando SQL Shell ou API.
Importe seus dados.

# Crie um SQL Database

curl -X POST 'https://api.azionapi.net/v4/workspace/sql/databases' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "my-database",

"description": "Migrated from DynamoDB"

}

Instâncias de SQL Database são criadas via /v4/workspace/sql/databases. Use SQL Shell ou a API para criar tabelas e importar dados.

Exporte Dados do DynamoDB

Exporte dados do DynamoDB e transforme para importação:

# Exporte tabela DynamoDB para S3

aws dynamodb export-table-to-point-in-time --table-name Users --s3-bucket my-export-bucket --export-format DYNAMODB_JSON

# Converta e importe para Azion

# Para KV Store: transforme em pares key-value

# Para SQL Database: transforme em instruções SQL INSERT

Migração de Global Tables

DynamoDB Global Tables fornecem replicação multi-Region. KV Store é global por padrão:

DynamoDB Global Tables	Azion KV Store
Replicação multi-Region	Global por padrão
Resolução de conflito: last writer wins	Sincronização automática
Consistência eventual	Acesso global de baixa latência
Custo adicional por escrita replicada	Sem custo adicional de replicação

Documentação de referência

3. Migrando RDS/Aurora para SQL Database

A migração de banco relacional move seus dados transacionais e workloads SQL para Azion SQL Database. O Azion SQL Database é compatível com SQLite e fornece conformidade ACID com arquitetura Main/Replicas distribuída.

Diferenças Principais

Aspecto	Amazon RDS/Aurora	Azion SQL Database
Engine	MySQL, PostgreSQL, MariaDB, Oracle, SQL Server	SQLite
Compatibilidade	Específica por engine	API compatível com PostgreSQL
Arquitetura	Primary/Replicas	Main/Replicas (distribuída)
Conexão	String de conexão, connection pooling	Runtime API (sem necessidade de connection pooling)
Transações	ACID	ACID
Scaling	Scaling vertical, read replicas	Arquitetura distribuída
Região	Single ou multi-Region	Rede global

Migração de PostgreSQL para SQL Database

Para workloads PostgreSQL, o Azion SQL Database fornece uma interface SQL familiar:

import { Database } from 'azion:sql';

// Abra conexão com o banco de dados

const db = await Database.open('my-database');

// Antes: consulta PostgreSQL

// const result = await pgClient.query(

// 'SELECT id, name, email FROM users WHERE status = $1',

// ['active']

// );

// Depois: consulta SQL Database

const result = await db.query(

'SELECT id, name, email FROM users WHERE status = ?',

['active']

);

// Processe resultados

let row = await result.next();

while (row) {

const id = row.getString(0);

const name = row.getString(1);

const email = row.getString(2);

console.log(`User: ${name} <${email}>`);

row = await result.next();

}

Crie um SQL Database

Acesse o Azion Console.
Vá para SQL Database.
Clique em + Database.
Insira um nome para seu banco de dados.
Clique em Save.
Use SQL Shell para criar tabelas e importar dados.

# Crie um SQL Database

curl -X POST 'https://api.azionapi.net/v4/workspace/sql/databases' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "production-db",

"description": "Migrated from Aurora PostgreSQL"

}

# Execute SQL para criar tabelas

curl -X POST 'https://api.azionapi.net/v4/workspace/sql/databases/{database_id}/query' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"query": "CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT, email TEXT, created_at TIMESTAMP)"

}

Instâncias de SQL Database são criadas via /v4/workspace/sql/databases. Use o endpoint de query para executar instruções DDL de criação de tabelas.

Exporte e Importe Dados

Exporte dados de RDS/Aurora e importe para SQL Database:

# Exporte de RDS PostgreSQL

pg_dump -h my-db.xxxx.region.rds.amazonaws.com -U admin -d mydb --data-only --inserts > export.sql

# Para Aurora, você também pode usar Snapshot Export para S3

aws rds start-export-task --export-task-identifier my-export --source-arn arn:aws:rds:region:account:cluster:my-aurora-cluster --s3-bucket-name my-export-bucket --export-only data

# Importe para Azion SQL Database via SQL Shell

# Conecte ao SQL Shell e execute o arquivo export.sql

# Ou use a API de importação

Mapeamento de Tipos de Dados

Tipo PostgreSQL	Equivalente SQLite
INTEGER, BIGINT, SMALLINT	INTEGER
SERIAL, BIGSERIAL	INTEGER (auto-increment)
VARCHAR(n), CHAR(n), TEXT	TEXT
BOOLEAN	INTEGER (0 ou 1)
REAL, DOUBLE PRECISION	REAL
DECIMAL, NUMERIC	REAL
DATE, TIME, TIMESTAMP	TEXT (formato ISO 8601)
JSON, JSONB	TEXT (use funções JSON)
UUID	TEXT
BYTEA	BLOB

Documentação de referência

4. Migrando ElastiCache para Cache / KV Store

ElastiCache fornece cache em memória com Redis ou Memcached. A Azion fornece cache por meio de Cache e storage key-value por meio de KV Store.

Diferenças Principais

Aspecto	Amazon ElastiCache	Azion Cache	Azion KV Store
Tipo	Cache em memória	Cache	Key-value distribuído
Engines	Redis, Memcached	Cache HTTP	API similar a Redis
Persistência	Opcional (Redis AOF/RDB)	TTL baseado em tempo	Persistente
Estruturas de dados	Strings, hashes, lists, sets, sorted sets	Respostas HTTP	Strings, hashes
Replicação	Cluster mode, replication groups	Rede global	Global por padrão
Acesso	Conexão TCP	Requisição/resposta HTTP	Runtime API

Guia de Decisão de Migração

Caso de Uso ElastiCache	Serviço Azion Recomendado
Cache de resposta HTTP	Cache
Storage de sessão	KV Store
Contadores de rate limiting	KV Store
Feature flags	KV Store
Cache de consulta de banco	Cache + Functions
Mensageria Pub/Sub	Functions + KV Store
Leaderboards, sorted sets	SQL Database
Estruturas de dados complexas	SQL Database

Migre Cache Redis para KV Store

Para operações key-value similares a Redis, use KV Store:

import { createClient } from 'azion/kv';

// Crie cliente KV com API similar a Redis

const client = await createClient()

.on('error', (err) => console.error('KV Error:', err))

.connect();

// Antes: Redis SET com expiração

// await redis.set('session:abc123', JSON.stringify(sessionData), 'EX', 3600);

// Depois: KV Store set com expiração

await client.set('session:abc123', JSON.stringify(sessionData), {

expiration: { type: 'EX', value: 3600 }

});

// Antes: Redis GET

// const data = await redis.get('session:abc123');

// Depois: KV Store get

const data = await client.get('session:abc123');

// Antes: Redis DEL

// await redis.del('session:abc123');

// Depois: KV Store delete

await client.delete('session:abc123');

Documentação de referência

Observe

A categoria Observe cobre analytics, métricas, logs e tracing distribuído. Migrar observabilidade garante que você mantenha visibilidade de produção, capacidade de troubleshooting e relatórios de conformidade após o cutover.

1. Migrando CloudWatch Metrics para Real-Time Metrics

CloudWatch Metrics fornece monitoramento para recursos AWS e aplicações. Azion Real-Time Metrics entrega recursos comparáveis por meio de uma GraphQL API e dashboards integrados com agregação de dados quase em tempo real.

Diferenças Principais

Aspecto	Amazon CloudWatch Metrics	Azion Real-Time Metrics
Atualidade dos dados	Quase em tempo real (1-5 minutos)	Quase em tempo real (até 10 minutos)
Retenção	15 meses (padrão)	2 anos
Método de consulta	GetMetricStatistics API, CloudWatch Insights	GraphQL API, dashboards do Console
Métricas	Métricas customizadas, baseadas em namespace	Requisições, bandwidth, latência, cache, WAF, DNS
Granularidade	1 segundo a 1 dia	Intervalos adaptativos (minuto/hora/dia)
Dashboards	CloudWatch Dashboards	Real-Time Metrics + plugin Grafana
Alarmes	CloudWatch Alarms	Monitoramento externo via Data Stream

Métricas Disponíveis

Azion Real-Time Metrics fornece monitoramento abrangente entre categorias de produtos:

Métricas Build:

Applications: total de requisições, dados transferidos, status codes, economia de bandwidth, tempo médio de requisição
Functions: total de invocações, tempo de execução
Image Processor: total de requisições, requisições por segundo
Tiered Cache: caching offload, L2 offload

Métricas Secure:

WAF: ameaças vs requisições, SQL injection, XSS, RFI, ameaças por país
Edge DNS: total de consultas
Bot Manager: bot hits, bad bot hits, good bot hits, classificação de tráfego

Métricas Observe:

Data Stream: total de dados transmitidos, total de requisições

Passos de Configuração

Acesse o Azion Console.
Vá para Products menu > Real-Time Metrics.
Selecione uma aba de categoria (Build, Secure, Observe).
Selecione uma aba de produto para ver métricas específicas.
Configure Time range (Last Hour, 24 Hours, 7 Days, 30 Days, 6 Months).
Use Filters para refinar a análise por host, status code ou outras dimensões.
Clique no menu de contexto de qualquer gráfico para exportar CSV ou copiar a consulta GraphQL.

query HttpMetrics {

http(

filter: { tsRange: { begin: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" } }

aggregate: { sum: requests }

groupBy: [ts]

orderBy: [ts_DESC]

first: 100

) {

ts

sum

}

Real-Time Metrics usa a GraphQL API em https://console.azion.com/metrics/graphql. Consultas suportam filtros por intervalo de tempo, funções de agregação (sum, avg), agrupamento e ordenação. A API retorna até 10.000 linhas por consulta.

Exemplos de Consulta GraphQL

Consultar requisições por status code:

query RequestsByStatus {

http(

filter: {

tsRange: { begin: "2024-01-01T00:00:00", end: "2024-01-01T23:59:59" }

}

aggregate: { sum: requests }

groupBy: [status]

orderBy: [sum_DESC]

first: 20

) {

status

sum

}

Consultar ameaças WAF por país:

query WafThreatsByCountry {

waf(

filter: {

tsRange: { begin: "2024-01-01T00:00:00", end: "2024-01-02T00:00:00" }

}

aggregate: { sum: threats }

groupBy: [country]

orderBy: [sum_DESC]

first: 10

) {

country

sum

}

Consultar dados transferidos para host específico:

query DataTransferredByHost {

http(

filter: {

tsRange: { begin: "2024-01-01T00:00:00", end: "2024-01-07T00:00:00" }

host: { eq: "www.example.com" }

}

aggregate: { sum: dataTransferred }

groupBy: [ts]

first: 500

) {

ts

sum

}

Migração de CloudWatch Alarm

CloudWatch Alarms notificam sobre limites de métricas. A Azion não fornece alertas integrados, mas você pode alcançar funcionalidade semelhante:

CloudWatch Alarm	Equivalente Azion
Alarme de limite de métrica	Configure alertas em monitoramento externo (Datadog, Splunk) via Data Stream
Alarmes compostos	Functions com lógica customizada + Data Stream
Detecção de anomalia	Plataformas externas de SIEM/analytics

Integração com Grafana

Use o plugin Grafana da Azion para dashboards customizados:

# Instale o plugin Grafana da Azion

grafana-cli plugins install aziontech-azion-plugin

Consulte a documentação do plugin Grafana para configuração de dashboards.

Documentação de referência

2. Migrando CloudWatch Logs para Real-Time Events

CloudWatch Logs coleta e armazena dados de log de recursos AWS. Azion Real-Time Events fornece acesso imediato a logs pelo Console ou GraphQL API para troubleshooting e investigação em tempo real.

Diferenças Principais

Aspecto	Amazon CloudWatch Logs	Azion Real-Time Events
Método de acesso	GetLogEvents API, CloudWatch Logs Insights	Consulta em tempo real via Console ou GraphQL API
Latência	Segundos a minutos	Segundos
Retenção	1 dia a 10 anos (configurável)	7 dias (168 horas), 2 anos para Activity History
Linguagem de consulta	CloudWatch Logs Insights (similar a SQL)	Consultas GraphQL
Log groups	Log groups com log streams	Fontes de dados por tipo de produto
Metric filters	Cria métricas a partir de logs	Use Data Stream para processamento customizado

Mapeamento de Fontes de Dados

CloudWatch Log Group	Fonte de Dados Azion Real-Time Events
/aws/cloudfront/…	HTTP Requests
/aws/lambda/…	Functions
/aws/waf/…	HTTP Requests (campos WAF)
/aws/route53/…	Edge DNS
CloudTrail	Activity History

Passos de Configuração

Acesse o Azion Console.
Vá para Products menu > Real-Time Events.
Selecione a aba Data Source (HTTP Requests, Functions, Edge DNS etc.).
Configure Time filter (Last 15 minutes até Last 7 days, ou Custom time range).
Adicione filtros para restringir resultados (host, status, remote address etc.).
Clique em Search para consultar logs.
Clique em qualquer linha para ver informações detalhadas de log em More details.

query HttpEvents {

http(

filter: {

tsRange: { begin: "2024-01-01T00:00:00", end: "2024-01-01T01:00:00" }

status: { eq: "500" }

}

orderBy: [ts_DESC]

first: 100

) {

ts

remoteAddress

requestUri

status

upstreamResponseTime

host

requestMethod

}

A GraphQL API de Real-Time Events consulta dados das últimas 168 horas (7 dias). Para Activity History, consultas podem abranger até 2 anos. A API suporta filtros, ordenação e paginação baseada em cursor.

Migração de CloudWatch Logs Insights para GraphQL

Converta consultas CloudWatch Logs Insights para GraphQL de Real-Time Events:

Consulta CloudWatch Logs Insights:

fields @timestamp, @message

| filter @logGroup = "/aws/cloudfront/distribution"

| filter status >= 500

| sort @timestamp desc

| limit 100

Equivalente Azion GraphQL:

query ErrorRequests {

http(

filter: {

tsRange: { begin: "2024-01-01T00:00:00", end: "2024-01-01T23:59:59" }

status: { gte: "500" }

}

orderBy: [ts_DESC]

first: 100

) {

ts

status

requestUri

host

remoteAddress

upstreamStatus

upstreamResponseTime

}

Variáveis Disponíveis por Fonte de Dados

HTTP Requests:

Metadados da requisição: ts, remoteAddress, remotePort, host, requestUri, requestMethod, status
Performance: requestTime, upstreamResponseTime, upstreamHeaderTime
Bandwidth: bytesSent, requestLength, upstreamBytesReceived, upstreamBytesSent
Cache: upstreamCacheStatus
Segurança: wafBlock, wafMatch, wafScore, wafLearning
Geo: geoipCountryName, geoipRegionName, geoipAsn
TLS: sslCipher, sslProtocol

Functions:

functionId, functionsList, functionsTime, functionLanguage

Edge DNS:

level, qType, resolutionType, statusCode, zoneId

Métricas Baseadas em Logs

Para criar métricas a partir de logs (equivalente a CloudWatch metric filters), use Data Stream:

Acesse o Azion Console.
Vá para Products menu > Data Stream.
Clique em + Stream.
Selecione Applications como fonte de dados.
Use Custom Template para selecionar variáveis específicas.
Escolha um endpoint (Datadog, Splunk, Elasticsearch etc.).
Configure o destino para processamento de logs.
Ative o stream.

curl -X POST 'https://api.azion.com/v4/workspace/stream/streams' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "Log Metrics Stream",

"source": {

"type": "applications"

},

"template_id": 12345,

"endpoint": {

"type": "datadog",

"name": "my-datadog-endpoint",

"url": "https://http-intake.logs.datadoghq.com/v1/input",

"api_key": "YOUR_DATADOG_API_KEY"

},

"active": true

}

Documentação de referência

3. Migrando X-Ray para Data Stream

AWS X-Ray fornece tracing distribuído e tracing de requisições entre serviços. Azion Data Stream permite transmitir dados de observabilidade para destinos externos para análise de tracing distribuído.

Diferenças Principais

Aspecto	AWS X-Ray	Azion Data Stream
Coleta de traces	Automática com X-Ray SDK	Transmite logs para sistemas externos de tracing
Mapa de serviços	Visualização integrada de service map	Ferramentas externas (Datadog, Jaeger, Splunk)
Análise de trace	Console X-Ray	Plataformas externas de tracing
Annotations	Pares key-value customizados	Templates de log customizados
Sampling	Regras de sampling configuráveis	Percentual de sampling configurável
Destinos	Console X-Ray, CloudWatch	10+ destinos externos

Migração de Fluxo de Dados de Tracing

Conceito AWS X-Ray	Equivalente Azion
Segments	Entradas de log de requisição/resposta
Subsegments	Logs de execução de Functions
Service graph	Integrado em ferramentas externas de tracing (Datadog, Jaeger)
Propagação de Trace ID	Cabeçalhos customizados via Rules Engine ou Functions
Annotations	Variáveis de log no template de Data Stream

Passos de Configuração

Acesse o Azion Console.
Vá para Products menu > Data Stream.
Clique em + Stream.
Selecione Applications como fonte de dados para tracing de requisições.
Selecione Functions como fonte de dados adicional para traces de execução de funções.
Crie um Custom Template com variáveis relacionadas a trace:
- $request_id (identificador único de trace)
- $ts (timestamp)
- $upstream_addr (endereço da origem)
- $upstream_response_time (tempo de resposta)
- $request_uri, $status, $host
Escolha um endpoint compatível com tracing (Datadog, Splunk, Elasticsearch, Kafka).
Configure credenciais do destino.
Ative o stream.

curl -X POST 'https://api.azion.com/v4/workspace/stream/streams' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "Distributed Tracing Stream",

"source": {

"type": "applications"

},

"template": {

"name": "Custom Trace Template",

"variables": [

"$request_id",

"$ts",

"$host",

"$request_uri",

"$request_method",

"$status",

"$upstream_addr",

"$upstream_response_time",

"$upstream_status",

"$remote_addr"

]

},

"endpoint": {

"type": "datadog",

"name": "tracing-endpoint",

"url": "https://http-intake.logs.datadoghq.com/v1/input",

"api_key": "YOUR_DATADOG_API_KEY"

},

"active": true

}

Data Stream usa o endpoint /v4/workspace/stream/streams. Configure templates customizados com variáveis relevantes para trace. O campo $request_id fornece um identificador único para correlacionar requisições entre serviços.

Propagação de Trace ID

Para habilitar tracing distribuído entre serviços, propague o contexto de trace via cabeçalhos HTTP:

Usando Rules Engine:

Criteria: All requests

Behavior: Add Request Header

Header Name: X-Trace-Id

Header Value: ${request_id}

Usando Functions:

export default {

async fetch(request) {

// Extraia ou gere trace ID

const traceId = request.headers.get('x-trace-id') ||

crypto.randomUUID();

// Adicione trace ID à requisição upstream

const upstreamRequest = new Request(request, {

headers: {

...Object.fromEntries(request.headers),

'X-Trace-Id': traceId

}

});

return fetch(upstreamRequest);

}

};

Endpoints Suportados para Tracing

Data Stream suporta múltiplos endpoints adequados para tracing distribuído:

Endpoint	Caso de Uso
Datadog	APM completo e tracing distribuído
Splunk	Log analytics e tracing
Elasticsearch	Busca e correlação de trace
Apache Kafka	Stream para Jaeger, Zipkin ou tracing customizado
Google BigQuery	Data warehouse para análise de trace
AWS Kinesis Data Firehose	Integração com AWS X-Ray ou outros serviços AWS
Standard HTTP/HTTPS POST	Sistemas customizados de tracing

Migração de Data Firehose

AWS Kinesis Data Firehose entrega dados de streaming para destinos. Azion Data Stream fornece recursos semelhantes:

AWS Kinesis Data Firehose	Azion Data Stream
Destino S3	Endpoint S3 (qualquer storage compatível com S3)
Destino Redshift	BigQuery ou endpoint HTTP customizado
Destino Elasticsearch	Endpoint Elasticsearch
Endpoint HTTP	Standard HTTP/HTTPS POST
Transformação de dados (Lambda)	Functions para pré-processamento

Configure Data Stream para S3:

curl -X POST 'https://api.azion.com/v4/workspace/stream/streams' --header 'Authorization: Token YOUR_TOKEN' --header 'Content-Type: application/json' --data {

"name": "S3 Archive Stream",

"source": {

"type": "applications"

},

"template_id": 12345,

"endpoint": {

"type": "s3",

"name": "my-s3-endpoint",

"host_url": "https://s3.amazonaws.com",

"bucket_name": "my-logs-bucket",

"region": "us-east-1",

"access_key": "YOUR_ACCESS_KEY",

"secret_key": "YOUR_SECRET_KEY",

"object_key_prefix": "azion-logs"

},

"active": true

}

CloudWatch RUM para Edge Pulse

CloudWatch RUM fornece monitoramento de usuário real. Azion Edge Pulse entrega recursos comparáveis:

Aspecto	CloudWatch RUM	Azion Edge Pulse
Coleta de dados	JavaScript SDK	JavaScript SDK
Métricas	Page load, Core Web Vitals, erros JavaScript	Métricas de usuário real, dados de performance
Session replay	Disponível	Disponível via integração
Eventos customizados	API de eventos customizados	Eventos customizados via SDK

Configure Edge Pulse para monitoramento de usuário real:

Acesse o Azion Console.
Vá para Products menu > Edge Pulse.
Crie uma nova instância Pulse.
Configure o snippet JavaScript para sua aplicação.
Adicione o snippet ao HTML da sua aplicação.
Configure definições de coleta de dados.
Veja métricas em Real-Time Metrics sob Edge Pulse.

Documentação de referência

Data Stream
Data Stream primeiros passos
Use Data Stream
Connectors: Amazon S3, Azion Object Storage, Datadog, Splunk, Elasticsearch, Kinesis, BigQuery
Edge Pulse

Solução de Problemas

Problema	Causa Provável	Solução
DNS não resolve	Atraso de propagação de nameserver	Aguarde até 48 horas após atualizar nameservers; verifique com `dig yourdomain.com NS`
Validação de certificado falha	Propriedade do domínio não verificada	Confirme se o registro DNS TXT ou challenge HTTP está acessível; verifique o status no Certificate Manager
Function retorna `process.env not defined`	Sintaxe de variável de ambiente Node.js usada	Use `Azion.env.get('VARIABLE_NAME')` em vez de `process.env.VARIABLE_NAME`
Cache não purga como esperado	Requisição de purge ainda em processamento	Aguarde 5-10 minutos; verifique purge com `curl -I` para checar cabeçalhos; use purge wildcard para mudanças amplas
Regras WAF bloqueiam tráfego legítimo	Sensibilidade alta demais ou falso positivo	Coloque o WAF em modo Learning primeiro; revise requisições bloqueadas em Real-Time Events; ajuste a sensibilidade
Timeouts de conexão com origem	Connector mal configurado ou origem indisponível	Verifique endereço e porta do Connector; confira health da origem; aumente timeout nas configurações do Connector
Falhas de handshake SSL	Certificado incompatível ou cadeia incompleta	Verifique se o certificado cobre o domínio; inclua CA intermediária na cadeia; confira a versão TLS mínima
Erros CORS em requisições de API	Cabeçalhos CORS ausentes na resposta	Adicione cabeçalhos CORS via Rules Engine: `Access-Control-Allow-Origin`, `Access-Control-Allow-Methods`
Erros de assinatura de função Lambda	Estrutura de evento CloudFront difere da Azion	Atualize a função para usar assinatura `fetch(request, env, ctx)`; acesse a requisição via objeto `request`
Consultas DynamoDB falham após migração	Sintaxe da API KV Store difere	Atualize o código para usar `KVStore` de `azion:kv`; confira convenções de nome de chave
Uploads S3 falham com 403	Credenciais ou endpoint incorretos	Verifique Access Key e Secret Key; confirme que o endpoint é `s3.us-east-005.azionstorage.net`
Métricas CloudWatch não aparecem	Data Stream não configurado	Configure Data Stream para exportar métricas; verifique credenciais e formato do destino

Principais Vantagens Após a Migração

Capacidade	Antes (AWS)	Depois (Azion)
Plataforma unificada	Múltiplos consoles para CloudFront, Lambda, S3, Route 53, WAF, CloudWatch	Console único para compute, storage, segurança e observabilidade
Cold starts	Possíveis em Lambda (especialmente com VPC)	Minimizados com V8 isolates distribuídos
Distribuição global	Regiões e edge locations (200+ PoPs)	Localizações da plataforma Azion no mundo todo com performance consistente
Modelo de preço	Cobrança por serviço, taxas de transferência de dados, contagem de requisições	Cobrança consolidada mais simples; custo zero de DTO para Object Storage
Observabilidade	CloudWatch com dashboards, logs e alarmes separados	Real-Time Metrics e Events com acesso instantâneo via Console ou GraphQL API
Integração de segurança	WAF, Shield, IAM como serviços separados	WAF, DDoS Protection e Bot Manager integrados a workloads

Próximos Passos

Após concluir sua migração:

Revise Real-Time Metrics para monitorar a performance da aplicação
Configure Real-Time Events para visibilidade de produção
Configure Web Application Firewall para segurança de produção
Revise os guias individuais de recursos para configuração avançada
Configure Data Stream para exportar logs para suas ferramentas existentes de SIEM ou analytics

Comece com um Projeto Pequeno

A melhor forma de começar não é com a aplicação mais complexa do seu portfólio. Comece com um projeto significativo o bastante para validar o caminho de migração, mas pequeno o suficiente para mover com rapidez e segurança.

Escolha uma aplicação ou workload que inclua partes representativas da sua arquitetura: uma distribuição CloudFront, algumas funções Lambda, um bucket S3, talvez uma tabela DynamoDB. Use esse projeto para validar o workflow, documentar o processo e identificar padrões internos que sua equipe pode reutilizar.

A partir daí, expanda gradualmente. Migre comportamentos de cache mais complexos. Mova funções adicionais. Traga workloads de storage e banco de dados. Adicione observabilidade. Revise regras de segurança. Então prepare cutovers de produção com mais confiança.

Próximos Passos Recomendados

Precisa de Ajuda?

Receba ajuda da equipe de Suporte da Azion, ou entre na nossa comunidade no Discord para ver como outras pessoas estão usando a Azion.