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:

1. 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.

2. 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.

3. 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.

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.

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

Conecte Seu Repositório

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

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

• Applications
• Applications primeiros passos
• Azion CLI visão geral
• Importe um projeto existente do GitHub

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

Comparação de Configuração de Build

Documentação de referência

• Azion CLI visão geral
• azion.config.js referência
• azion deploy comando

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

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

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

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');

Documentação de referência

• Variáveis de Ambiente
• Trabalhando com variáveis
• Azion referência de variáveis de ambiente de runtime

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

Passos de Configuração

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:

Documentação de referência

• Applications
• Applications configurações principais
• Rules Engine para Applications
• Connectors

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

Passos de Configuração

# 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

• Functions
• Functions Instances
• Rules Engine para Applications

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

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:

Documentação de referência

• Functions
• Functions Instances
• Runtime APIs
• JavaScript Runtime APIs 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

Passos de Configuração

# 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

Documentação de referência

• Load Balancer
• Connectors
• Application configurações principais

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

CloudFront Cache Policies para Azion Cache Settings

Passos de Configuração

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

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

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

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

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:

Passos de Configuração

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

Documentação de referência

• Image Processor
• Como processar imagens
• Object Storage

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

Passos de Configuração

// 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

• AI Inference
• AI Inference modelos
• AI Inference Starter Kit

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

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

• Functions
• Data Streaming

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

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

www CNAME xxxxxxxxxx.map.azionedge.net

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

Verifique Propagação

dig www.yourdomain.com CNAME +short

Documentação de referência

• Workloads
• Crie um domínio customizado Azion
• Edge DNS
• Certificate Manager

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

Passos de Migração

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

Mapeamento de Tipos de Registro

Migração de Política de Roteamento

Configuração de DNSSEC

Para habilitar DNSSEC:

1. Navegue para sua zona no Edge DNS.
2. Vá para a aba DNSSEC.
3. Habilite DNSSEC.
4. 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

• Edge DNS
• Compatibilidade DNSSEC
• Execute o comando dig
• Execute o comando traceroute

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

Provisionamento Automático de Certificado

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

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

Upload de Certificado Customizado

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

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

Configuração de mTLS

Para autenticação mutual TLS:

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

Documentação de referência

• Certificate Manager
• Firewall Certificate Manager
• Crie um certificado digital
• mTLS

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

Passos de Migraçã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" }
      ]
    }
  }
}'

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

Mapeamento de AWS Managed Rules para Rulesets Azion

Documentação de referência

• Web Application Firewall
• Rules Engine para Firewall
• Functions para Firewall

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

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:

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

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

• DDoS Protection
• DDoS Mitigation
• Network Shield

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

Bot Manager Lite (Marketplace)

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

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

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

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

Rate Limiting Baseado em Firewall

Configure rate limiting no Firewall Rules Engine:

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

Documentação de referência

• Rules Engine para Firewall
• Functions para Firewall
• Functions Instances para Firewall

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

Network Lists para Threat Intelligence

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

# 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}}]
}'

Considerações de Migração

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

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

Documentação de referência

• Network Lists
• Real-Time Events
• Data Streaming

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

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

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

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.

1. 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.

2. Use os comandos a seguir para migrar seus dados:

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

Use Bucket como Origem

Configure Object Storage como origem para 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/"
  }
}'

Documentação de referência

• Object Storage
• Como acessar Object Storage usando protocolo S3
• Crie e modifique um bucket
• Faça upload e download de objetos
• Use um bucket como origem
• Referência da biblioteca Storage

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