Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Migración a un nuevo entorno de Amazon MWAA
<a name="migrating-to-new-mwaa"></a>

Explore los siguientes pasos para migrar la carga de trabajo de Apache Airflow existente a un nuevo entorno de Amazon MWAA. Puede seguir estos pasos para migrar de una versión anterior de Amazon MWAA a una versión nueva, o bien migrar su implementación autoadministrada de Apache Airflow a Amazon MWAA. En este tutorial se da por sentado que está migrando desde una versión 1.10.12 de Apache Airflow existente a una nueva Amazon MWAA con Apache Airflow v2.5.1, pero puede utilizar los mismos procedimientos para migrar desde o hacia versiones diferentes de Apache Airflow. 

**Topics**
+ [Requisitos previos](#migrating-to-new-mwaa-prerequisites)
+ [Primer paso: cree un nuevo entorno Amazon MWAA que ejecute la última versión compatible de Apache Airflow](#migrating-to-new-mwaa-create-a-new-environment)
+ [Paso dos: migre los recursos de su flujo de trabajo](#migrating-to-new-mwaa-workflows)
+ [Paso tres: exportar los metadatos de su entorno actual](#migrating-to-new-mwaa-exporting-metadatadb)
+ [Paso cuatro: importar los metadatos a su nuevo entorno](#migrating-to-new-mwaa-importing-metadatadb)
+ [Siguientes pasos](#migrating-to-new-mwaa-next-up)

## Requisitos previos
<a name="migrating-to-new-mwaa-prerequisites"></a>

Para poder completar los pasos y migrar su entorno, necesitará lo siguiente:
+ Una implementación de Apache Airflow. Puede ser un entorno Amazon MWAA existente o autogestionado.
+  [Docker debe estar instalado](https://docs.docker.com/get-docker/) en el sistema operativo local. 
+  [AWS Command Line Interface versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install) instalada. 

## Primer paso: cree un nuevo entorno Amazon MWAA que ejecute la última versión compatible de Apache Airflow
<a name="migrating-to-new-mwaa-create-a-new-environment"></a>

 Puede crear un entorno siguiendo los pasos detallados de [Introducción a Amazon MWAA](https://docs.aws.amazon.com/mwaa/latest/userguide/get-started.html) en la *Guía del usuario de Amazon MWAA o mediante una* plantilla. CloudFormation Si está migrando desde un entorno Amazon MWAA existente y utilizó una CloudFormation plantilla para crear el entorno anterior, puede cambiar la `AirflowVersion` propiedad para especificar la nueva versión. 

```
MwaaEnvironment:
  Type: AWS::MWAA::Environment
  DependsOn: MwaaExecutionPolicy
  Properties:
    Name: !Sub "${AWS::StackName}-MwaaEnvironment"
    SourceBucketArn: !GetAtt EnvironmentBucket.Arn
    ExecutionRoleArn: !GetAtt MwaaExecutionRole.Arn
    AirflowVersion: 2.5.1
    DagS3Path: dags
  NetworkConfiguration:
    SecurityGroupIds:
      - !GetAtt SecurityGroup.GroupId
    SubnetIds:
      - !Ref PrivateSubnet1
      - !Ref PrivateSubnet2
  WebserverAccessMode: PUBLIC_ONLY
  MaxWorkers: !Ref MaxWorkerNodes
  LoggingConfiguration:
    DagProcessingLogs:
      LogLevel: !Ref DagProcessingLogs
      Enabled: true
    SchedulerLogs:
      LogLevel: !Ref SchedulerLogsLevel
      Enabled: true
    TaskLogs:
      LogLevel: !Ref TaskLogsLevel
      Enabled: true
    WorkerLogs:
      LogLevel: !Ref WorkerLogsLevel
      Enabled: true
    WebserverLogs:
      LogLevel: !Ref WebserverLogsLevel
      Enabled: true
```

 Como alternativa, si migra desde un entorno Amazon MWAA existente, puede copiar el siguiente script de Python que utiliza el [SDK de AWS para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) para clonar su entorno. También puede [descargar el script](../userguide/samples/clone_environment.zip). 

### Script de Python
<a name="migrating-to-new-mwaa-clone-a-new-environment"></a>

```
# This Python file uses the following encoding: utf-8
'''
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: MIT-0

Permission is hereby granted, free of charge, to any person obtaining a copy of this
software and associated documentation files (the "Software"), to deal in the Software
without restriction, including without limitation the rights to use, copy, modify,
merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
'''
from __future__ import print_function
import argparse
import json
import socket
import time
import re
import sys
from datetime import timedelta
from datetime import datetime
import boto3
from botocore.exceptions import ClientError, ProfileNotFound
from boto3.session import Session
ENV_NAME = ""
REGION = ""

def verify_boto3(boto3_current_version):
    '''
    check if boto3 version is valid, must be 1.17.80 and up
    return true if all dependenceis are valid, false otherwise
    '''
    valid_starting_version = '1.17.80'
    if boto3_current_version == valid_starting_version:
        return True
    ver1 = boto3_current_version.split('.')
    ver2 = valid_starting_version.split('.')
    for i in range(max(len(ver1), len(ver2))):
        num1 = int(ver1[i]) if i < len(ver1) else 0
        num2 = int(ver2[i]) if i < len(ver2) else 0
        if num1 > num2:
            return True
        elif num1 < num2:
            return False
    return False


def get_account_id(env_info):
    '''
    Given the environment metadata, fetch the account id from the
    environment ARN
    '''
    return env_info['Arn'].split(":")[4]


def validate_envname(env_name):
    '''
    verify environment name doesn't have path to files or unexpected input
    '''
    if re.match(r"^[a-zA-Z][0-9a-zA-Z-_]*$", env_name):
        return env_name
    raise argparse.ArgumentTypeError("%s is an invalid environment name value" % env_name)


def validation_region(input_region):
    '''
    verify environment name doesn't have path to files or unexpected input
    REGION: example is us-east-1
    '''
    session = Session()
    mwaa_regions = session.get_available_regions('mwaa')
    if input_region in mwaa_regions:
        return input_region
    raise argparse.ArgumentTypeError("%s is an invalid REGION value" % input_region)


def validation_profile(profile_name):
    '''
    verify profile name doesn't have path to files or unexpected input
    '''
    if re.match(r"^[a-zA-Z0-9]*$", profile_name):
        return profile_name
    raise argparse.ArgumentTypeError("%s is an invalid profile name value" % profile_name)

def validation_version(version_name):
    '''
    verify profile name doesn't have path to files or unexpected input
    '''
    if re.match(r"[1-2].\d.\d", version_name):
        return version_name
    raise argparse.ArgumentTypeError("%s is an invalid version name value" % version_name)

def validation_execution_role(execution_role_arn):
    '''
    verify profile name doesn't have path to files or unexpected input
    '''
    if re.match(r'(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:\'".,<>?«»“”‘’]))', execution_role_arn):
        return execution_role_arn
    raise argparse.ArgumentTypeError("%s is an invalid execution role ARN" % execution_role_arn)

def create_new_env(env):
    '''
    method to duplicate env
    '''
    mwaa = boto3.client('mwaa', region_name=REGION)

    print('Source Environment')
    print(env)
    if (env['AirflowVersion']=="1.10.12") and (VERSION=="2.2.2"):
        if env['AirflowConfigurationOptions']['secrets.backend']=='airflow.contrib.secrets.aws_secrets_manager.SecretsManagerBackend':
            print('swapping',env['AirflowConfigurationOptions']['secrets.backend'])
            env['AirflowConfigurationOptions']['secrets.backend']='airflow.providers.amazon.aws.secrets.secrets_manager.SecretsManagerBackend'
    env['LoggingConfiguration']['DagProcessingLogs'].pop('CloudWatchLogGroupArn')
    env['LoggingConfiguration']['SchedulerLogs'].pop('CloudWatchLogGroupArn')
    env['LoggingConfiguration']['TaskLogs'].pop('CloudWatchLogGroupArn')
    env['LoggingConfiguration']['WebserverLogs'].pop('CloudWatchLogGroupArn')
    env['LoggingConfiguration']['WorkerLogs'].pop('CloudWatchLogGroupArn')
    env['AirflowVersion']=VERSION
    env['ExecutionRoleArn']=EXECUTION_ROLE_ARN
    env['Name']=ENV_NAME_NEW
    env.pop('Arn')
    env.pop('CreatedAt')
    env.pop('LastUpdate')
    env.pop('ServiceRoleArn')
    env.pop('Status')
    env.pop('WebserverUrl')
    if not env['Tags']:
        env.pop('Tags')
    print('Destination Environment')
    print(env)

    return mwaa.create_environment(**env)

def get_mwaa_env(input_env_name):
 
    # https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/mwaa.html#MWAA.Client.get_environment
    mwaa = boto3.client('mwaa', region_name=REGION)
    environment = mwaa.get_environment(
        Name=input_env_name
    )['Environment']

    return environment

def print_err_msg(c_err):
    '''short method to handle printing an error message if there is one'''
    print('Error Message: {}'.format(c_err.response['Error']['Message']))
    print('Request ID: {}'.format(c_err.response['ResponseMetadata']['RequestId']))
    print('Http code: {}'.format(c_err.response['ResponseMetadata']['HTTPStatusCode']))

#
# Main
#
# Usage:
# python3 clone_environment.py --envname MySourceEnv --envnamenew MyDestEnv --region us-west-2 --execution_role AmazonMWAA-MyDestEnv-ExecutionRole --version 2.2.2
#
# based on https://github.com/awslabs/aws-support-tools/blob/master/MWAA/verify_env/verify_env.py
#

if __name__ == '__main__':
    if sys.version_info[0] < 3:
        print("python2 detected, please use python3. Will try to run anyway")
    if not verify_boto3(boto3.__version__):
        print("boto3 version ", boto3.__version__, "is not valid for this script. Need 1.17.80 or higher")
        print("please run pip install boto3 --upgrade --user")
        sys.exit(1)
    parser = argparse.ArgumentParser()
    parser.add_argument('--envname', type=validate_envname, required=True, help="name of the source MWAA environment")
    parser.add_argument('--region', type=validation_region, default=boto3.session.Session().region_name,
                        required=False, help="region, Ex: us-east-1")
    parser.add_argument('--profile', type=validation_profile, default=None,
                        required=False, help="AWS CLI profile, Ex: dev")
    parser.add_argument('--version', type=validation_version, default="2.2.2",
                        required=False, help="Airflow destination version, Ex: 2.2.2")
    parser.add_argument('--execution_role', type=validation_execution_role, default=None,
                        required=True, help="New environment execution role ARN, Ex: arn:aws:iam::112233445566:role/service-role/AmazonMWAA-MyEnvironment-ExecutionRole")
    parser.add_argument('--envnamenew', type=validate_envname, required=True, help="name of the destination MWAA environment")

    args, _ = parser.parse_known_args()
    ENV_NAME = args.envname
    REGION = args.region
    PROFILE = args.profile
    VERSION = args.version
    EXECUTION_ROLE_ARN = args.execution_role
    ENV_NAME_NEW = args.envnamenew

    try:
        print("PROFILE",PROFILE)
        if PROFILE:
            boto3.setup_default_session(profile_name=PROFILE)
        env = get_mwaa_env(ENV_NAME)
        response = create_new_env(env)
        print(response)
    except ClientError as client_error:
        if client_error.response['Error']['Code'] == 'LimitExceededException':
            print_err_msg(client_error)
            print('please retry the script')
        elif client_error.response['Error']['Code'] in ['AccessDeniedException', 'NotAuthorized']:
            print_err_msg(client_error)
            print('please verify permissions used have permissions documented in readme')
        elif client_error.response['Error']['Code'] == 'InternalFailure':
            print_err_msg(client_error)
            print('please retry the script')
        else:
            print_err_msg(client_error)
    except ProfileNotFound as profile_not_found:
        print('profile', PROFILE, 'does not exist; check the profile name')
    except IndexError as error:
        print("Error:", error)
```

## Paso dos: migre los recursos de su flujo de trabajo
<a name="migrating-to-new-mwaa-workflows"></a>

 Apache Airflow v2 es una versión principal. Si va a migrar desde Apache Airflow v1, debe preparar los recursos de flujo de trabajo y verificar los cambios que realiza en DAGs sus requisitos y complementos. Para ello, le recomendamos configurar una versión *puente* de Apache Airflow en su sistema operativo local mediante Docker y el [ejecutor local Amazon MWAA.](https://github.com/aws/aws-mwaa-local-runner) El ejecutor local de Amazon MWAA proporciona una utilidad de interfaz de línea de comandos (CLI) que replica un entorno de Amazon MWAA de forma local. 

 Siempre que cambie las versiones de Apache Airflow, asegúrese de hacer [referencia a la URL `--constraint` correcta](https://docs.aws.amazon.com/mwaa/latest/userguide/working-dags-dependencies.html#working-dags-dependencies-test-create) en su `requirements.txt`. 

**Migración de los recursos de su flujo de trabajo**

1.  Cree una bifurcación del [aws-mwaa-local-runner](https://github.com/aws/aws-mwaa-local-runner)repositorio y clone una copia del ejecutor local de Amazon MWAA. 

1.  Consulte la `v1.10.15` sucursal del repositorio. aws-mwaa-local-runner Apache Airflow publicó la versión 1.10.15 como *versión puente* para facilitar la migración a Apache Airflow v2 y, aunque Amazon MWAA no es compatible con la versión 1.10.15, puede utilizar el ejecutor local de Amazon MWAA para probar sus recursos. 

1.  Utilice la herramienta CLI del ejecutor local Amazon MWAA para crear la imagen de Docker y ejecutar Apache Airflow de forma local. Para obtener más información, consulta el [archivo README](https://github.com/aws/aws-mwaa-local-runner/tree/v1.10.15#readme) local del GitHub repositorio. 

1.  Si Apache Airflow se ejecuta de forma local, siga los pasos descritos en la sección [Actualización de la versión 1.10 a la versión 2 en el sitio web de](https://airflow.apache.org/docs/apache-airflow/stable/upgrading-from-1-10/index.html) documentación de Apache Airflow. 

   1.  Para actualizar los `requirements.txt`, siga las prácticas recomendadas que se indican en [Administrar las dependencias de Python](https://docs.aws.amazon.com/mwaa/latest/userguide/best-practices-dependencies.html), en la *Guía del usuario de Amazon MWAA*. 

   1.  Si ha agrupado sus operadores y sensores personalizados con los complementos de su entorno Apache Airflow v1.10.12 existente, muévalos a su carpeta DAG. Para obtener más información sobre las prácticas recomendadas de administración de módulos para Apache Airflow v2 y versiones posteriores, consulte cómo [administrar módulos](https://airflow.apache.org/docs/apache-airflow/stable/modules_management.html) en el sitio web de documentación de Apache Airflow. 

1.  Una vez que hayas realizado los cambios necesarios en los recursos de tu flujo de trabajo, `v2.5.1` consulta la rama del aws-mwaa-local-runner repositorio y prueba localmente el flujo de trabajo actualizado DAGs, los requisitos y los complementos personalizados. Si va a migrar a una versión diferente de Apache Airflow, puede utilizar la rama de ejecución local adecuada para su versión. 

1.  Una vez que haya probado correctamente sus recursos de flujo de trabajo, copie sus DAGs complementos y los suyos en el bucket de Amazon S3 que configuró con su nuevo entorno de Amazon MWAA. `requirements.txt` 

## Paso tres: exportar los metadatos de su entorno actual
<a name="migrating-to-new-mwaa-exporting-metadatadb"></a>

 Las tablas de metadatos de Apache Airflow como `dag`, `dag_tag` y `dag_code` se rellenan automáticamente cuando copia los archivos DAG actualizados en el bucket de Amazon S3 de su entorno y el programador los analiza. Las tablas relacionadas con los permisos también se rellenan automáticamente en función del permiso del rol de ejecución de IAM. No es necesario migrarlos. 

 Puede migrar los datos relacionados con el historial del DAG, `variable`, `slot_pool`, `sla_miss`, y si es necesario, `xcom`, `job`, y las tablas `log`. El registro de instancias de tareas se almacena en los CloudWatch registros del grupo de `airflow-{environment_name}` registros. Si quiere ver los registros de las instancias de tareas de las ejecuciones anteriores, debe copiarlos en el nuevo grupo de registros del entorno. Le recomendamos que mueva solo los registros correspondientes a unos pocos días para reducir los costes asociados. 

 Si está migrando desde un entorno Amazon MWAA existente, no hay acceso directo a la base de datos de metadatos. Debe ejecutar un DAG para exportar los metadatos del entorno de Amazon MWAA existente al bucket de Amazon S3 de su elección. Los siguientes pasos también se pueden utilizar para exportar los metadatos de Apache Airflow si va a migrar desde un entorno autogestionado. 

 Después de exportar los datos, puede ejecutar un DAG en el nuevo entorno para importar los datos. Durante el proceso de exportación e importación, todos los demás DAGs se detienen. 

**Exportación de los metadatos de su entorno actual**

1.  Cree un bucket de Amazon S3 con el AWS CLI para almacenar los datos exportados. Reemplace `UUID` y `region` con su propia información. 

   ```
   aws s3api create-bucket \
   --bucket mwaa-migration-{UUID}\
   --region {region}
   ```
**nota**  
 Si va a migrar datos confidenciales, como las conexiones que almacena en variables, le recomendamos que [habilite el cifrado predeterminado](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-bucket-encryption.html) para el bucket de Amazon S3. 

1. 
**nota**  
No se aplica a la migración desde un entorno autogestionado.

    Modifique el rol de ejecución del entorno existente y añada la siguiente política para conceder acceso de escritura al bucket que creó en el primer paso. 

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:PutObject*"
               ],
               "Resource": [
                   "arn:aws:s3:::mwaa-migration-{UUID}/*"
               ]
           }
       ]
   }
   ```

------

1.  Clone el [amazon-mwaa-examples](https://github.com/aws-samples/amazon-mwaa-examples)repositorio y navegue hasta el `metadata-migration` subdirectorio correspondiente a su escenario de migración. 

   ```
   git clone https://github.com/aws-samples/amazon-mwaa-examples.git
   cd amazon-mwaa-examples/usecases/metadata-migration/existing-version-new-version/
   ```

1.  En `export_data.py`, sustituya el valor de cadena para `S3_BUCKET` con el bucket de Amazon S3 que creó para almacenar los metadatos exportados. 

   ```
   S3_BUCKET = 'mwaa-migration-{UUID}'
   ```

1.  Ubique el archivo `requirements.txt` en el directorio `metadata-migration`. Si ya tiene un archivo de requisitos para su entorno actual, añada los requisitos adicionales especificados en el archivo `requirements.txt`. Si no tiene un archivo de requisitos existente, simplemente puede usar el que se proporciona en el directorio `metadata-migration`. 

1.  Copie `export_data.py` en el directorio DAG el bucket de Amazon S3 asociado con el entorno actual. Si va a migrar desde un entorno autogestionado, copie `export_data.py` a su carpeta `/dags`. 

1. Copie la actualización de `requirements.txt` en el bucket de Amazon S3 asociado a su entorno actual y, a continuación, edite el entorno para especificar la nueva versión `requirements.txt`.

1.  Una vez actualizado el entorno, acceda a la interfaz de usuario de Apache Airflow, anule la pausa del DAG `db_export` y active la ejecución del flujo de trabajo. 

1.  Compruebe que los metadatos se exportan al `data/migration/existing-version_to_new-version/export/` en el bucket de Amazon S3 `mwaa-migration-{UUID}`, con cada tabla en su propio archivo dedicado. 

## Paso cuatro: importar los metadatos a su nuevo entorno
<a name="migrating-to-new-mwaa-importing-metadatadb"></a>

**Importación de los metadatos a su nuevo entorno**

1.  En `import_data.py`, sustituya los valores de cadena de los siguientes valores por su información. 
   + Para la migración desde un entorno Amazon MWAA existente:

     ```
     S3_BUCKET = 'mwaa-migration-{UUID}'
     							OLD_ENV_NAME='{old_environment_name}'
     							NEW_ENV_NAME='{new_environment_name}'
     							TI_LOG_MAX_DAYS = {number_of_days}
     ```

      `MAX_DAYS` controla el número de días de archivos de registro que el flujo de trabajo copia al nuevo entorno. 
   + Para migrar desde un entorno autoadministrado:

     ```
     S3_BUCKET = 'mwaa-migration-{UUID}'
     							NEW_ENV_NAME='{new_environment_name}'
     ```

1.  (Opcional) `import_data.py` copia solo los registros de tareas fallidas. Si desea copiar todos los registros de tareas, modifique la función `getDagTasks` y elimine `ti.state = 'failed'` como se muestra en el siguiente fragmento de código. 

   ```
   def getDagTasks():
   					session = settings.Session()
   					dagTasks = session.execute(f"select distinct ti.dag_id, ti.task_id, date(r.execution_date) as ed \
   					from task_instance ti, dag_run r where r.execution_date > current_date - {TI_LOG_MAX_DAYS} and \
   					ti.dag_id=r.dag_id and ti.run_id = r.run_id order by ti.dag_id, date(r.execution_date);").fetchall()
   					return dagTasks
   ```

1.  Modifique el rol de ejecución de su nuevo entorno y añada la siguiente política. La política de permisos permite a Amazon MWAA leer del bucket de Amazon S3 al que exportaron los metadatos de Apache Airflow y copiar los registros de instancias de tareas de los grupos de registros existentes. Sustituya todos los marcadores de posición por su información. 
**nota**  
 Si va a migrar desde un entorno autogestionado, debe eliminar de la política los permisos relacionados con los CloudWatch registros. 

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "logs:GetLogEvents",
                   "logs:DescribeLogStreams"
               ],
               "Resource": [
                "arn:aws:logs:us-east-1:111122223333:log-group:airflow-{old_environment_name}*"
               ]
           },
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::mwaa-migration-{UUID}",
                   "arn:aws:s3:::mwaa-migration-{UUID}/*"
               ]
           }
       ]
   }
   ```

------

1.  Copie `import_data.py` en el directorio DAG del bucket de Amazon S3 asociado a su nuevo entorno y, a continuación, acceda a la interfaz de usuario de Apache Airflow para detener el DAG `db_import` y active el flujo de trabajo. El nuevo DAG aparecerá en la interfaz de usuario de Apache Airflow en unos minutos. 

1.  Una vez finalizada la ejecución del DAG, compruebe que el historial de ejecuciones del DAG esté copiado accediendo a cada DAG individual. 

## Siguientes pasos
<a name="migrating-to-new-mwaa-next-up"></a>
+  Para obtener más información sobre las clases y capacidades del entorno Amazon MWAA disponibles, consulte la [clase de entorno de Amazon MWAA](https://docs.aws.amazon.com/mwaa/latest/userguide/environment-class.html) en la *guía del usuario de Amazon MWAA*. 
+  Para obtener más información sobre cómo Amazon MWAA gestiona el escalado automático de los procesos de trabajo, consulte el [escalado automático de Amazon MWAA](https://docs.aws.amazon.com/mwaa/latest/userguide/mwaa-autoscaling.html) en la *guía del usuario de Amazon MWAA.* 
+  Para obtener más información acerca de la API de REST de Amazon MWAA, consulte la [API de REST de Amazon MWAA](https://docs.aws.amazon.com/mwaa/latest/API/Welcome.html).