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.

Cómo empezar a AWS Batch usar Fargate el AWS CLI

En este tutorial se muestra cómo configurar AWS Batch la AWS Fargate orquestación y cómo ejecutar un sencillo trabajo de «Hello World» con la AWS Command Line Interface tecla ().AWS CLI Aprenderá a crear entornos de computación, colas de trabajos, definiciones de trabajos y enviar trabajos a AWS Batch.

Requisitos previos

Antes de comenzar este tutorial, asegúrese de tener lo siguiente:

Tiempo necesario: Este tutorial se completa entre aproximadamente 15 y 20 minutos.

Costo: Este tutorial utiliza los recursos de computación de Fargate. El costo estimado para completar este tutorial es menos de 0,01 USD, siempre que siga las instrucciones de eliminación para eliminar los recursos inmediatamente después de completarlo. Los precios de Fargate se basan en los recursos de vCPU y memoria consumidos, y se cobran por segundo con un mínimo de 1 minuto. Para obtener información acerca de los precios, consulte Precios de AWS Fargate.

Creación de un rol de ejecución de IAM

AWS Batch requiere una función de ejecución que permita a los agentes de Amazon Elastic Container Service (Amazon ECS) AWS realizar llamadas a la API en su nombre. Esta función es necesaria para que Fargate extraiga imágenes de contenedores y escriba registros para Amazon. CloudWatch

Creación de un documento de política de confianza

Primero, cree una política de confianza que permita al servicio de Amazon ECS asumir el rol.

cat > batch-execution-role-trust-policy.json << EOF
{
  "Version":"2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "ecs-tasks.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
EOF

Cree el rol de ejecución

El siguiente comando crea un rol de IAM con el nombre BatchEcsTaskExecutionRoleTutorial mediante la política de confianza que usted creó.

aws iam create-role \
    --role-name BatchEcsTaskExecutionRoleTutorial \
    --assume-role-policy-document file://batch-execution-role-trust-policy.json

Asociación de la política requerida

Adjunte la política AWS gestionada que proporciona los permisos necesarios para la ejecución de las tareas de Amazon ECS.

aws iam attach-role-policy \
    --role-name BatchEcsTaskExecutionRoleTutorial \
    --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy

La función ya está lista para ser utilizada en la ejecución AWS Batch de tareas de Fargate.

Creación de un entorno de computación

Un entorno de computación define los recursos de computación en los que se ejecutarán los trabajos por lotes. Para este tutorial, creará un entorno de computación administrado por Fargate que aprovisione y escale automáticamente los recursos según los requisitos del trabajo.

Creación de un entorno de computación

El siguiente comando crea un entorno de computación para Fargate. Sustituya la subred y el grupo de seguridad de ejemplo por IDs los suyos propios según el. Requisitos previos

aws batch create-compute-environment \
    --compute-environment-name my-fargate-compute-env \
    --type MANAGED \
    --state ENABLED \
    --compute-resources type=FARGATE,maxvCpus=128,subnets=subnet-a123456b,securityGroupIds=sg-a12b3456

A continuación, se muestra cómo se ve la salida cuando el comando se ejecuta correctamente.

{
    "computeEnvironmentName": "my-fargate-compute-env",
    "computeEnvironmentArn": "arn:aws:batch:us-west-2:123456789012:compute-environment/my-fargate-compute-env"
}

Espera del entorno de computación hasta que esté listo

Compruebe el estado de su entorno de computación para asegurarse de que esté listo antes de continuar.

aws batch describe-compute-environments \
    --compute-environments my-fargate-compute-env \
    --query 'computeEnvironments[0].status'
        

"VALID"

Cuando se muestre el estado VALID, su entorno de computación estará preparado para aceptar trabajos.

Cree una cola de trabajos

Una cola de trabajos almacena los trabajos enviados hasta que el AWS Batch programador los ejecute en los recursos de su entorno informático. Los trabajos se procesan en orden de prioridad dentro de la cola.

Creación de una cola de trabajos

El siguiente comando crea una cola de trabajos con prioridad 900 que utiliza su entorno informático de Fargate.

aws batch create-job-queue \
    --job-queue-name my-fargate-job-queue \
    --state ENABLED \
    --priority 900 \
    --compute-environment-order order=1,computeEnvironment=my-fargate-compute-env

A continuación, se muestra cómo se ve la salida cuando el comando se ejecuta correctamente.

{
    "jobQueueName": "my-fargate-job-queue",
    "jobQueueArn": "arn:aws:batch:us-west-2:123456789012:job-queue/my-fargate-job-queue"
}

Comprobación de que la cola de trabajos esté lista

Compruebe que la cola de trabajos está en el estado ENABLED y lista para aceptar trabajos.

aws batch describe-job-queues \
    --job-queues my-fargate-job-queue \
    --query 'jobQueues[0].state' "ENABLED"

crear una definición de trabajo,

Una definición de trabajo especifica cómo se ejecutan los trabajos, como la imagen de Docker que se va a usar, los requisitos de recursos y otros parámetros. Para Fargate, utilizará los requisitos de recursos en lugar de los parámetros tradicionales de vCPU y memoria.

Creación de la definición de trabajo

El siguiente comando crea una definición de trabajo que ejecuta un comando simple de “Hola, mundo” utilizando la imagen del contenedor de busybox. 123456789012Sustitúyelo por su Cuenta de AWS ID real y sustituya el ejemplo por el Región de AWS suyo propio.

aws batch register-job-definition \
    --job-definition-name my-fargate-job-def \
    --type container \
    --platform-capabilities FARGATE \
    --container-properties '{
        "image": "busybox",
        "resourceRequirements": [
            {"type": "VCPU", "value": "0.25"},
            {"type": "MEMORY", "value": "512"}
        ],
        "command": ["echo", "hello world"],
        "networkConfiguration": {
            "assignPublicIp": "ENABLED"
        },
        "executionRoleArn": "arn:aws:iam::123456789012:role/BatchEcsTaskExecutionRoleTutorial"
    },
{
    "jobDefinitionName": "my-fargate-job-def",
    "jobDefinitionArn": "arn:aws:batch:us-west-2:123456789012:job-definition/my-fargate-job-def:1",
    "revision": 1
}'

La definición del trabajo especifica 0,25 vCPU y 512 MB de memoria, que son los recursos mínimos para una tarea de Fargate. La configuración assignPublicIp está habilitada para que el contenedor pueda extraer la imagen de Busybox de Docker Hub.

Envío y supervisión de un trabajo

Ahora que tiene todos los componentes necesarios, puede enviar un trabajo a la cola y supervisar su progreso.

Envía un trabajo

El siguiente comando envía un trabajo a la cola utilizando la definición de trabajo que ha creado.

aws batch submit-job \
    --job-name my-hello-world-job \
    --job-queue my-fargate-job-queue \
    --job-definition my-fargate-job-def

A continuación, se muestra cómo se ve la salida cuando el comando se ejecuta correctamente.

{
    "jobArn": "arn:aws:batch:us-west-2:123456789012:job/my-hello-world-job",
    "jobName": "my-hello-world-job",
    "jobId": "1509xmpl-4224-4da6-9ba9-1d1acc96431a"
}

Observe el jobId devuelto en la respuesta, ya que lo utilizará para supervisar el progreso del trabajo.

Supervisión del estado de trabajo

Utilice el ID del trabajo para verificar el estado del trabajo. El trabajo progresará a través de diversos estados: SUBMITTED, PENDING, RUNNABLE, STARTING, RUNNING, y finalmente, SUCCEEDED o FAILED.

aws batch describe-jobs --jobs 1509xmpl-4224-4da6-9ba9-1d1acc96431a

A continuación, se muestra cómo se ve la salida cuando el comando se ejecuta correctamente.

{
    "jobs": [
        {
            "jobArn": "arn:aws:batch:us-west-2:123456789012:job/my-hello-world-job",
            "jobName": "my-hello-world-job",
            "jobId": "1509xmpl-4224-4da6-9ba9-1d1acc96431a",
            "jobQueue": "arn:aws:batch:us-west-2:123456789012:job-queue/my-fargate-job-queue",
            "status": "SUCCEEDED",
            "createdAt": 1705161908000,
            "jobDefinition": "arn:aws:batch:us-west-2:123456789012:job-definition/my-fargate-job-def:1"
        }
    ]
}

Cuando se muestra el estado SUCCEEDED, el trabajo se habrá completado correctamente.

Visualización de la salida de un trabajo

Una vez finalizado el trabajo, podrás ver su resultado en Amazon CloudWatch Logs.

Obtención del nombre del flujo de registro

En primer lugar, recupere el nombre del flujo de registro desde los detalles del trabajo. Sustituya el ID de trabajo de ejemplo por el suyo.

aws batch describe-jobs --jobs 1509xmpl-4224-4da6-9ba9-1d1acc96431a \
    --query 'jobs[0].attempts[0].containers[0].logStreamName' \
    --output text

my-fargate-job-def/default/1509xmpl-4224-4da6-9ba9-1d1acc96431a

Visualización de los registros de trabajo

Utilice el nombre del flujo de registro para recuperar el resultado del trabajo desde CloudWatch Logs.

aws logs get-log-events \
    --log-group-name /aws/batch/job \
    --log-stream-name my-fargate-job-def/default/1509xmpl-4224-4da6-9ba9-1d1acc96431a \
    --query 'events[*].message' \
    --output text

La salida muestra “Hola, mundo”, lo que confirma que su trabajo se ha ejecutado correctamente.

Eliminar recursos

Elimine los recursos que haya creado en este tutorial para evitar cargos recurrentes. Debe eliminar los recursos en el orden correcto debido a las dependencias.

Deshabilite y elimine la cola de trabajos

En primer lugar, deshablite la cola de trabajos y, a continuación, elimínela.

aws batch update-job-queue \
    --job-queue my-fargate-job-queue \
    --state DISABLED

aws batch delete-job-queue \
    --job-queue my-fargate-job-queue

Deshabilite y elimine el entorno de computación

Una vez eliminada la cola de trabajos, deshabilite y elimine el entorno de computación.

aws batch update-compute-environment \
    --compute-environment my-fargate-compute-env \
    --state DISABLED

aws batch delete-compute-environment \
    --compute-environment my-fargate-compute-env

Elimine el rol de IAM

Elimine la asociación de la política y elimine el rol de IAM.

aws iam detach-role-policy \
    --role-name BatchEcsTaskExecutionRoleTutorial \
    --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
        

aws iam delete-role \
    --role-name BatchEcsTaskExecutionRoleTutorial

Elimine los archivos temporales

Elimine el archivo de política de confianza que creó.

rm batch-execution-role-trust-policy.json

Todos los recursos se han eliminado correctamente.

Paso a la producción

Este tutorial está diseñado para ayudarle a entender cómo AWS Batch funciona con Fargate. Para las implementaciones de producción, tenga en cuenta los siguientes requisitos adicionales:

Para obtener una guía completa sobre arquitecturas listas para producción, consulte Maro de AWS Well-Architected y AWS Security Best Practices.

Siguientes pasos

Ahora que ha completado este tutorial, puede explorar AWS Batch funciones más avanzadas: