GRANDES DADOS

Apresentando o Amazon MWAA sem servidor | Weblog de Huge Knowledge da AWS

novembro 18, 2025
José Peixoto Vieira Filho


Hoje, a AWS anunciou Fluxos de trabalho gerenciados pela Amazon para Apache Airflow (MWAA) Sem servidor. Esta é uma nova opção de implantação para MWAA que elimina a sobrecarga operacional de gerenciamento Fluxo de ar Apache ambientes e, ao mesmo tempo, otimizar custos por meio de escalonamento sem servidor. Esta nova oferta aborda os principais desafios que os engenheiros de dados e as equipes de DevOps enfrentam ao orquestrar fluxos de trabalho: escalabilidade operacional, otimização de custos e gerenciamento de acesso.

Com MWAA sem servidor você pode se concentrar na lógica do fluxo de trabalho em vez de monitorar a capacidade provisionada. Agora você pode enviar seus fluxos de trabalho do Airflow para execução de acordo com uma programação ou sob demanda, pagando apenas pelo tempo de computação actual usado durante a execução de cada tarefa. O serviço gerencia automaticamente todo o dimensionamento da infraestrutura para que seus fluxos de trabalho sejam executados com eficiência, independentemente da carga.

Além das operações simplificadas, o MWAA Serverless apresenta um modelo de segurança atualizado para controle granular através Gerenciamento de identidade e acesso da AWS (EU SOU). Cada fluxo de trabalho agora pode ter suas próprias permissões de IAM, executadas em uma VPC de sua escolha, para que você possa implementar controles de segurança precisos sem criar ambientes Airflow separados. Essa abordagem reduz significativamente a sobrecarga de gerenciamento de segurança e, ao mesmo tempo, fortalece sua postura de segurança.

Nesta postagem, demonstramos como usar MWAA Serverless para construir e implantar soluções escalonáveis ​​de automação de fluxo de trabalho. Examinamos exemplos práticos de criação e implantação de fluxos de trabalho, configurando a observabilidade por meio de Amazon CloudWatche convertendo DAGs (gráficos acíclicos direcionados) existentes do Apache Airflow para o formato sem servidor. Também exploramos as práticas recomendadas para gerenciar fluxos de trabalho sem servidor e mostramos como implementar monitoramento e registro.

Como funciona o MWAA sem servidor?

O MWAA Serverless processa suas definições de fluxo de trabalho e as executa com eficiência em ambientes Airflow gerenciados por serviços, dimensionando automaticamente os recursos com base nas demandas do fluxo de trabalho. MWAA Serverless usa o Serviço de contêiner elástico da Amazon (Amazon ECS) para executar cada tarefa particular person em seu próprio contêiner ECS Fargate, em sua VPC ou em uma VPC gerenciada por serviço. Esses contêineres então se comunicam de volta ao cluster do Airflow atribuído usando a API de tarefas do Airflow 3.

Apresentando o Amazon MWAA sem servidor | Weblog de Huge Knowledge da AWS
Figura 1: Arquitetura Amazon MWAA

MWAA Serverless usa arquivos de configuração YAML declarativos baseados no common código aberto Fábrica DAG formato para aumentar a segurança através do isolamento de tarefas. Você tem duas opções para criar essas definições de fluxo de trabalho:

Essa abordagem declarativa oferece dois benefícios principais. Primeiro, como o MWAA Serverless lê as definições de fluxo de trabalho do YAML, ele pode determinar o agendamento de tarefas sem executar nenhum código de fluxo de trabalho. Em segundo lugar, isso permite que o MWAA Serverless conceda permissões de execução apenas quando as tarefas são executadas, em vez de exigir permissões amplas no nível do fluxo de trabalho. O resultado é um ambiente mais seguro, onde as permissões de tarefas têm escopo preciso e são limitadas no tempo.

Considerações de serviço para MWAA Serverless

O MWAA Serverless tem as seguintes limitações que você deve considerar ao decidir entre implantações MWAA sem servidor e provisionadas:

  • Suporte ao operador
    • MWAA Serverless oferece suporte apenas a operadores do Amazon Supplier Bundle.
    • Para executar códigos ou scripts personalizados, você precisará usar serviços da AWS, como:
  • Interface do usuário
    • MWAA Serverless opera sem usar a interface da internet do Airflow.
    • Para monitoramento e gerenciamento de fluxo de trabalho, oferecemos integração com Amazon CloudWatch e AWS CloudTrail.

Trabalhando com MWAA sem servidor

Conclua os seguintes pré-requisitos e etapas para usar o MWAA Serverless.

Pré-requisitos

Antes de começar, verifique se você atende aos seguintes requisitos:

  • Acesso e permissões
    • Um Conta AWS
    • Interface de linha de comando da AWS (AWS CLI) versão 2.31.38 ou posterior instalada e configurada
    • As permissões apropriadas para criar e modificar funções e políticas do IAM, incluindo as seguintes permissões obrigatórias do IAM:
      • airflow-serverless:CreateWorkflow
      • airflow-serverless:DeleteWorkflow
      • airflow-serverless:GetTaskInstance
      • airflow-serverless:GetWorkflowRun
      • airflow-serverless:ListTaskInstances
      • airflow-serverless:ListWorkflowRuns
      • airflow-serverless:ListWorkflows
      • airflow-serverless:StartWorkflowRun
      • airflow-serverless:UpdateWorkflow
      • iam:CreateRole
      • iam:DeleteRole
      • iam:DeleteRolePolicy
      • iam:GetRole
      • iam:PutRolePolicy
      • iam:UpdateAssumeRolePolicy
      • logs:CreateLogGroup
      • logs:CreateLogStream
      • logs:PutLogEvents
      • airflow:GetEnvironment
      • airflow:ListEnvironments
      • s3:DeleteObject
      • s3:GetObject
      • s3:ListBucket
      • s3:PutObject
      • s3:Sync
    • Acesso a um Nuvem Privada Digital Amazon (VPC) com conectividade à Web
  • Serviços AWS necessários – Além do MWAA Serverless, você precisará de acesso aos seguintes serviços AWS:
    • Amazon MWAA para acessar seus ambientes Airflow existentes
    • Amazon CloudWatch para visualizar logs
    • Amazon S3 para gerenciamento de arquivos DAG e YAML
    • AWS IAM para controlar permissões
  • Ambiente de desenvolvimento
  • Requisitos adicionais
    • Familiaridade básica com os conceitos do Apache Airflow
    • Compreensão da sintaxe YAML
    • Conhecimento de comandos AWS CLI

Observação: ao longo desta postagem, usamos valores de exemplo que você precisará substituir pelos seus próprios:

  • Substituir amzn-s3-demo-bucket com o nome do seu bucket S3
  • Substituir 111122223333 com o número da sua conta AWS
  • Substituir us-east-2 com sua região da AWS. O MWAA Serverless está disponível em várias regiões da AWS. Verifique o Lista de serviços AWS disponíveis por região para disponibilidade atual.

Criando seu primeiro fluxo de trabalho sem servidor

Vamos começar definindo um fluxo de trabalho simples que obtém uma lista de objetos S3 e grava essa lista em um arquivo no mesmo bucket. Crie um novo arquivo chamado simple_s3_test.yaml com o seguinte conteúdo:

simples3test:
  dag_id: simples3test
  schedule: 0 0 * * *
  duties:
    list_objects:
      operator: airflow.suppliers.amazon.aws.operators.s3.S3ListOperator
      bucket: 'amzn-s3-demo-bucket'
      prefix: ''
      retries: 0
    create_object_list:
      operator: airflow.suppliers.amazon.aws.operators.s3.S3CreateObjectOperator
      information: '{{ ti.xcom_pull(task_ids="list_objects", key="return_value") }}'
      s3_bucket: 'amzn-s3-demo-bucket'
      s3_key: 'filelist.txt'
      dependencies: (list_objects)

Para que esse fluxo de trabalho seja executado, você deve criar uma função de execução que tenha permissões para listar e gravar no bucket acima. A função também precisa ser assumida no MWAA Serverless. Os seguintes comandos CLI criam esta função e sua política associada:

aws iam create-role 
--role-name mwaa-serverless-access-role 
--assume-role-policy-document '{
    "Model": "2012-10-17",
    "Assertion": (
      {
        "Impact": "Enable",
        "Principal": {
          "Service": (
            "airflow-serverless.amazonaws.com"
          )
        },
        "Motion": "sts:AssumeRole"
      },
      {
        "Sid": "AllowAirflowServerlessAssumeRole",
        "Impact": "Enable",
        "Principal": {
          "Service": "airflow-serverless.amazonaws.com"
        },
        "Motion": "sts:AssumeRole",
        "Situation": {
          "StringEquals": {
            "aws:SourceAccount": "${aws:PrincipalAccount}"
          },
          "ArnLike": {
            "aws:SourceArn": "arn:aws:*:*:${aws:PrincipalAccount}:workflow/*"
          }
        }
      }
    )
  }'

aws iam put-role-policy 
  --role-name mwaa-serverless-access-role 
  --policy-name mwaa-serverless-policy   
  --policy-document '{
	"Model": "2012-10-17",
	"Assertion": (
		{
			"Sid": "CloudWatchLogsAccess",
			"Impact": "Enable",
			"Motion": (
				"logs:CreateLogGroup",
				"logs:CreateLogStream",
				"logs:PutLogEvents"
			),
			"Useful resource": "*"
		},
		{
			"Sid": "S3DataAccess",
			"Impact": "Enable",
			"Motion": (
				"s3:ListBucket",
				"s3:GetObject",
				"s3:PutObject"
			),
			"Useful resource": (
				"arn:aws:s3:::amzn-s3-demo-bucket",
				"arn:aws:s3:::amzn-s3-demo-bucket/*"
			)
		}
	)
}'

Em seguida, você copia seu YAML DAG para o mesmo bucket S3 e cria seu fluxo de trabalho com base na resposta Arn da função acima.

aws s3 cp "simple_s3_test.yaml" 
s3://amzn-s3-demo-bucket/yaml/simple_s3_test.yaml

aws mwaa-serverless create-workflow 
--name simple_s3_test 
--definition-s3-location '{ "Bucket": "amzn-s3-demo-bucket", "ObjectKey": "yaml/simple_s3_test.yaml" }' 
--role-arn arn:aws:iam::111122223333:function/mwaa-serverless-access-role 
--region us-east-2

A saída do último comando retorna um WorkflowARN valor, que você usa para executar o fluxo de trabalho:

aws mwaa-serverless start-workflow-run 
--workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def 
--region us-east-2

A saída retorna um RunId valor, que você usa para verificar o standing da execução do fluxo de trabalho que acabou de executar.

aws mwaa-serverless get-workflow-run 
--workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def 
--run-id ABC123456789def 
--region us-east-2

Se precisar fazer uma alteração em seu YAML, você pode copiar de volta para o S3 e executar o update-workflow comando.

aws s3 cp "simple_s3_test.yaml" 
s3://amzn-s3-demo-bucket/yaml/simple_s3_test.yaml

aws mwaa-serverless update-workflow 
--workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def 
--definition-s3-location '{ "Bucket": "amzn-s3-demo-bucket", "ObjectKey": "yaml/simple_s3_test.yaml" }' 
--role-arn arn:aws:iam::111122223333:function/mwaa-serverless-access-role 
--region us-east-2

Convertendo DAGs Python para o formato YAML

A AWS publicou um ferramenta de conversão que usa o processador Airflow DAG de código aberto para serializar DAGs Python no formato de fábrica YAML DAG. Para instalar, você executa o seguinte:

pip3 set up python-to-yaml-dag-converter-mwaa-serverless
dag-converter convert source_dag.py --output output_yaml_folder

Por exemplo, crie o seguinte DAG e nomeie-o create_s3_objects.py:

from datetime import datetime
from airflow import DAG
from airflow.fashions.param import Param
from airflow.suppliers.amazon.aws.operators.s3 import S3CreateObjectOperator

default_args = {
    'start_date': datetime(2024, 1, 1),
    'retries': 0,
}

dag = DAG(
    'create_s3_objects',
    default_args=default_args,
    description='Create a number of S3 objects in a loop',
    schedule=None
)

# Set variety of recordsdata to create
LOOP_COUNT = 3
s3_bucket="md-workflows-mwaa-bucket"
s3_prefix = 'test-files'

# Create a number of S3 objects utilizing loop
last_task=None
for i in vary(1, LOOP_COUNT + 1):  
    create_object = S3CreateObjectOperator(
        task_id=f'create_object_{i}',
        s3_bucket=s3_bucket,
        s3_key=f'{s3_prefix}/{i}.txt',
        information="{{ ds_nodash }}-{ decrease }",
        substitute=True,
        dag=dag
    )
    if last_task:
        last_task >> create_object
    last_task = create_object

Depois de instalar python-to-yaml-dag-converter-mwaa-serverlessvocê executa:

dag-converter convert "/path_to/create_s3_objects.py" --output "/path_to/yaml/"

Onde a saída terminará com:

YAML validation profitable, no errors discovered

YAML written to /path_to/yaml/create_s3_objects.yaml

E o YAML resultante será semelhante a:

create_s3_objects:
  dag_id: create_s3_objects
  params: {}
  default_args:
    start_date: '2024-01-01'
    retries: 0
  schedule: None
  duties:
    create_object_1:
      operator: airflow.suppliers.amazon.aws.operators.s3.S3CreateObjectOperator
      aws_conn_id: aws_default
      information: '{{ ds_nodash }}-{ decrease }'
      encrypt: false
      retailers: ()
      params: {}
      priority_weight: 1
      substitute: true
      retries: 0
      retry_delay: 300.0
      retry_exponential_backoff: false
      s3_bucket: md-workflows-mwaa-bucket
      s3_key: test-files/1.txt
      task_id: create_object_1
      trigger_rule: all_success
      wait_for_downstream: false
      dependencies: ()
    create_object_2:
      operator: airflow.suppliers.amazon.aws.operators.s3.S3CreateObjectOperator
      aws_conn_id: aws_default
      information: '{{ ds_nodash }}-{ decrease }'
      encrypt: false
      retailers: ()
      params: {}
      priority_weight: 1
      substitute: true
      retries: 0
      retry_delay: 300.0
      retry_exponential_backoff: false
      s3_bucket: md-workflows-mwaa-bucket
      s3_key: test-files/2.txt
      task_id: create_object_2
      trigger_rule: all_success
      wait_for_downstream: false
      dependencies: (create_object_1)
    create_object_3:
      operator: airflow.suppliers.amazon.aws.operators.s3.S3CreateObjectOperator
      aws_conn_id: aws_default
      information: '{{ ds_nodash }}-{ decrease }'
      encrypt: false
      retailers: ()
      params: {}
      priority_weight: 1
      substitute: true
      retries: 0
      retry_delay: 300.0
      retry_exponential_backoff: false
      s3_bucket: md-workflows-mwaa-bucket
      s3_key: test-files/3.txt
      task_id: create_object_3
      trigger_rule: all_success
      wait_for_downstream: false
      dependencies: (create_object_2)
  catchup: false
  description: Create a number of S3 objects in a loop
  max_active_runs: 16
  max_active_tasks: 16
  max_consecutive_failed_dag_runs: 0

Observe que, como a conversão YAML é feita após a análise do DAG, o loop que cria as tarefas é executado primeiro e a lista estática de tarefas resultante é gravada no documento YAML com suas dependências.

Migrando DAGs de um ambiente MWAA para MWAA Serverless

Você pode aproveitar um ambiente MWAA provisionado para desenvolver e testar seus fluxos de trabalho e, em seguida, movê-los para sem servidor para serem executados com eficiência em escala. Além disso, se o seu ambiente MWAA estiver usando operadores MWAA Serverless compatíveis, você poderá converter todos os DAGs do ambiente de uma só vez. A primeira etapa é permitir que o MWAA Serverless assuma a função de execução do MWAA por meio de uma relação de confiança. Esta é uma operação única para cada função de execução do MWAA e pode ser executada manualmente no console do IAM ou usando um comando AWS CLI da seguinte forma:

MWAA_ENVIRONMENT_NAME="MyAirflowEnvironment"
MWAA_REGION=us-east-2

MWAA_EXECUTION_ROLE_ARN=$(aws mwaa get-environment --region $MWAA_REGION --name $MWAA_ENVIRONMENT_NAME --query 'Setting.ExecutionRoleArn' --output textual content )
MWAA_EXECUTION_ROLE_NAME=$(echo $MWAA_EXECUTION_ROLE_ARN | xargs basename) 
MWAA_EXECUTION_ROLE_POLICY=$(aws iam get-role --role-name $MWAA_EXECUTION_ROLE_NAME --query 'Position.AssumeRolePolicyDocument' --output json | jq '.Assertion(0).Principal.Service += ("airflow-serverless.amazonaws.com") | .Assertion(0).Principal.Service |= distinctive | .Assertion += ({"Sid": "AllowAirflowServerlessAssumeRole", "Impact": "Enable", "Principal": {"Service": "airflow-serverless.amazonaws.com"}, "Motion": "sts:AssumeRole", "Situation": {"StringEquals": {"aws:SourceAccount": "${aws:PrincipalAccount}"}, "ArnLike": {"aws:SourceArn": "arn:aws:*:*:${aws:PrincipalAccount}:workflow/*"}}})')

aws iam update-assume-role-policy --role-name $MWAA_EXECUTION_ROLE_NAME --policy-document "$MWAA_EXECUTION_ROLE_POLICY"

Agora podemos percorrer cada DAG convertido com sucesso e criar fluxos de trabalho sem servidor para cada um.

S3_BUCKET=$(aws mwaa get-environment --name $MWAA_ENVIRONMENT_NAME --query 'Setting.SourceBucketArn' --output textual content --region us-east-2 | lower -d':' -f6)

for file in /tmp/yaml/*.yaml; do MWAA_WORKFLOW_NAME=$(basename "$file" .yaml); 
      aws s3 cp "$file" s3://$S3_BUCKET/yaml/$MWAA_WORKFLOW_NAME.yaml --region us-east-2; 
      aws mwaa-serverless create-workflow --name $MWAA_WORKFLOW_NAME 
      --definition-s3-location "{"Bucket": "$S3_BUCKET", "ObjectKey": "yaml/$MWAA_WORKFLOW_NAME.yaml"}" --role-arn $MWAA_EXECUTION_ROLE_ARN  
      --region us-east-2  
      achieved

Para ver uma lista dos fluxos de trabalho criados, execute:

aws mwaa-serverless list-workflows --region us-east-2

Monitoramento e observabilidade

O standing de execução do fluxo de trabalho sem servidor MWAA é retornado por meio do GetWorkflowRun função. Os resultados retornarão detalhes dessa execução específica. Se houver erros na definição do fluxo de trabalho, eles serão retornados em RunDetail no ErrorMessage campo como no exemplo a seguir:

{
  "WorkflowVersion": "7bcd36ce4d42f5cf23bfee67a0f816c6",
  "RunId": "d58cxqdClpTVjeN",
  "RunType": "SCHEDULE",
  "RunDetail": {
    "ModifiedAt": "2025-11-03T08:02:47.625851+00:00",
    "ErrorMessage": "anticipated token ',', acquired 'create_test_table'",
    "TaskInstances": (),
    "RunState": "FAILED"
  }
}

Fluxos de trabalho definidos corretamente, mas cujas tarefas falham, retornarão "ErrorMessage": "Workflow execution failed":

{
  "WorkflowVersion": "0ad517eb5e33deca45a2514c0569079d",
  "RunId": "ABC123456789def",
  "RunType": "SCHEDULE",
  "RunDetail": {
    "StartedOn": "2025-11-03T13:12:09.904466+00:00",
    "CompletedOn": "2025-11-03T13:13:57.620605+00:00",
    "ModifiedAt": "2025-11-03T13:16:08.888182+00:00",
    "Period": 107,
    "ErrorMessage": "Workflow execution failed",
    "TaskInstances": (
      "ex_5496697b-900d-4008-8d6f-5e43767d6e36_create_bucket_1"
    ),
    "RunState": "FAILED"
  },
}

Os logs de tarefas sem servidor MWAA são armazenados no grupo de logs do CloudWatch /aws/mwaa-serverless// (onde / é a mesma string que o ID exclusivo do fluxo de trabalho no ARN do fluxo de trabalho). Para fluxos de log de tarefas específicos, você precisará listar as tarefas para a execução do fluxo de trabalho e, em seguida, obter as informações de cada tarefa. Você pode combinar essas operações em um único comando CLI.

aws mwaa-serverless list-task-instances 
  --workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def 
  --run-id ABC123456789def 
  --region us-east-2 
  --query 'TaskInstances().TaskInstanceId' 
  --output textual content | xargs -n 1 -I {} aws mwaa-serverless get-task-instance 
  --workflow-arn arn:aws:airflow-serverless:us-east-2:111122223333:workflow/simple_s3_test-abc1234def 
  --run-id ABC123456789def 
  --task-instance-id {} 
  --region us-east-2 
  --query '{Standing: Standing, StartedAt: StartedAt, LogStream: LogStream}'

O que resultaria no seguinte:

{
    "Standing": "SUCCESS",
    "StartedAt": "2025-10-28T21:21:31.753447+00:00",
    "LogStream": "//aws/mwaa-serverless/simple_s3_test_3-abc1234def//workflow_id=simple_s3_test-abc1234def/run_id=ABC123456789def/task_id=list_objects/try=1.log"
}
{
    "Standing": "FAILED",
    "StartedAt": "2025-10-28T21:23:13.446256+00:00",
    "LogStream": "//aws/mwaa-serverless/simple_s3_test_3-abc1234def//workflow_id=simple_s3_test-abc1234def/run_id=ABC123456789def/task_id=create_object_list/try=1.log"
}

Nesse ponto, você usaria o CloudWatch LogStream saída para depurar seu fluxo de trabalho.

Você pode visualizar e gerenciar seus fluxos de trabalho no Console sem servidor Amazon MWAA:

Para obter um exemplo que cria métricas detalhadas e painel de monitoramento usando AWS Lambda, Amazon CloudWatch, Amazon DynamoDBe Amazon Occasion Bridgerevise o exemplo em este repositório GitHub.

Limpar recursos

Para evitar cobranças contínuas, siga estas etapas para limpar todos os recursos criados durante este tutorial:

  1. Excluir fluxos de trabalho sem servidor MWAA – execute este comando AWS CLI para excluir todos os fluxos de trabalho:
    aws mwaa-serverless list-workflows --query 'Workflows(*).WorkflowArn' --output textual content | whereas learn -r workflow; do aws mwaa-serverless delete-workflow --workflow-arn $workflow achieved

  2. Remova as funções e políticas do IAM criadas para este tutorial:
    aws iam delete-role-policy --role-name mwaa-serverless-access-role --policy-name mwaa-serverless-policy

  3. Remova as definições de fluxo de trabalho YAML do bucket S3:
    aws s3 rm s3://amzn-s3-demo-bucket/yaml/ --recursive

Após concluir essas etapas, verifique no AWS Administration Console se todos os recursos foram removidos corretamente. Lembre-se de que os CloudWatch Logs são retidos por padrão e podem precisar ser excluídos separadamente se você quiser remover todos os rastros das execuções do seu fluxo de trabalho.

Se você encontrar algum erro durante a limpeza, verifique se possui as permissões necessárias e se existem recursos antes de tentar excluí-los. Alguns recursos podem ter dependências que exigem que sejam excluídos em uma ordem específica.

Conclusão

Nesta postagem, exploramos o Amazon MWAA Serverless, uma nova opção de implantação que simplifica o gerenciamento do fluxo de trabalho do Apache Airflow. Demonstramos como criar fluxos de trabalho usando definições YAML, converter DAGs Python existentes para o formato sem servidor e monitorar seus fluxos de trabalho.

MWAA Serverless oferece várias vantagens importantes:

  • Sem sobrecarga de provisionamento
  • Modelo de preços de pagamento por uso
  • Dimensionamento automático com base nas demandas do fluxo de trabalho
  • Segurança aprimorada por meio de permissões granulares de IAM
  • Definições simplificadas de fluxo de trabalho usando YAML

Para saber mais sobre MWAA Serverless, revise o documentação.

Sobre os autores

João Jackson

João Jackson

John tem mais de 25 anos de experiência em software program como desenvolvedor, arquiteto de sistemas e gerente de produtos em startups e grandes corporações e é o principal gerente de produto da AWS responsável pelo Amazon MWAA.

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *