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 con AWS Batch los tutoriales
<a name="Batch_GetStarted"></a>

Puede utilizar el asistente AWS Batch de primera ejecución para empezar rápidamente. AWS Batch Tras completar los requisitos previos, puede utilizar el asistente de primera ejecución para crear un entorno de computación, una definición de trabajos y una cola de trabajos. 

También puede enviar un ejemplo de trabajo de «Hello World» mediante el asistente de AWS Batch primera ejecución para probar la configuración. Si ya tiene una imagen de Docker con la que quiere lanzarla AWS Batch, puede utilizarla para crear una definición de trabajo. 

Después, puedes usar el asistente de AWS Batch primera ejecución para crear un entorno informático, una cola de trabajos y enviar un ejemplo de trabajo de *Hello* World. 

# Introducción a la orquestación de Amazon EC2 con el asistente
<a name="getting-started-ec2"></a>

Amazon Elastic Compute Cloud (Amazon EC2) proporciona capacidad de computación escalable y segura en Nube de AWS. El uso de Amazon EC2 elimina la necesidad de invertir inicialmente en hardware, de manera que puede desarrollar e implementar aplicaciones en menos tiempo. 

Puede usar Amazon EC2 para lanzar tantos servidores virtuales como necesite, configurar la seguridad y las redes, y administrar el almacenamiento. Amazon EC2 le permite escalar hacia arriba o hacia abajo para controlar los cambios en los requisitos o los picos de popularidad, con lo que se reduce la necesidad de prever el tráfico.

## Descripción general de
<a name="getting-started-ec2-context"></a>

En este tutorial se muestra cómo realizar la configuración AWS Batch con el asistente para configurar Amazon EC2 y ejecutarlo. `Hello World` 

**Público objetivo**  
Este tutorial está diseñado para los administradores y desarrolladores de sistemas responsables de la configuración, las pruebas y la implementación de AWS Batch.

**Características utilizadas**  
En este tutorial se muestra cómo utilizar el asistente de AWS Batch consola para:  
+ crear y configurar un entorno de computación de Amazon EC2,
+ crear una cola de trabajos,
+ crear una definición de trabajo,
+ crear y enviar un flujo de trabajo para ejecutarlo,
+ Vea el resultado del trabajo en CloudWatch

**Tiempo requerido**  
Completar este tutorial debería tardar entre 10 y 15 minutos.

**Restricciones regionales**  
No hay restricciones regionales o de país asociadas al uso de esta solución.

**Costos de uso de recursos**  
La creación de una AWS cuenta es gratuita. Sin embargo, mediante la implementación de esta solución, es posible que incurra en algunos o todos los costos que se enumeran en la siguiente tabla.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/batch/latest/userguide/getting-started-ec2.html)

## Requisitos previos
<a name="getting-started-ec2-prerequisite"></a>

Antes de empezar:
+ Crea una Cuenta de AWS si no tienes una.
+ Cree la [instancia del rol `ecsInstanceRole`](batch-check-ecsinstancerole.md).

## Paso 1: Crear un entorno de computación
<a name="create-ce-1"></a>

**importante**  
Para comenzar de la manera más sencilla y rápida posible, en este tutorial se incluirán los pasos con la configuración predeterminada. Antes de crear para su uso en producción, recomendamos que conozca toda la configuración e implemente la configuración que satisfaga sus requisitos.

Para crear un entorno de computación para una orquestación de Amazon EC2, haga lo siguiente:

1. Abra el [Asistente de primer uso de la consola AWS Batch](https://console.aws.amazon.com/batch/home#wizard).

1. En **Configuración el tipo de orquestación y trabajo**, seleccione **Amazon Elastic Compute Cloud (Amazon EC2)**.

1. Elija **Siguiente**.

1. En la sección de **Configuración de entorno de computación** de **Nombre**, especifique un nombre único para su entorno de computación. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1). 

1. En **Rol de instancia**, elija un rol de instancia existente que tenga asociados los permisos de IAM necesarios. Esta función de instancia permite a las instancias de contenedor de Amazon ECS de su entorno informático realizar llamadas a las operaciones de AWS API requeridas. Para obtener más información, consulte [Rol de instancia de Amazon ECS](instance_IAM_role.md). 

   El nombre predeterminado de la **instancia del rol** es `ecsInstanceRole`. 

1. En **Configuración de instancia**, puede dejar la configuración predeterminada.

1. En **Configuración de red**, utilice su VPC predeterminada para la Región de AWS.

1. Elija **Siguiente**.

## Paso 2: Crear una cola de trabajo
<a name="create-job-queue-1"></a>

Una cola de trabajos almacena los trabajos enviados hasta que el AWS Batch programador ejecute el trabajo en un recurso de su entorno informático. Para obtener más información, consulte [Colas de trabajos](job_queues.md)

Para crear una cola de trabajos para una orquestación de Amazon EC2, haga lo siguiente:

1. En **Configuración de la cola de trabajos**, **Nombre**, especifique un nombre único para la cola de trabajos. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1). 

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 3: Crea una definición de trabajo
<a name="create-job-definition-1"></a>

AWS Batch las definiciones de trabajos especifican cómo se van a ejecutar los trabajos. Si bien cada trabajo debe hacer referencia a una definición de trabajo, muchos de los parámetros especificados en dicha definición pueden ser ignorados en tiempo de ejecución. 

Para crear la definición de trabajo:

1. En **Crear una definición de trabajo**

   1. en **Nombre**, escriba un nombre único para su cola de trabajos. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1).

   1. En **Comando: *optional***, puede cambiar `hello world` a un mensaje personalizado o dejarlo como está.

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 4: Crear un trabajo
<a name="create-job-1"></a>

Para crear un trabajo, haga lo siguiente:

1. En **Configuración de trabajo**, especifique un **Nombre** único para el trabajo. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1).

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 5: Revisar y crear
<a name="review-create-1"></a>

En la página **Revisar y crear**, revise los pasos de configuración. Si necesita realizar cambios, elija **Editar**. Cuando haya terminado, seleccione **Creación de recursos**.

1. En **Revisar y crear**, seleccione **Crear recursos**.

1. Se abre una ventana al AWS Batch principio para asignar los recursos. Una vez completado, seleccione **Ir al panel**. En el panel, verá todos los recursos que tiene asignados y también que el trabajo se encuentra en el estado `Runnable`. Su tarea está programada para ejecutarse y se completará en un plazo de 2 a 3 minutos.

## Paso 6: Ver la salida de la tarea
<a name="view-job-1"></a>

Para ver la salida del trabajo, realice lo siguiente:

1. En el panel de navegación, seleccione **Trabajos**. 

1. En el menú desplegable de **Colas de trabajo**, elija la cola de trabajos que creó para el tutorial.

1. La tabla **Trabajos** muestra todos los trabajos y su estado actual. Una vez que el **Estado** del trabajo sea **Correcto**, seleccione el **Nombre** del trabajo para consultar sus detalles. 

1. En el panel **Detalles**, elija el **Nombre del flujo de registro**. Se abrirá la CloudWatch consola del Job y debería haber un evento con el **Mensaje** de `hello world` o su mensaje personalizado.

## Paso 7: Eliminar los recursos del tutorial
<a name="delete-1"></a>

Se le cobrará por la instancia de Amazon EC2 mientras esté habilitada. Puede eliminar la instancia para dejar de generar cargos.

Para eliminar los recursos que usted creó, haga lo que se indica a continuación:

1. En el panel de navegación, elija **Cola de trabajos**. 

1. En la tabla **Cola de trabajos**, elija la cola de trabajos que creó para el tutorial.

1. Elija **Deshabilitar**. Una vez que el **Estado** de la cola de trabajos esté deshabilitado, puede elegir **Eliminar**.

1. Una vez se elimine la cola de trabajos, en el panel de navegación, elija **Entornos de computación**.

1. Elija el entorno de computación que creó para este tutorial y, a continuación, elija **Deshabilitar**. El entorno de computación puede tardar entre 1 y 2 minutos en terminar de deshabilitarse.

1. Una vez que el **Estado** del entorno de computación esté deshabilitado, seleccione **Eliminar**. La eliminación del entorno de computación puede tardar entre 1 y 2 minutos.

## Recursos adicionales
<a name="procedure_additional_resources"></a>

Después de completar el tutorial, recomendamos consultar alguno de los siguientes temas:
+ Explore los componentes AWS Batch principales. Para obtener más información, consulte [Componentes de AWS Batch](batch_components.md).
+ Obtenga más información sobre los diferentes [entornos de computación](compute_environments.md) disponibles en AWS Batch.
+ Obtenga más información sobre las [colas de trabajos](job_queues.md) y sus diferentes opciones de programación.
+ Obtenga más información sobre las [definiciones de trabajos](job_definitions.md) y las diferentes opciones de configuración.
+ Obtenga más información sobre los distintos tipos de [trabajos](jobs.md).

# Introducción a la orquestación AWS Batch de Fargate con el Mago
<a name="getting-started-fargate"></a>

AWS Fargate lanza y escala el cómputo para que se ajuste perfectamente a los requisitos de recursos que especifique para el contenedor. Con Fargate, no es necesario aprovisionar en exceso los servidores ni pagar por ellos. Para obtener más información, consulte [Fargate](https://docs.aws.amazon.com//batch/latest/userguide/fargate.html#when-to-use-fargate).

## Descripción general de
<a name="getting-started-fargate-contextual"></a>

En este tutorial se muestra cómo realizar la configuración AWS Batch con el asistente para configurar AWS Fargate y ejecutarlo. `Hello World` 

**Público al que va dirigido**  
Este tutorial está diseñado para los administradores y desarrolladores de sistemas responsables de la configuración, las pruebas y la implementación de AWS Batch.

**Características utilizadas**  
En este tutorial se muestra cómo utilizar el asistente de AWS Batch consola para:  
+ Cree y configure un entorno de AWS cómputo Fargate
+ crear una cola de trabajos,
+ crear una definición de trabajo,
+ crear y enviar un flujo de trabajo para ejecutarlo,
+ Vea el resultado del trabajo en CloudWatch

**Tiempo requerido**  
Completar este tutorial debería tardar entre 10 y 15 minutos.

**Restricciones regionales**  
No hay restricciones regionales o de país asociadas al uso de esta solución.

**Costos de uso de recursos**  
La creación de una AWS cuenta no conlleva ningún cargo. Sin embargo, mediante la implementación de esta solución, es posible que incurra en algunos o todos los costos que se enumeran en la siguiente tabla.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/batch/latest/userguide/getting-started-fargate.html)

## Requisitos previos
<a name="getting-started-fargate-prerequisite"></a>

Antes de empezar: 
+ Crea una Cuenta de AWS si no tienes una.
+ cree el rol de ejecución de tareas. Si aún no ha creado el [rol de ejecución de tareas](create-execution-role.md), puede crearlo como parte de este tutorial.

## Paso 1: Crear un entorno de computación
<a name="create-ce-2"></a>

**importante**  
Para comenzar de la manera más sencilla y rápida posible, en este tutorial se incluirán los pasos con la configuración predeterminada. Antes de crear para su uso en producción, recomendamos que conozca toda la configuración e implemente la configuración que satisfaga sus requisitos.

Para crear un entorno de computación para una orquestación de Fargate, haga lo siguiente:

1. Abra el [Asistente de primer uso de la consola AWS Batch](https://console.aws.amazon.com/batch/home#wizard).

1. En **Configurar trabajo y tipo de orquestación**, elija **Fargate**.

1. Elija **Siguiente**.

1. En la sección de **Configuración de entorno de computación** de **Nombre**, especifique un nombre único para su entorno de computación. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1).

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 2: Crear una cola de trabajo
<a name="create-job-queue-2"></a>

Una cola de trabajos almacena los trabajos enviados hasta que el AWS Batch programador ejecute el trabajo en un recurso de su entorno informático. Para crear una cola de trabajos:

Para crear una cola de trabajos para una orquestación de Fargate, haga lo siguiente:

1. En la sección de **configuración de la cola de trabajos** de **Nombre**, especifique un nombre único para la cola de trabajos. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1).

1. En **Prioridad**, ingrese 900 para la cola de trabajos. 

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 3: Crear una definición de trabajo
<a name="create-job-definition-2"></a>

Para crear la definición de trabajo:

1. En la sección de **Configuración general**:

   1. En la sección **de configuración general** de **Nombre**, especifique un nombre único para la definición de su trabajo. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1).

1. En la sección de **Configuración de la plataforma Fargate**:

   1. Active **Asignar IP pública** para asignar una dirección IP pública. Necesita una IP pública para descargar la imagen del contenedor, a menos que haya configurado un repositorio de imágenes privado.

   1. Para **la función de ejecución**, elija una función de ejecución de tareas que permita a los agentes de Amazon Elastic Container Service (Amazon ECS) AWS realizar llamadas en su nombre. Elija **ecsTaskExecutionRol** o **BatchEcsTaskExecutionRole**. 

      Para crear el **Rol de ejecución**, seleccione **Crear un rol de ejecución**. En el modal **Crear un rol de IAM**, seleccione **Crear rol de IAM**. 

      1. La consola de IAM ya tiene la configuración de permisos configurada para crear el rol de ejecución. 

      1. En **Tipo de entidad de confianza**, verifique que el **Servicio de AWS ** esté seleccionado.

      1. En **Caso de servicio o usuario**, compruebe que **Elastic Container Service** esté seleccionado.

      1. Elija **Siguiente**.

      1. Para **las políticas de permisos**, verifica que **Amazon ECSTask ExecutionRolePolicy** esté seleccionado.

      1. Elija **Siguiente**.

      1. **En Nombre, revise y cree,** compruebe que el nombre del rol es **BatchEcsTaskExecutionRole**. 

      1. Elija **Crear rol**.

      1. En la AWS Batch consola, pulse el botón de actualización situado junto a la **función de ejecución**. Elija el rol **BatchEcsTaskExecutionRole**de ejecución.

1. En la sección **Configuración del contenedor**:

   1. En **Comando**, puede cambiar `hello world` con un mensaje personalizado o dejarlo como está.

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 4: Crear un trabajo
<a name="create-job-2"></a>

Para crear un trabajo de Fargate, haga lo siguiente:

1. En **Configuración de trabajo**, especifique un **Nombre** único para el trabajo. El nombre puede tener una longitud máxima de 128 caracteres. Puede contener letras mayúsculas y minúsculas, números, guiones (-) y guiones bajos (\$1).

1. Puede dejar el valor predeterminado en todas las demás opciones de configuración.

1. Elija **Siguiente**.

## Paso 5: Revisar y crear
<a name="review-create-2"></a>

En la página **Revisar y crear**, revise los pasos de configuración. Si necesita realizar cambios, elija **Editar**. Cuando haya terminado, seleccione **Creación de recursos**.

## Paso 6: Ver la salida de la tarea
<a name="view-job-fargate"></a>

Para ver la salida del trabajo, realice lo siguiente:

1. En el panel de navegación, seleccione **Trabajos**. 

1. En el menú desplegable de **Colas de trabajo**, elija la cola de trabajos que creó para el tutorial.

1. La tabla **Trabajos** muestra todos los trabajos y su estado actual. Una vez que el **Estado** del trabajo sea **Correcto**, seleccione el **Nombre** del trabajo para consultar sus detalles. 

1. En el panel **Detalles**, elija el **Nombre del flujo de registro**. Se abrirá la CloudWatch consola del Job y debería haber un evento con el **Mensaje** de `hello world` o su mensaje personalizado.

## Paso 7: Eliminar los recursos del tutorial
<a name="delete-fargate"></a>

Se le cobrará por la instancia de Amazon EC2 mientras esté habilitada. Puede eliminar la instancia para dejar de generar cargos.

Para eliminar los recursos que usted creó, haga lo que se indica a continuación:

1. En el panel de navegación, elija **Cola de trabajos**. 

1. En la tabla **Cola de trabajos**, elija la cola de trabajos que creó para el tutorial.

1. Elija **Deshabilitar**. Una vez que el **Estado** de la cola de trabajos esté deshabilitado, puede elegir **Eliminar**.

1. Una vez se elimine la cola de trabajos, en el panel de navegación, elija **Entornos de computación**.

1. Elija el entorno de computación que creó para este tutorial y, a continuación, elija **Deshabilitar**. El entorno de computación puede tardar entre 1 y 2 minutos en terminar de deshabilitarse.

1. Una vez que el **Estado** del entorno de computación esté deshabilitado, seleccione **Eliminar**. La eliminación del entorno de computación puede tardar entre 1 y 2 minutos.

## Recursos adicionales
<a name="fargate-additional-resources"></a>

Después de completar el tutorial, recomendamos consultar alguno de los siguientes temas:
+ Obtenga más información sobre las [prácticas recomendadas](best-practices.md).
+ Explore los componentes AWS Batch principales. Para obtener más información, consulte [Componentes de AWS Batch](batch_components.md).
+ Obtenga más información sobre los diferentes [entornos de computación](compute_environments.md) disponibles en AWS Batch.
+ Obtenga más información sobre las [colas de trabajos](job_queues.md) y sus diferentes opciones de programación.
+ Obtenga más información sobre las [definiciones de trabajos](job_definitions.md) y las diferentes opciones de configuración.
+ Obtenga más información sobre los distintos tipos de [trabajos](jobs.md).

# Cómo empezar a AWS Batch usar Fargate el AWS CLI
<a name="getting-started-with-fargate-using-the-aws-cli"></a>

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.

**Topics**
+ [Requisitos previos](#prerequisites)
+ [Creación de un rol de ejecución de IAM](#tutorial-fargate-using-the-aws-cli-create-an-iam-execution-role)
+ [Creación de un entorno de computación](#create-a-compute-environment)
+ [Cree una cola de trabajos](#cli-create-a-job-queue)
+ [crear una definición de trabajo,](#cli-create-a-job-definition)
+ [Envío y supervisión de un trabajo](#cli-submit-and-monitor-a-job)
+ [Visualización de la salida de un trabajo](#cli-view-job-output)
+ [Eliminar recursos](#cli-clean-up-resources)
+ [Paso a la producción](#cli-going-to-production)
+ [Siguientes pasos](#cli-next-steps)

## Requisitos previos
<a name="prerequisites"></a>

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

1. El AWS CLI. Si necesita instalarla, siga la [guía de instalación de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). También puede [usar AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), que incluye el AWS CLI.

1. Lo configuró AWS CLI con las credenciales adecuadas. Si aún no ha configurado sus credenciales, ejecute `aws configure`

1. Conocimiento básico de las interfaces de línea de comandos y los conceptos de contenedorización

1. [¿Cómo AWS Batch funciona con IAM](security_iam_service-with-iam.md)para crear y gestionar AWS Batch recursos, funciones de IAM y recursos de VPC en su. Cuenta de AWS

1. Un ID de subred y un ID de grupo de seguridad de una VPC de su. Cuenta de AWS Si no dispone de una VPC, puede [crear una](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc.html). *Para obtener más información sobre cómo usar el recurso AWS CLI para recuperar estos recursos IDs, consulte [describe-subnets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-subnets.html) y en la Referencia de comandos. [describe-security-groups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-groups.html)AWS CLI *

**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](https://aws.amazon.com/fargate/pricing/).

## Creación de un rol de ejecución de IAM
<a name="tutorial-fargate-using-the-aws-cli-create-an-iam-execution-role"></a>

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
<a name="create-a-compute-environment"></a>

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](#prerequisites)

```
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
<a name="cli-create-a-job-queue"></a>

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,
<a name="cli-create-a-job-definition"></a>

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. `123456789012`Sustitú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
<a name="cli-submit-and-monitor-a-job"></a>

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
<a name="cli-view-job-output"></a>

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
<a name="cli-clean-up-resources"></a>

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
<a name="cli-going-to-production"></a>

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:

**Consideraciones de seguridad:**
+ Crear grupos de seguridad dedicados con un acceso mínimo obligatorio en lugar de utilizar los grupos de seguridad predeterminados.
+ Utilizar subredes privadas con la puerta de enlace NAT en lugar de asignar direcciones IP públicas para los contenedores.
+ Almacenar imágenes de contenedor en Amazon ECR en lugar de usar repositorios públicos.
+ Implemente puntos finales de VPC para la comunicación del AWS servicio a fin de evitar el tráfico de Internet

**Consideraciones de arquitectura:**
+ Desplegar en varias zonas de disponibilidad para lograr una alta disponibilida.
+ Implementar estrategias de reintentos de tareas y colas de mensajes fallidos para gestionar los errores.
+ Utilizar varias colas de trabajos con diferentes prioridades para la administración de la carga de trabajo.
+ Configurar políticas de escalado automático según la profundidad de las colas y la utilización de los recursos.
+ Implementar la supervisión y las alertas en caso de que se produzcan errores en los trabajos y se utilicen los recursos.

**Consideraciones operativas:**
+ Configure CloudWatch paneles y alarmas para la supervisión
+ Implementar registros y registros de auditoría adecuados.
+ Utilice CloudFormation o la AWS CDK infraestructura como código
+ Establecer procedimientos de copia de seguridad y recuperación ante desastres.

Para obtener una guía completa sobre arquitecturas listas para producción, consulte [Maro de AWS Well-Architected](https://aws.amazon.com/architecture/well-architected/) y [AWS Security Best Practices](https://aws.amazon.com/architecture/security-identity-compliance/).

## Siguientes pasos
<a name="cli-next-steps"></a>

Ahora que ha completado este tutorial, puede explorar AWS Batch funciones más avanzadas:
+ [Colas de trabajos](job_queues.md): obtenga información sobre la programación de colas de trabajos y la administración de prioridades
+ [Definiciones de trabajo](job_definitions.md): conozca las configuraciones avanzadas de definición de trabajos, como las variables de entorno, los volúmenes y las estrategias de reintento
+ [Entornos informáticos para AWS Batch](compute_environments.md): comprenda los diferentes tipos de entornos de computación y las opciones de escalado
+ [Trabajos paralelos de varios nodos](multi-node-parallel-jobs.md): ejecute trabajos que abarquen varios nodos de computación
+ [Trabajos de matrices](array_jobs.md): envíe un gran número de trabajos similares de manera eficiente
+ [Prácticas recomendadas de AWS Batch](best-practices.md): aprenda técnicas de optimización para las cargas de trabajo de producción

# Cómo empezar con AWS Batch Amazon EKS
<a name="getting-started-eks"></a>

AWS Batch on Amazon EKS es un servicio gestionado para programar y escalar cargas de trabajo por lotes en clústeres de Amazon EKS existentes. AWS Batch no crea, administra ni realiza operaciones del ciclo de vida de sus clústeres de Amazon EKS en su nombre. AWS Batch la orquestación amplía y reduce los nodos administrados por dichos nodos AWS Batch y los ejecuta en ellos.

AWS Batch no afecta a los nodos, ni a los grupos de nodos con escalado automático ni a los ciclos de vida de los pods que no estén asociados a los entornos AWS Batch informáticos de su clúster de Amazon EKS. AWS Batch Para funcionar de forma eficaz, su [función vinculada a un servicio](using-service-linked-roles.md) necesita permisos de control Kubernetes de acceso basado en funciones (RBAC) en su clúster Amazon EKS existente. Para obtener más información, consulte [Utilización de la autorización de RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) en la *documentación Kubernetes*.

AWS Batch requiere un espacio de Kubernetes nombres en el que pueda clasificar los pods como trabajos. AWS Batch Recomendamos un espacio de nombres dedicado para aislar los AWS Batch pods de las demás cargas de trabajo del clúster.

Una vez AWS Batch que se le haya otorgado acceso a RBAC y se haya establecido un espacio de nombres, puede asociar ese clúster de Amazon EKS a un entorno AWS Batch informático mediante la operación de API. [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html) Se puede asociar una cola de trabajos a este nuevo entorno informático de Amazon EKS. AWS Batch los trabajos se envían a la cola de trabajos en función de una definición de trabajo de Amazon EKS mediante la operación de [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)API. AWS Batch a continuación, lanza los nodos AWS Batch gestionados y coloca los trabajos de la cola de trabajos en forma de Kubernetes pods en el clúster EKS asociado a un entorno AWS Batch informático.

En las siguientes secciones se explica cómo configurar AWS Batch Amazon EKS.

**Contents**
+ [Descripción general de](#getting-started-eks-context)
+ [Requisitos previos](#getting-started-eks-prerequisites)
+ [Paso 1: Cree su clúster de Amazon EKS para AWS Batch](#getting-started-eks-step-0)
+ [Paso 2: Prepare el clúster de Amazon EKS para AWS Batch](#getting-started-eks-step-1)
+ [Paso 3: Crear un entorno de computación de Amazon EKS](#getting-started-eks-step-2)
+ [Paso 4: Cree una cola de trabajos y adjunte el entorno informático](#getting-started-eks-step-3)
+ [Paso 5: Crear una definición de trabajo](#getting-started-eks-step-4)
+ [Paso 6: Presentar un trabajo](#getting-started-eks-step-5)
+ [Paso 7: Ver la salida del trabajo](#getting-started-eks-step-7)
+ [Paso 8: (opcional) Enviar un trabajo con anulaciones](#getting-started-eks-step-6)
+ [Paso 9: Eliminar los recursos del tutorial](#getting-started-eks-step-8)
+ [Recursos adicionales](#getting-started-eks-additional-resources)

## Descripción general de
<a name="getting-started-eks-context"></a>

En este tutorial se muestra cómo realizar la configuración AWS Batch con Amazon EKS mediante AWS CLI, `kubectl` y`eksctl`. 

**Público al que va dirigido**  
Este tutorial está diseñado para los administradores y desarrolladores de sistemas responsables de la configuración, las pruebas y la implementación de AWS Batch.

**Características utilizadas**  
En este tutorial se muestra cómo utilizar el AWS CLI, para:  
+ crear y configurar un entorno de computación de Amazon EKS,
+ crear una cola de trabajos,
+ crear una definición de trabajo,
+ crear y enviar un flujo de trabajo para ejecutarlo,
+ enviar un trabajo con anulaciones.

**Tiempo requerido**  
Completar este tutorial debería tardar entre 30 y 40 minutos.

**Restricciones regionales**  
No hay restricciones regionales o de país asociadas al uso de esta solución.

**Costos de uso de recursos**  
La creación de una AWS cuenta no conlleva ningún cargo. Sin embargo, mediante la implementación de esta solución, es posible que incurra en algunos o todos los costos que se enumeran en la siguiente tabla.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/batch/latest/userguide/getting-started-eks.html)

## Requisitos previos
<a name="getting-started-eks-prerequisites"></a>

Antes de comenzar este tutorial, debe instalar y configurar las siguientes herramientas y recursos que necesita para crear y administrar tanto AWS Batch los recursos de Amazon EKS.
+ **AWS CLI**: una herramienta de línea de comandos para trabajar con servicios de AWS , incluido Amazon EKS. Esta guía requiere que utilices la versión 2.8.6 o posterior o la 1.26.0 o posterior. Para obtener más información, consulte [Instalar, actualizar y desinstalar la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) en la *Guía del usuario de AWS Command Line Interface *. Tras instalarlo AWS CLI, le recomendamos que también lo configure. Para obtener más información, consulte [Configuración rápida con `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) en la *Guía del usuario de AWS Command Line Interface *.
+ **`kubectl`**: una herramienta de línea de comandos para trabajar con clústeres de Kubernetes. Esta guía requiere que utilice la versión `1.23` o una posterior. Para obtener más información, consulte [Instalación o actualización de `kubectl`](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) en la *Guía del usuario de Amazon EKS*.
+ **`eksctl`**: una herramienta de línea de comandos para trabajar con clústeres de Amazon EKS que automatiza varias tareas individuales. Esta guía requiere que utilice la versión `0.115.0` o una posterior. Para obtener más información, consulte [Instalación o actualización de `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) en la **Guía del usuario de Amazon EKS**.
+ **Permisos de IAM necesarios**: el responsable de seguridad de IAM que utilice debe tener permisos para trabajar con las funciones de IAM de Amazon EKS y las funciones vinculadas a servicios CloudFormation, así como con una VPC y los recursos relacionados. Para obtener más información, consulte [Acciones, recursos y claves de condición de Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html) y [Uso de roles vinculados a servicios](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) en la *Guía del usuario de IAM*. Debe completar todos los pasos de esta guía como el mismo usuario.
+ **Permisos**: los usuarios que llamen a la operación de [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html)API para crear un entorno de cómputo que utilice los recursos de Amazon EKS necesitan permisos para la operación de `eks:DescribeCluster` API. 
+ **Cuenta de AWS número**: necesita saber su Cuenta de AWS ID. Siga las instrucciones que se indican en [Visualización de su ID de Cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html).
+ **(Opcional) CloudWatch**: para examinar los detalles de [(opcional) Enviar un trabajo con anulaciones](#getting-started-eks-step-6), se debe configurar el registro. Para obtener más información, consulte [Utilice CloudWatch los registros para supervisar AWS Batch los trabajos de Amazon EKS](batch-eks-cloudwatch-logs.md).

## Paso 1: Cree su clúster de Amazon EKS para AWS Batch
<a name="getting-started-eks-step-0"></a>

**importante**  
Para comenzar de la manera más sencilla y rápida posible, en este tutorial se incluirán los pasos con la configuración predeterminada. Antes de crear para su uso en producción, recomendamos que conozca toda la configuración e implemente la configuración que satisfaga sus requisitos.

Tras haber instalado los requisitos previos, debe crear su clúster con `eksctl`. Crear el clúster puede tardar entre 10 y 15 minutos. 

```
$  eksctl create cluster --name my-cluster-name --region region-code
```

Sustituya en el comando anterior:
+ *my-cluster-name*Sustitúyalo por el nombre que desee usar para su clúster. 
+ *region-code*Sustitúyalo por el Región de AWS para crear el clúster, por ejemplo`us-west-2`.

El nombre y la región del clúster serán necesarios en otro momento para este tutorial.

## Paso 2: Prepare el clúster de Amazon EKS para AWS Batch
<a name="getting-started-eks-step-1"></a>

Todos los pasos son obligatorios.

1. 

**Cree un espacio de nombres dedicado a los trabajos AWS Batch**

   Se utiliza `kubectl` para crear un nuevo espacio de nombres.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl create -f -
   {
     "apiVersion": "v1",
     "kind": "Namespace",
     "metadata": {
       "name": "${namespace}",
       "labels": {
         "name": "${namespace}"
       }
     }
   }
   EOF
   ```

   Salida:

   ```
   namespace/my-aws-batch-namespace created
   ```

1. 

**Habilite el acceso a través del control de acceso basado en roles (RBAC)**

   `kubectl`Utilícelo para crear un Kubernetes rol para el clúster que AWS Batch permita vigilar los nodos y los pods y vincular el rol. Debe hacerlo una vez para cada clúster de EKS.

   ```
   $ cat - <<EOF | kubectl apply -f -
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: aws-batch-cluster-role
   rules:
     - apiGroups: [""]
       resources: ["namespaces"]
       verbs: ["get"]
     - apiGroups: [""]
       resources: ["nodes"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["events"]
       verbs: ["list"]
     - apiGroups: [""]
       resources: ["configmaps"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["apps"]
       resources: ["daemonsets", "deployments", "statefulsets", "replicasets"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["clusterroles", "clusterrolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: aws-batch-cluster-role-binding
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: aws-batch-cluster-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Salida:

   ```
   clusterrole.rbac.authorization.k8s.io/aws-batch-cluster-role created
   clusterrolebinding.rbac.authorization.k8s.io/aws-batch-cluster-role-binding created
   ```

1. Cree un Kubernetes rol dentro del espacio de nombres para administrar los pods durante AWS Batch todo el ciclo de vida y vincúlelo. Debe hacerlo una vez para cada espacio de nombres único.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl apply -f - --namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: aws-batch-compute-environment-role
     namespace: ${namespace}
   rules:
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["create", "get", "list", "watch", "delete", "patch"]
     - apiGroups: [""]
       resources: ["serviceaccounts"]
       verbs: ["get", "list"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["roles", "rolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: aws-batch-compute-environment-role-binding
     namespace: ${namespace}
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: Role
     name: aws-batch-compute-environment-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Salida:

   ```
   role.rbac.authorization.k8s.io/aws-batch-compute-environment-role created
   rolebinding.rbac.authorization.k8s.io/aws-batch-compute-environment-role-binding created
   ```

1. Actualice el Kubernetes `aws-auth` mapa de configuración para asignar los permisos RBAC anteriores al rol vinculado al servicio. AWS Batch 

   Reemplace en el siguiente comando:
   + Reemplace *<your-account-number>* por el ID de su  Cuenta de AWS . 

   ```
   $ eksctl create iamidentitymapping \
       --cluster my-cluster-name \
       --arn "arn:aws:iam::<your-account-number>:role/AWSServiceRoleForBatch" \
       --username aws-batch
   ```

   Salida:

   ```
   2022-10-25 20:19:57 [ℹ]  adding identity "arn:aws:iam::<your-account-number>:role/AWSServiceRoleForBatch" to auth ConfigMap
   ```
**nota**  
La ruta `aws-service-role/batch.amazonaws.com/` se ha eliminado del ARN del rol vinculado a un servicio. Esto se debe a un problema con el mapa de configuración de `aws-auth`. Para obtener más información, consulte [Roles con rutas que no funcionan cuando la ruta está incluida en su ARN en el aws-authconfigmap](https://github.com/kubernetes-sigs/aws-iam-authenticator/issues/268).

## Paso 3: Crear un entorno de computación de Amazon EKS
<a name="getting-started-eks-step-2"></a>

AWS Batch los entornos informáticos definen los parámetros de los recursos informáticos para satisfacer sus necesidades de carga de trabajo por lotes. En un entorno informático gestionado, le AWS Batch ayuda a gestionar la capacidad y los tipos de instancia de los recursos informáticos (Kubernetesnodos) de su clúster de Amazon EKS. Se basa en la especificación de recursos de computación que se define al crear el entorno de computación. Puede utilizar instancias bajo demanda EC2 o instancias de spot EC2.

Ahora que el rol **AWSServiceRoleForBatch**vinculado al servicio tiene acceso a su clúster de Amazon EKS, puede crear AWS Batch recursos. En primer lugar, cree un entorno de computación que apunte a su clúster de Amazon EKS.
+ En `subnets` ejecute `eksctl get cluster my-cluster-name` para obtener las subredes que el clúster utilizó. 
+ En el parámetro `securityGroupIds`, puede utilizar el mismo grupo de seguridad que utiliza el clúster de Amazon EKS. Este comando recupera el ID del grupo de seguridad del clúster.

  ```
  $ aws eks describe-cluster \
      --name my-cluster-name \
      --query cluster.resourcesVpcConfig.clusterSecurityGroupId
  ```
+ El `instanceRole` se creará con la formación del clúster. Si desea encontrar la lista `instanceRole` de todas las entidades que utilizan la política `AmazonEKSWorkerNodePolicy`: 

  ```
  $  aws iam list-entities-for-policy --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
  ```

  El nombre del rol de política contiene el nombre del clúster que se creó en `eksctl-my-cluster-name-nodegroup-example`. 

  Ejecute el siguiente comando para buscar el ARN de `instanceRole`:

  ```
  $  aws iam list-instance-profiles-for-role --role-name eksctl-my-cluster-name-nodegroup-example        
  ```

  Salida:

  ```
  INSTANCEPROFILES        arn:aws:iam::<your-account-number>:instance-profile/eks-04cb2200-94b9-c297-8dbe-87f12example
  ```

  Para obtener más información, consulte [Crear el rol de IAM de nodo de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html#create-worker-node-role) y [Habilitar el acceso de entidad principal para el clúster de IAM](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) en la *Guía del usuario de Amazon EKS*. Si utiliza redes de pod, consulte [Configuración del complemento de CNI de Amazon VPC de Kubernetes para utilizar roles de IAM en las cuentas de servicio](https://docs.aws.amazon.com/eks/latest/userguide/cni-iam-role.html) en la **Guía del usuario de Amazon EKS**.

```
$ cat <<EOF > ./batch-eks-compute-environment.json
{
  "computeEnvironmentName": "My-Eks-CE1",
  "type": "MANAGED",
  "state": "ENABLED",
  "eksConfiguration": {
    "eksClusterArn": "arn:aws:eks:region-code:your-account-number:cluster/my-cluster-name",
    "kubernetesNamespace": "my-aws-batch-namespace"
  },
  "computeResources": {
    "type": "EC2",
    "allocationStrategy": "BEST_FIT_PROGRESSIVE",
    "minvCpus": 0,
    "maxvCpus": 128,
    "instanceTypes": [
        "m5"
    ],
    "subnets": [
        "<eks-cluster-subnets-with-access-to-internet-for-image-pull>"
    ],
    "securityGroupIds": [
        "<eks-cluster-sg>"
    ],
    "instanceRole": "<eks-instance-profile>"
  }
}
EOF
```

```
$ aws batch create-compute-environment --cli-input-json file://./batch-eks-compute-environment.json
```

**Notas**
+ El mantenimiento de un entorno de computación de Amazon EKS es una responsabilidad compartida. Para obtener más información, consulte [Responsabilidad compartida de los nodos Kubernetes](eks-ce-shared-responsibility.md).

## Paso 4: Cree una cola de trabajos y adjunte el entorno informático
<a name="getting-started-eks-step-3"></a>

**importante**  
Es importante confirmar que el entorno de computación está en buen estado antes de continuar. Para ello, se puede utilizar la operación de la [DescribeComputeEnvironments](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeComputeEnvironments.html)API.  

```
$ aws batch describe-compute-environments --compute-environments My-Eks-CE1
```
Confirme que el parámetro `status` no es `INVALID`. Si es así, busque la causa en el parámetro `statusReason`. Para obtener más información, consulte [Solución de problemas AWS Batch](troubleshooting.md).

Los trabajos enviados a esta nueva cola de trabajos se ejecutan como pods en los nodos AWS Batch gestionados que se unieron al clúster de Amazon EKS asociado a su entorno de cómputo.

```
$ cat <<EOF > ./batch-eks-job-queue.json
 {
    "jobQueueName": "My-Eks-JQ1",
    "priority": 10,
    "computeEnvironmentOrder": [
      {
        "order": 1,
        "computeEnvironment": "My-Eks-CE1"
      }
    ]
  }
EOF
```

```
$ aws batch create-job-queue --cli-input-json file://./batch-eks-job-queue.json
```

## Paso 5: Crear una definición de trabajo
<a name="getting-started-eks-step-4"></a>

La siguiente definición de trabajo le indica al pod que permanezca en espera durante 60 segundos.

```
$ cat <<EOF > ./batch-eks-job-definition.json
{
  "jobDefinitionName": "MyJobOnEks_Sleep",
  "type": "container",
  "eksProperties": {
    "podProperties": {
      "hostNetwork": true,
      "containers": [
        {
          "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
          "command": [
            "sleep",
            "60"
          ],
          "resources": {
            "limits": {
              "cpu": "1",
              "memory": "1024Mi"
            }
          }
        }
      ],
      "metadata": {
        "labels": {
          "environment": "test"
        }
      }
    }
  }
}
EOF
```

```
$ aws batch register-job-definition --cli-input-json file://./batch-eks-job-definition.json
```

**Notas**
+ Hay que tener en cuenta los parámetros `cpu` y `memory`. Para obtener más información, consulte [Consideraciones sobre memoria y vCPU para AWS Batch en Amazon EKS](memory-cpu-batch-eks.md).

## Paso 6: Presentar un trabajo
<a name="getting-started-eks-step-5"></a>

Ejecute el siguiente AWS CLI comando para enviar un nuevo Job.

```
$ aws batch submit-job --job-queue My-Eks-JQ1 \
    --job-definition MyJobOnEks_Sleep --job-name My-Eks-Job1
```

Cómo comprobar el estado de un trabajo:

```
$ aws batch describe-jobs --job <jobId-from-submit-response>
```

**Notas**
+ Para obtener más información sobre la ejecución de trabajos en recursos de Amazon EKS, consulte [Trabajos de Amazon EKS](eks-jobs.md).

## Paso 7: Ver la salida del trabajo
<a name="getting-started-eks-step-7"></a>

Para ver la salida del trabajo, realice lo siguiente:

1. Abra la AWS Batch consola en [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. En el panel de navegación, seleccione **Trabajos**. 

1. En el menú desplegable de **Colas de trabajo**, elija la cola de trabajos que creó para el tutorial.

1. La tabla **Trabajos** muestra todos los trabajos y su estado actual. Una vez que el **estado** del **trabajo** sea correcto, elija el **nombre** del trabajo*My-Eks-JQ1*, para ver los detalles del trabajo. 

1. En el panel **Detalles**, las horas de **Iniciado a las** y **Terminado a las** deben estar separadas por un minuto. 

## Paso 8: (opcional) Enviar un trabajo con anulaciones
<a name="getting-started-eks-step-6"></a>

Este trabajo anula el comando pasado al contenedor. AWS Batch limpia agresivamente las cápsulas una vez finalizadas las tareas para reducir la carga. Kubernetes Para examinar los detalles de un trabajo, se debe configurar el registro. Para obtener más información, consulte [Utilice CloudWatch los registros para supervisar AWS Batch los trabajos de Amazon EKS](batch-eks-cloudwatch-logs.md).

```
$ cat <<EOF > ./submit-job-override.json
{
  "jobName": "EksWithOverrides",
  "jobQueue": "My-Eks-JQ1",
  "jobDefinition": "MyJobOnEks_Sleep",
  "eksPropertiesOverride": {
    "podProperties": {
      "containers": [
        {
          "command": [
            "/bin/sh"
          ],
          "args": [
            "-c",
            "echo hello world"
          ]
        }
      ]
    }
  }
}
EOF
```

```
$ aws batch submit-job --cli-input-json file://./submit-job-override.json
```

**Notas**
+ Para mejorar la visibilidad de los detalles de las operaciones, habilite el registro del plano de control de Amazon EKS. Para obtener más información, consulte [Registros del plano de control del clúster de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html) en la *Guía del usuario de Amazon EKS*.
+ La sobrecarga Daemonsets y kubelets afectan a los recursos de vCPU y de memoria disponibles, específicamente al escalado y la colocación de trabajos. Para obtener más información, consulte [Consideraciones sobre memoria y vCPU para AWS Batch en Amazon EKS](memory-cpu-batch-eks.md).

Para ver la salida del trabajo, realice lo siguiente:

1. Abre la AWS Batch consola en. [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/)

1. En el panel de navegación, seleccione **Trabajos**. 

1. En el menú desplegable de **Colas de trabajo**, elija la cola de trabajos que creó para el tutorial.

1. La tabla **Trabajos** muestra todos los trabajos y su estado actual. Una vez que el **Estado** del trabajo sea **Correcto**, seleccione el **Nombre** del trabajo para consultar sus detalles. 

1. En el panel **Detalles**, elija el **Nombre del flujo de registro**. Se abrirá la CloudWatch consola del Job y debería haber un evento con el **Mensaje** de `hello world` o su mensaje personalizado.

## Paso 9: Eliminar los recursos del tutorial
<a name="getting-started-eks-step-8"></a>

Se le cobrará por la instancia de Amazon EC2 mientras esté habilitada. Puede eliminar la instancia para dejar de generar cargos.

Para eliminar los recursos que usted creó, haga lo que se indica a continuación:

1. Abra la AWS Batch consola en [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. En el panel de navegación, elija **Cola de trabajos**. 

1. En la tabla **Cola de trabajos**, elija la cola de trabajos que creó para el tutorial.

1. Elija **Deshabilitar**. Una vez que el **Estado** de la cola de trabajos esté deshabilitado, puede elegir **Eliminar**.

1. Una vez se elimine la cola de trabajos, en el panel de navegación, elija **Entornos de computación**.

1. Elija el entorno de computación que creó para este tutorial y, a continuación, elija **Deshabilitar**. El entorno de computación puede tardar entre 1 y 2 minutos en terminar de deshabilitarse.

1. Una vez que el **Estado** del entorno de computación esté deshabilitado, seleccione **Eliminar**. La eliminación del entorno de computación puede tardar entre 1 y 2 minutos.

## Recursos adicionales
<a name="getting-started-eks-additional-resources"></a>

Después de completar el tutorial, recomendamos consultar alguno de los siguientes temas:
+ Obtenga más información sobre las [prácticas recomendadas](best-practices.md).
+ Explore los componentes AWS Batch principales. Para obtener más información, consulte [Componentes de AWS Batch](batch_components.md).
+ Obtenga más información sobre los diferentes [entornos de computación](compute_environments.md) disponibles en AWS Batch.
+ Obtenga más información sobre las [colas de trabajos](job_queues.md) y sus diferentes opciones de programación.
+ Obtenga más información sobre las [definiciones de trabajos](job_definitions.md) y las diferentes opciones de configuración.
+ Obtenga más información sobre los distintos tipos de [trabajos](jobs.md).

# Cómo empezar a utilizar AWS Batch Amazon EKS Private Clusters
<a name="getting-started-eks-privateclusters"></a>

AWS Batch es un servicio gestionado que organiza las cargas de trabajo por lotes en los clústeres de Amazon Elastic Kubernetes Service (Amazon EKS). Esto incluye la creación de colas, el seguimiento de dependencias, la gestión de reintentos y las prioridades de los trabajos, la gestión de pods y el escalado de nodos. Esta función conecta su clúster privado de Amazon EKS existente con el AWS Batch fin de ejecutar sus trabajos a escala. Puede utilizar [https://eksctl.io/usage/eks-private-cluster/](https://eksctl.io/usage/eks-private-cluster/)(una interfaz de línea de comandos para Amazon EKS), la AWS consola o la [AWS Command Line Interface](https://aws.amazon.com/cli/)para crear un clúster privado de Amazon EKS con todos los demás recursos necesarios. 

De forma predeterminada, [los clústeres privados de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html#private-access) no tienen acceso a inbound/outbound Internet y solo puede acceder al servidor de API desde su VPC o desde una red conectada. Los puntos de enlace de VPC de Amazon se utilizan para permitir el acceso privado a otros servicios de AWS . `eksctl` admite la creación de clústeres totalmente privados mediante una VPC de Amazon y subredes preexistentes. `eksctl` también crea puntos de enlace de VPC de Amazon en la VPC de Amazon suministrada y modifica las tablas de enrutamiento de las subredes proporcionadas.

Cada subred debe tener asociada una tabla de enrutamiento explícita, ya que `eksctl` no modifica la tabla de enrutamiento principal. El [clúster](#getting-started-eks-privateclusters) debe extraer imágenes de un registro de contenedores que esté en su VPC de Amazon. Además, puede crear un Amazon Elastic Container Registry en su VPC de Amazon y copiar las imágenes del contenedor para que sus nodos puedan extraerlas. Para obtener más información, consulte [Copiar una imagen de contenedor de un repositorio en otro repositorio](https://docs.aws.amazon.com/eks/latest/userguide/copy-image-to-repository.html). Para empezar a utilizar los repositorios privados de Amazon ECR, consulte [Repositorios privados de Amazon ECR.](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html)

También puede crear una [regla de caché de extracción](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache.html) con Amazon ECR. Una vez creada una regla de caché de extracción para un registro público externo, extraiga una imagen de ese registro público externo mediante el identificador de recursos uniforme (URI) de su registro privado de Amazon ECR. A continuación, Amazon ECR crea un repositorio y almacena la imagen en la caché. Cuando se extrae una imagen en caché mediante el URI del registro privado de Amazon ECR, Amazon ECR verifica el registro remoto para ver si hay una nueva versión de la imagen y actualiza su registro privado hasta una vez cada 24 horas.

**Contents**
+ [Descripción general de](#getting-started-eks-context)
+ [Requisitos previos](#getting-started-eks-privateclusters-prerequisites)
+ [Paso 1: Cree su clúster de EKS para AWS Batch](#getting-started-eks-privateclusters-step-0)
+ [Paso 2: Prepare su clúster EKS para AWS Batch](#getting-started-eks-privateclusters-step-1)
+ [Paso 3: Crear un entorno de computación de Amazon EKS](#getting-started-eks-privateclusters-2)
+ [Paso 4: Cree una cola de trabajos y adjunte el entorno informático](#getting-started-eks-privateclusters-step-3)
+ [Paso 5: Crear un Amazon ECR con pull through cache](#getting-started-eks-privateclusters-step-ecr)
+ [Paso 6: Registrar una definición de trabajo](#getting-started-eks-privateclusters-step-4)
+ [Paso 7: Enviar un trabajo para ejecutarlo](#getting-started-eks-privateclusters-step-5)
+ [Paso 8: Ver la salida del trabajo](#getting-started-eks-privateclusters-step-7)
+ [Paso 9: (opcional) Enviar un trabajo con anulaciones](#getting-started-eks-privateclusters-step-6)
+ [Paso 10: Eliminar los recursos del tutorial](#getting-started-eks-privateclusters-step-8)
+ [Recursos adicionales](#getting-started-eks-additional-resources)
+ [Resolución de problemas](#getting-started-eks-privateclusters-troubleshooting)

## Descripción general de
<a name="getting-started-eks-context"></a>

En este tutorial se muestra cómo realizar la configuración AWS Batch con un Amazon EKS privado mediante AWS CloudShell, `kubectl` y`eksctl`. 

**Público al que va dirigido**  
Este tutorial está diseñado para los administradores y desarrolladores de sistemas responsables de la configuración, las pruebas y la implementación de AWS Batch.

**Características utilizadas**  
En este tutorial se muestra cómo utilizar el AWS CLI, para:  
+ utilizar Amazon Elastic Container Registry (Amazon ECR) para almacenar imágenes de contenedor, 
+ crear y configurar un entorno de computación de Amazon EKS,
+ crear una cola de trabajos,
+ crear una definición de trabajo,
+ crear y enviar un flujo de trabajo para ejecutarlo,
+ enviar un trabajo con anulaciones.

**Tiempo requerido**  
Completar este tutorial debería tardar entre 40 y 50 minutos.

**Restricciones regionales**  
No hay restricciones regionales o de país asociadas al uso de esta solución.

**Costos de uso de recursos**  
La creación de una AWS cuenta no conlleva ningún cargo. Sin embargo, mediante la implementación de esta solución, es posible que incurra en algunos o todos los costos que se enumeran en la siguiente tabla.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/batch/latest/userguide/getting-started-eks-privateclusters.html)

## Requisitos previos
<a name="getting-started-eks-privateclusters-prerequisites"></a>

Este tutorial AWS CloudShell utiliza un shell preautenticado y basado en un navegador que se inicia directamente desde. Consola de administración de AWS Esto permite acceder al clúster cuando deje de tener acceso público a Internet. El AWS CLI`kubectl`, y `eksctl` puede que ya estén instalados como parte de. AWS CloudShell Para obtener más información al respecto AWS CloudShell, consulte la [https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). Una alternativa AWS CloudShell es conectarse a la VPC del clúster o a una [red conectada](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/introduction.html).

Para ejecutar comandos de kubectl, necesitará acceso privado a su clúster de Amazon EKS. Esto significa que todo el tráfico al servidor de la API del clúster debe proceder de dentro de la VPC de su clúster o de una red conectada.
+ **AWS CLI**— Una herramienta de línea de comandos para trabajar con AWS servicios, incluido Amazon EKS. Esta guía requiere que utilices la versión 2.8.6 o posterior o la 1.26.0 o posterior. Para obtener más información, consulte [Instalar, actualizar y desinstalar la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) en la *Guía del usuario de AWS Command Line Interface *. Tras instalarlo AWS CLI, le recomendamos que también lo configure. Para obtener más información, consulte [Configuración rápida con `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) en la *Guía del usuario de AWS Command Line Interface *.
+ **`kubectl`**: una herramienta de línea de comandos para trabajar con clústeres de Kubernetes. Esta guía requiere que utilice la versión `1.23` o una posterior. Para obtener más información, consulte [Instalación o actualización de `kubectl`](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) en la *Guía del usuario de Amazon EKS*.
+ **`eksctl`**: una herramienta de línea de comandos para trabajar con clústeres de Amazon EKS que automatiza varias tareas individuales. Esta guía requiere que utilice la versión `0.115.0` o una posterior. Para obtener más información, consulte [Instalación o actualización de `eksctl`](https://eksctl.io/installation/) en la **Guía del usuario de Amazon EKS**.
+ **Permisos**: los usuarios que llamen a la operación de [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html)API para crear un entorno de cómputo que utilice los recursos de Amazon EKS necesitan permisos para la operación de `eks:ListClusters` API `eks:DescribeCluster` y de API. Puede adjuntar la política [AWSBatchFullAccess](batch_managed_policies.md)gestionada a su cuenta de usuario siguiendo las instrucciones para [añadir y eliminar permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) que aparecen en la Guía del *usuario de IAM*. 
+ **InstanceRole**— Debe crear una `InstanceRole` para sus nodos de Amazon EKS que tenga las `AmazonEC2ContainerRegistryPullOnly` políticas `AmazonEKSWorkerNodePolicy` y. Para obtener instrucciones sobre cómo crear el `InstanceRole`, consulte [Crear el rol de IAM de nodo de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html#create-worker-node-role). Necesitará el ARN del `InstanceRole`.
+ **Cuenta de AWS ID**: necesita saber su Cuenta de AWS ID. Sigue las instrucciones que se indican en Cómo [ver tu Cuenta de AWS identificación](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html).
+ **(Opcional) CloudWatch**: para examinar los detalles de [(opcional) Enviar un trabajo con anulaciones](getting-started-eks.md#getting-started-eks-step-6), se debe configurar el registro. Para obtener más información, consulte [Utilice CloudWatch los registros para supervisar AWS Batch los trabajos de Amazon EKS](batch-eks-cloudwatch-logs.md).

## Paso 1: Cree su clúster de EKS para AWS Batch
<a name="getting-started-eks-privateclusters-step-0"></a>

**importante**  
Para comenzar de la manera más sencilla y rápida posible, en este tutorial se incluirán los pasos con la configuración predeterminada. Antes de crear para su uso en producción, recomendamos que conozca toda la configuración e implemente la configuración que satisfaga sus requisitos.

Recomendamos utilizar `eksctl` y el siguiente archivo de configuración para crear el clúster. Para configurar el clúster de forma manual, siga las instrucciones en [Implementación de clústeres privados con acceso limitado a Internet](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) de la *Guía del usuario de Amazon EKS*.

1. Abra la [consola de AWS CloudShell](https://console.aws.amazon.com/cloudshell/home) y establezca la región en `us-east-1`. Para el resto del tutorial, asegúrese de estar utilizando `us-east-1`.

1. Cree un clúster de EKS privado en la región `us-east-1` mediante el ejemplo de archivo de configuración `eksctl`. Guarde el archivo yaml en su AWS CloudShell entorno y asígnele `clusterConfig.yaml` un nombre. Puede *my-test-cluster* cambiarlo por el nombre que desee usar para su clúster. 

   ```
   kind: ClusterConfig 
   apiVersion: eksctl.io/v1alpha5
   metadata:
       name: my-test-cluster 
       region: us-east-1
   availabilityZones: 
       - us-east-1a 
       - us-east-1b 
       - us-east-1c
   managedNodeGroups:
       - name: ng-1
         privateNetworking: true 
   privateCluster: 
       enabled: true 
       skipEndpointCreation: false
   ```

1. Cree los recursos con el siguiente comando: `eksctl create cluster -f clusterConfig.yaml` La creación del cluster puede tardar entre 10 y 15 minutos.

1. Una vez que el clúster haya terminado de crearse, tendrás que añadir tu dirección AWS CloudShell IP a la lista de direcciones permitidas. Para encontrar su dirección AWS CloudShell IP, ejecute el siguiente comando:

   ```
   curl http://checkip.amazonaws.com
   ```

   Luego de conseguir la dirección IP pública, debe crear una regla de lista de permitidos:

   ```
   aws eks update-cluster-config \
     --name my-test-cluster \
     --region us-east-1 \
     --resources-vpc-config endpointPublicAccess=true,endpointPrivateAccess=true,publicAccessCidrs=["<Public IP>/32"]
   ```

   A continuación, aplique la actualización al archivo de configuración de kubectl:

   ```
   aws eks update-kubeconfig --name my-test-cluster --region us-east-1
   ```

1. Ejecute el siguiente comando para comprobar que tiene acceso a los nodos:

   ```
   kubectl get nodes
   ```

   La salida del comando será:

   ```
   NAME                              STATUS   ROLES    AGE     VERSION
   ip-192-168-107-235.ec2.internal   Ready    none     1h   v1.32.3-eks-473151a
   ip-192-168-165-40.ec2.internal    Ready    none     1h   v1.32.3-eks-473151a
   ip-192-168-98-54.ec2.internal     Ready    none     1h   v1.32.1-eks-5d632ec
   ```

## Paso 2: Prepare su clúster EKS para AWS Batch
<a name="getting-started-eks-privateclusters-step-1"></a>

Todos los pasos son obligatorios y deben realizarse en él AWS CloudShell.

1. 

**Cree un espacio de nombres dedicado a los trabajos AWS Batch**

   Se utiliza `kubectl` para crear un nuevo espacio de nombres.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl create -f -
   {
     "apiVersion": "v1",
     "kind": "Namespace",
     "metadata": {
       "name": "${namespace}",
       "labels": {
         "name": "${namespace}"
       }
     }
   }
   EOF
   ```

   Salida:

   ```
   namespace/my-aws-batch-namespace created
   ```

1. 

**Habilite el acceso a través del control de acceso basado en roles (RBAC)**

   Se utiliza `kubectl` para crear un rol de Kubernetes para el clúster que permita a AWS Batch vigilar los nodos y los pods y vincular el rol. Haga esto una vez para cada clúster de Amazon EKS.

   ```
   $ cat - <<EOF | kubectl apply -f -
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: aws-batch-cluster-role
   rules:
     - apiGroups: [""]
       resources: ["namespaces"]
       verbs: ["get"]
     - apiGroups: [""]
       resources: ["nodes"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["events"]
       verbs: ["list"]
     - apiGroups: [""]
       resources: ["configmaps"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["apps"]
       resources: ["daemonsets", "deployments", "statefulsets", "replicasets"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["clusterroles", "clusterrolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: aws-batch-cluster-role-binding
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: aws-batch-cluster-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Salida:

   ```
   clusterrole.rbac.authorization.k8s.io/aws-batch-cluster-role created
   clusterrolebinding.rbac.authorization.k8s.io/aws-batch-cluster-role-binding created
   ```

   Cree un Kubernetes rol centrado en el espacio de nombres para administrar los pods y vincularlos durante su ciclo AWS Batch de vida. Debe hacerlo una vez para cada espacio de nombres único.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl apply -f - --namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: aws-batch-compute-environment-role
     namespace: ${namespace}
   rules:
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["create", "get", "list", "watch", "delete", "patch"]
     - apiGroups: [""]
       resources: ["serviceaccounts"]
       verbs: ["get", "list"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["roles", "rolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: aws-batch-compute-environment-role-binding
     namespace: ${namespace}
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: Role
     name: aws-batch-compute-environment-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Salida:

   ```
   role.rbac.authorization.k8s.io/aws-batch-compute-environment-role created
   rolebinding.rbac.authorization.k8s.io/aws-batch-compute-environment-role-binding created
   ```

   Actualice el Kubernetes `aws-auth` mapa de configuración para asignar los permisos RBAC anteriores al rol vinculado al servicio. AWS Batch 

   ```
   $ eksctl create iamidentitymapping \
       --cluster my-test-cluster \
       --arn "arn:aws:iam::<your-account-ID>:role/AWSServiceRoleForBatch" \
       --username aws-batch
   ```

   Salida:

   ```
   2022-10-25 20:19:57 [ℹ]  adding identity "arn:aws:iam::<your-account-ID>:role/AWSServiceRoleForBatch" to auth ConfigMap
   ```
**nota**  
La ruta `aws-service-role/batch.amazonaws.com/` se ha eliminado del ARN del rol vinculado a un servicio. Esto se debe a un problema con el mapa de configuración de `aws-auth`. Para obtener más información, consulte [Roles con rutas que no funcionan cuando la ruta está incluida en su ARN en el aws-authconfigmap](https://github.com/kubernetes-sigs/aws-iam-authenticator/issues/268).

## Paso 3: Crear un entorno de computación de Amazon EKS
<a name="getting-started-eks-privateclusters-2"></a>

AWS Batch los entornos informáticos definen los parámetros de los recursos informáticos para satisfacer sus necesidades de carga de trabajo por lotes. En un entorno informático gestionado, le AWS Batch ayuda a gestionar la capacidad y los tipos de instancia de los recursos informáticos (Kubernetesnodos) de su clúster de Amazon EKS. Se basa en la especificación de recursos de computación que se define al crear el entorno de computación. Puede utilizar instancias bajo demanda EC2 o instancias de spot EC2.

Ahora que el rol **AWSServiceRoleForBatch**vinculado al servicio tiene acceso a su clúster de Amazon EKS, puede crear AWS Batch recursos. En primer lugar, cree un entorno de computación que apunte a su clúster de Amazon EKS.
+ En `subnets` ejecute `eksctl get cluster my-test-cluster` para obtener las subredes que el clúster utilizó. 
+ En el parámetro `securityGroupIds`, puede utilizar el mismo grupo de seguridad que utiliza el clúster de Amazon EKS. Este comando recupera el ID del grupo de seguridad del clúster.

  ```
  $ aws eks describe-cluster \
      --name my-test-cluster \
      --query cluster.resourcesVpcConfig.clusterSecurityGroupId
  ```
+ Utilice el ARN del `instanceRole` que creó en los requisitos previos.

```
$ cat <<EOF > ./batch-eks-compute-environment.json
{
  "computeEnvironmentName": "My-Eks-CE1",
  "type": "MANAGED",
  "state": "ENABLED",
  "eksConfiguration": {
    "eksClusterArn": "arn:aws:eks:us-east-1:<your-account-ID>:cluster/my-test-cluster",
    "kubernetesNamespace": "my-aws-batch-namespace"
  },
  "computeResources": {
    "type": "EC2",
    "allocationStrategy": "BEST_FIT_PROGRESSIVE",
    "minvCpus": 0,
    "maxvCpus": 128,
    "instanceTypes": [
        "m5"
    ],
    "subnets": [
        "<eks-cluster-subnets-with-access-to-the-image-for-image-pull>"
    ],
    "securityGroupIds": [
        "<eks-cluster-sg>"
    ],
    "instanceRole": "<eks-instance-profile>"
  }
}
EOF
```

```
$ aws batch create-compute-environment --cli-input-json file://./batch-eks-compute-environment.json
```

**Notas**
+ El mantenimiento de un entorno de computación de Amazon EKS es una responsabilidad compartida. Para obtener más información, consulte [Seguridad en Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security.html).

## Paso 4: Cree una cola de trabajos y adjunte el entorno informático
<a name="getting-started-eks-privateclusters-step-3"></a>

**importante**  
Es importante confirmar que el entorno de computación está en buen estado antes de continuar. Para ello, se puede utilizar la operación de la [DescribeComputeEnvironments](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeComputeEnvironments.html)API.  

```
$ aws batch describe-compute-environments --compute-environments My-Eks-CE1
```
Confirme que el parámetro `status` no es `INVALID`. Si es así, busque la causa en el parámetro `statusReason`. Para obtener más información, consulte [Solución de problemas AWS Batch](troubleshooting.md).

Los trabajos enviados a esta nueva cola de trabajos se ejecutan como pods en los nodos AWS Batch gestionados que se unieron al clúster de Amazon EKS asociado a su entorno de cómputo.

```
$ cat <<EOF > ./batch-eks-job-queue.json
 {
    "jobQueueName": "My-Eks-JQ1",
    "priority": 10,
    "computeEnvironmentOrder": [
      {
        "order": 1,
        "computeEnvironment": "My-Eks-CE1"
      }
    ]
  }
EOF
```

```
$ aws batch create-job-queue --cli-input-json file://./batch-eks-job-queue.json
```

## Paso 5: Crear un Amazon ECR con pull through cache
<a name="getting-started-eks-privateclusters-step-ecr"></a>

Como el clúster no tiene acceso público a Internet, deberá crear un Amazon ECR para las imágenes del contenedor. Las siguientes instrucciones crean un Amazon ECR con pull-through cache rule (regla de cache de extracción) para almacenar la imagen.

1. El siguiente comando crea la pull-through cache rule. Puede sustituirlo por *tutorial-prefix* un prefijo diferente.

   ```
   aws ecr create-pull-through-cache-rule \
       --ecr-repository-prefix "my-prefix" \
       --upstream-registry-url "public.ecr.aws" \
       --region us-east-1
   ```

1. Autentifíquese con el ECR público.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com
   ```

   Ahora puede extraer una imagen.

   ```
   docker pull <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2
   ```

1. Verifique el repositorio y la imagen ejecutando los siguientes comandos:

   ```
   aws ecr describe-repositories
   ```

   ```
   aws ecr describe-images --repository-name my-prefix/amazonlinux/amazonlinux
   ```

1. La cadena de imagen que se utilizará para extraer el contenedor tiene el siguiente formato:

   ```
   <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2
   ```

## Paso 6: Registrar una definición de trabajo
<a name="getting-started-eks-privateclusters-step-4"></a>

La siguiente definición de trabajo le indica al pod que permanezca en espera durante 60 segundos.

En el campo de imagen de la definición del trabajo, en lugar de proporcionar un enlace a la imagen de un repositorio de ECR público, facilite el enlace a la imagen almacenada en nuestro repositorio de ECR privado. Consulte el siguiente ejemplo de definición del trabajo:

```
$ cat <<EOF > ./batch-eks-job-definition.json
{
  "jobDefinitionName": "MyJobOnEks_Sleep",
  "type": "container",
  "eksProperties": {
    "podProperties": {
      "hostNetwork": true,
      "containers": [
        {
          "image": "<your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2",
          "command": [
            "sleep",
            "60"
          ],
          "resources": {
            "limits": {
              "cpu": "1",
              "memory": "1024Mi"
            }
          }
        }
      ],
      "metadata": {
        "labels": {
          "environment": "test"
        }
      }
    }
  }
}
EOF
```

```
$ aws batch register-job-definition --cli-input-json file://./batch-eks-job-definition.json
```



**Notas**
+ Hay que tener en cuenta los parámetros `cpu` y `memory`. Para obtener más información, consulte [Consideraciones sobre memoria y vCPU para AWS Batch en Amazon EKS](memory-cpu-batch-eks.md).

## Paso 7: Enviar un trabajo para ejecutarlo
<a name="getting-started-eks-privateclusters-step-5"></a>

Ejecuta el siguiente AWS CLI comando AWS CloudShell para enviar un nuevo trabajo y devuelve el JoBid único.

```
$ aws batch submit-job --job-queue My-Eks-JQ1 \
    --job-definition MyJobOnEks_Sleep - -job-name My-Eks-Job1
```

**Notas**
+ Para obtener más información sobre la ejecución de trabajos en recursos de Amazon EKS, consulte [Trabajos de Amazon EKS](eks-jobs.md).

## Paso 8: Ver la salida del trabajo
<a name="getting-started-eks-privateclusters-step-7"></a>

Cómo comprobar el estado de un trabajo:

```
$ aws batch describe-jobs --job <JobID-from-submit-response>
```

Los `startedAt` y `stoppedAt` deben estar separados por un minuto. 

## Paso 9: (opcional) Enviar un trabajo con anulaciones
<a name="getting-started-eks-privateclusters-step-6"></a>

Este trabajo anula el comando transferido al contenedor.

```
$ cat <<EOF > ./submit-job-override.json
{
  "jobName": "EksWithOverrides",
  "jobQueue": "My-Eks-JQ1",
  "jobDefinition": "MyJobOnEks_Sleep",
  "eksPropertiesOverride": {
    "podProperties": {
      "containers": [
        {
          "command": [
            "/bin/sh"
          ],
          "args": [
            "-c",
            "echo hello world"
          ]
        }
      ]
    }
  }
}
EOF
```

```
$ aws batch submit-job - -cli-input-json file://./submit-job-override.json
```

**Notas**
+ Para mejorar la visibilidad de los detalles de las operaciones, habilite el registro del plano de control de Amazon EKS. Para obtener más información, consulte [Registros del plano de control del clúster de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html) en la **Guía del usuario de Amazon EKS**.
+ La sobrecarga Daemonsets y kubelets afectan a los recursos de vCPU y de memoria disponibles, específicamente al escalado y la colocación de trabajos. Para obtener más información, consulte [Consideraciones sobre memoria y vCPU para AWS Batch en Amazon EKS](memory-cpu-batch-eks.md).

## Paso 10: Eliminar los recursos del tutorial
<a name="getting-started-eks-privateclusters-step-8"></a>

Se le cobrará por la instancia de Amazon EC2 mientras esté habilitada. Puede eliminar la instancia para dejar de generar cargos.

Para eliminar los recursos que usted creó, haga lo que se indica a continuación:

1. Abre la AWS Batch consola en. [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/)

1. En el panel de navegación, elija **Cola de trabajos**. 

1. En la tabla **Cola de trabajos**, elija la cola de trabajos que creó para el tutorial.

1. En **Acciones**, seleccione **Deshabilitar**. Una vez que el **Estado** de la cola de trabajos esté deshabilitado, puede elegir **Eliminar**.

1. Una vez se elimine la cola de trabajos, en el panel de navegación, elija **Entornos de computación**.

1. Elija el entorno de computación que creó para este tutorial y, a continuación, elija **Deshabilitar** desde **Acciones**. El entorno de computación puede tardar entre 1 y 2 minutos en terminar de deshabilitarse.

1. Una vez que el **Estado** del entorno de computación esté deshabilitado, seleccione **Eliminar**. La eliminación del entorno de computación puede tardar entre 1 y 2 minutos.

## Recursos adicionales
<a name="getting-started-eks-additional-resources"></a>

Después de completar el tutorial, recomendamos consultar alguno de los siguientes temas:
+ Obtenga más información sobre las [prácticas recomendadas](best-practices.md).
+ Explore los componentes AWS Batch principales. Para obtener más información, consulte [Componentes de AWS Batch](batch_components.md).
+ Obtenga más información sobre los diferentes [entornos de computación](compute_environments.md) disponibles en AWS Batch.
+ Obtenga más información sobre las [colas de trabajos](job_queues.md) y sus diferentes opciones de programación.
+ Obtenga más información sobre las [definiciones de trabajos](job_definitions.md) y las diferentes opciones de configuración.
+ Obtenga más información sobre los distintos tipos de [trabajos](jobs.md).

## Resolución de problemas
<a name="getting-started-eks-privateclusters-troubleshooting"></a>

Si los nodos lanzados por AWS Batch no tienen acceso al repositorio de Amazon ECR (o a ningún otro repositorio) que almacene su imagen, sus trabajos podrían permanecer en el estado STARTING. Esto se debe a que el pod no podrá descargar la imagen ni ejecutar su AWS Batch trabajo. Si haces clic en el nombre del pod lanzado por, AWS Batch deberías poder ver el mensaje de error y confirmar el problema. El mensaje de error debería ser similar al siguiente:

```
Failed to pull image "public.ecr.aws/amazonlinux/amazonlinux:2": rpc error: code =
Unknown desc = failed to pull and unpack image
"public.ecr.aws/amazonlinux/amazonlinux:2": failed to resolve reference
"public.ecr.aws/amazonlinux/amazonlinux:2": failed to do request: Head
"https://public.ecr.aws/v2/amazonlinux/amazonlinux/manifests/2": dial tcp: i/o timeout
```

Para ver otros escenarios de solución de problemas comunes, consulte [Solución de problemas de AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/batch-eks-troubleshooting.html). Para solucionar problemas relacionados con el estado del pod, consulte [https://repost.aws/knowledge-center/eks-pod-status-troubleshooting](https://repost.aws/knowledge-center/eks-pod-status-troubleshooting)

# Primeros pasos con AWS Batch la SageMaker IA
<a name="getting-started-sagemaker"></a>

AWS Batch Los trabajos de servicio le permiten enviar trabajos de SageMaker formación a través de colas de AWS Batch trabajos con funciones de programación, priorización y preparación de colas. En este tutorial se muestra cómo configurar y ejecutar un trabajo de SageMaker formación sencillo mediante AWS Batch trabajos de servicio.

**Contents**
+ [Descripción general de](#getting-started-sagemaker-context)
+ [Requisitos previos](#getting-started-sagemaker-prerequisites)
+ [Paso 1: Crear un rol de ejecución de SageMaker IA](#getting-started-sagemaker-step-1)
+ [Paso 2: Crear el entorno de servicio](#getting-started-sagemaker-step-2)
+ [Paso 3: Crea tu cola de SageMaker trabajos](#getting-started-sagemaker-step-3)
+ [Paso 4: Crear y enviar un trabajo de entrenamiento](#getting-started-sagemaker-step-4)
+ [Paso 5: Supervisar el estado del trabajo](#getting-started-sagemaker-step-5)
+ [Paso 6: Ver la salida del trabajo](#getting-started-sagemaker-step-6)
+ [Paso 7: Eliminar los recursos del tutorial](#getting-started-sagemaker-step-7)
+ [Recursos adicionales](#getting-started-sagemaker-additional-resources)

## Descripción general de
<a name="getting-started-sagemaker-context"></a>

En este tutorial se muestra cómo configurar los trabajos AWS Batch de servicio para los trabajos de SageMaker formación mediante el AWS CLI.

**Público objetivo**  
Este tutorial está dirigido a científicos de datos y desarrolladores responsables de configurar y ejecutar trabajos de entrenamiento en machine learning a gran escala.

**Características utilizadas**  
En este tutorial se muestra cómo utilizarlas AWS CLI para:  
+ Crear un entorno de servicios para los trabajos SageMaker de formación
+ Cree una cola SageMaker de trabajos de formación
+ enviar trabajos de servicio mediante la API `SubmitServiceJob`,
+ supervisar el estado del trabajo y ver las salidas,
+ Acceda a CloudWatch los registros para los trabajos de formación

**Tiempo requerido**  
Debe tardar aproximadamente 15 minutos en completar este tutorial.

**Restricciones regionales**  
Este tutorial se puede completar en cualquier AWS región en la que estén disponibles AWS Batch tanto la SageMaker IA como la IA.

**Costos de uso de recursos**  
La creación de una AWS cuenta no conlleva ningún cargo. Sin embargo, si se implementa esta solución, es posible que se generen gastos para los siguientes recursos:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/batch/latest/userguide/getting-started-sagemaker.html)

## Requisitos previos
<a name="getting-started-sagemaker-prerequisites"></a>

Antes de comenzar este tutorial, debe instalar y configurar las siguientes herramientas y recursos que necesita para crear y administrar tanto AWS Batch los recursos de SageMaker IA.
+ **AWS CLI**— Una herramienta de línea de comandos para trabajar con AWS servicios, incluida AWS Batch la SageMaker IA. Esta guía requiere que utilices la versión 2.8.6 o posterior. Para obtener más información, consulte [Instalar, actualizar y desinstalar la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) en la *Guía del usuario de AWS Command Line Interface *. Tras instalar el AWS CLI, le recomendamos que también lo configure. Para obtener más información, consulte [Configuración rápida con `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) en la *Guía del usuario de AWS Command Line Interface *.

## Paso 1: Crear un rol de ejecución de SageMaker IA
<a name="getting-started-sagemaker-step-1"></a>

SageMaker La IA utiliza las funciones de ejecución para realizar operaciones en su nombre mediante otros AWS servicios. Debe crear un rol de ejecución y conceder permisos a la SageMaker IA para usar los servicios y recursos necesarios para los trabajos de formación. Utilice la política administrada de `AmazonSageMakerFullAccess`, ya que incluye permisos para Amazon S3. 

**nota**  
Siga las instrucciones siguientes para crear el rol de ejecución de SageMaker IA para este tutorial.  
Antes de crear una función de ejecución para su entorno de producción, le recomendamos que consulte la guía [Cómo utilizar las funciones de ejecución de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) en la *[guía para desarrolladores de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)*.

1. 

**Creación del rol de IAM**

   Cree un archivo JSON denominado `sagemaker-trust-policy.json` con la siguiente política de confianza:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "sagemaker.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

   Cree un rol de IAM mediante la política de confianza:

   ```
   aws iam create-role \
       --role-name SageMakerExecutionRole \
       --assume-role-policy-document file://sagemaker-trust-policy.json \
       --description "Execution role for SageMaker training jobs"
   ```

1. 

**Asocie las políticas administradas**

   Asocie las políticas administradas necesarias al rol:

   ```
   aws iam attach-role-policy \
       --role-name SageMakerExecutionRole \
       --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   ```

   ```
   aws iam attach-role-policy \
       --role-name SageMakerExecutionRole \
       --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   ```

1. 

**Observe el ARN del rol**

   Obtenga el rol ARN que necesitará en los siguientes pasos:

   ```
   aws iam get-role --role-name SageMakerExecutionRole --query 'Role.Arn' --output text
   ```

   Guarde este ARN, ya que lo usará al crear la carga útil de su trabajo de entrenamiento.

## Paso 2: Crear el entorno de servicio
<a name="getting-started-sagemaker-step-2"></a>

Un entorno de servicios define las limitaciones de capacidad para los trabajos de SageMaker formación. El entorno de servicio encapsula la cantidad máxima de instancias de entrenamiento que se pueden ejecutar simultáneamente.

**importante**  
Cuando crea su primer entorno de servicios para la SageMaker formación, crea AWS Batch automáticamente un rol vinculado al servicio denominado `AWSServiceRoleForAWSBatchWithSagemaker` en su cuenta. Esta función te permite AWS Batch poner en cola los trabajos de SageMaker formación y gestionarlos en tu nombre. Para obtener más información sobre los roles vinculados a servicios y sus permisos, consulte [Uso de roles para la IA AWS Batch SageMaker](using-service-linked-roles-batch-sagemaker.md).

Cree un entorno de servicios que pueda gestionar hasta 5 instancias:

```
aws batch create-service-environment \
    --service-environment-name TutorialServiceEnvironment \
    --service-environment-type SAGEMAKER_TRAINING \
    --capacity-limits capacityUnit=NUM_INSTANCES,maxCapacity=5
```

Salida:

```
{
    "serviceEnvironmentName": "TutorialServiceEnvironment",
    "serviceEnvironmentArn": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment"
}
```

Compruebe que el entorno de servicio se haya creado correctamente:

```
aws batch describe-service-environments --service-environments TutorialServiceEnvironment
```

Salida:

```
{
    "serviceEnvironments": [
        {
            "serviceEnvironmentName": "TutorialServiceEnvironment",
            "serviceEnvironmentArn": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment",
            "serviceEnvironmentType": "SAGEMAKER_TRAINING",
            "state": "ENABLED",
            "status": "VALID",
            "capacityLimits": [
                {
                    "maxCapacity": 5,
                    "capacityUnit": "NUM_INSTANCES"
                }
            ],
            "tags": {}
        }
    ]
}
```

Para obtener más información sobre los entornos de servicios, consulte [Entornos de servicio para AWS Batch](service-environments.md).

## Paso 3: Crea tu cola de SageMaker trabajos
<a name="getting-started-sagemaker-step-3"></a>

Una cola de SageMaker trabajos gestiona la programación y la ejecución de los trabajos de servicio. Los trabajos enviados a esta cola se entregarán a su entorno de servicio según la disponibilidad de la capacidad.

Cree una cola SageMaker de trabajos de formación:

```
aws batch create-job-queue \
    --job-queue-name my-sm-training-fifo-jq \
    --job-queue-type SAGEMAKER_TRAINING \
    --priority 1 \
    --service-environment-order order=1,serviceEnvironment=TutorialServiceEnvironment
```

Salida:

```
{
    "jobQueueName": "my-sm-training-fifo-jq",
    "jobQueueArn": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq"
}
```

Compruebe que la cola de trabajos se haya creado correctamente:

```
aws batch describe-job-queues --job-queues my-sm-training-fifo-jq
```

Salida:

```
{
    "jobQueues": [
        {
            "jobQueueName": "my-sm-training-fifo-jq",
            "jobQueueArn": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq",
            "state": "ENABLED",
            "status": "VALID",
            "statusReason": "JobQueue Healthy",
            "priority": 1,
            "computeEnvironmentOrder": [],
            "serviceEnvironmentOrder": [
                {
                    "order": 1,
                    "serviceEnvironment": "arn:aws:batch:your-region:your-account-id:service-environment/TutorialServiceEnvironment"
                }
            ],
            "jobQueueType": "SAGEMAKER_TRAINING",
            "tags": {}
        }
    ]
}
```

Para obtener más información sobre las colas de SageMaker trabajos, consulte. [Creación de una cola de trabajos de entrenamiento de SageMaker en AWS Batch](create-sagemaker-job-queue.md)

## Paso 4: Crear y enviar un trabajo de entrenamiento
<a name="getting-started-sagemaker-step-4"></a>

Ahora creará un trabajo de entrenamiento sencillo y lo enviará a la lista de trabajos. En este ejemplo se utiliza un trabajo de entrenamiento básico de “hola, mundo” que demuestra la funcionalidad del trabajo de servicio.

Cree un archivo llamado `my_training_job.json` con el siguiente contenido. *your-account-id*Sustitúyalo por tu ID AWS de cuenta:

**nota**  
`S3OutputPath`es necesario para crear el trabajo de SageMaker formación, pero los resultados de este tutorial no se almacenan en el bucket de Amazon S3 y puede utilizar la ruta en el siguiente JSON. En su entorno de producción, necesitará un bucket de Amazon S3 válido para almacenar allí la salida, si así lo desea.

```
{
    "TrainingJobName": "my-simple-training-job",
    "RoleArn": "arn:aws:iam::your-account-id:role/SageMakerExecutionRole",
    "AlgorithmSpecification": {
        "TrainingInputMode": "File",
        "TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-training:2.0.0-cpu-py310",
        "ContainerEntrypoint": [
            "echo",
            "hello world"
        ]
    },
    "ResourceConfig": {
        "InstanceType": "ml.c5.xlarge",
        "InstanceCount": 1,
        "VolumeSizeInGB": 1
    },
    "OutputDataConfig": {
        "S3OutputPath": "s3://your-s3-bucket/output"
    },
    "StoppingCondition": {
        "MaxRuntimeInSeconds": 30
    }
}
```

Envíe el trabajo de formación mediante la [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API:

```
aws batch submit-service-job \
    --job-queue my-sm-training-fifo-jq \
    --job-name my-batch-sm-job \
    --service-job-type SAGEMAKER_TRAINING \
    --retry-strategy attempts=1 \
    --timeout-config attemptDurationSeconds=60 \
    --service-request-payload file://my_training_job.json
```

Salida:

```
{
    "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
    "jobName": "my-batch-sm-job",
    "jobId": "your-job-id"
}
```

Para obtener más información sobre la carga útil del trabajo de servicio, consulte [Cargas útiles de trabajos de servicio en AWS Batch](service-job-payload.md). Y para obtener más información sobre el envío de trabajos de servicio, consulte [Envíe un trabajo de servicio en AWS Batch](service-job-submit.md).

## Paso 5: Supervisar el estado del trabajo
<a name="getting-started-sagemaker-step-5"></a>

Puede supervisar sus trabajos de formación mediante lo siguiente AWS Batch APIs: [DescribeServiceJob[ListServiceJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_ListServiceJobs.html)](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html), y [GetJobQueueSnapshot](https://docs.aws.amazon.com/batch/latest/APIReference/API_GetJobQueueSnapshot.html). En esta sección se muestran diferentes formas de comprobar el estado de los trabajos y la información de las colas.

Cómo ver los trabajos en ejecución en la cola:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq --job-status RUNNING
```

Salida:

```
{
    "jobSummaryList": [
        {
            "latestAttempt": {
                "serviceResourceId": {
                    "name": "TrainingJobArn",
                    "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
                }
            },
            "createdAt": 1753718760,
            "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
            "jobId": "your-job-id",
            "jobName": "my-batch-sm-job",
            "serviceJobType": "SAGEMAKER_TRAINING",
            "status": "RUNNING",
            "startedAt": 1753718820
        }
    ]
}
```

Cómo ver los trabajos que se encuentran en el estado `RUNNABLE`:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq --job-status RUNNABLE
```

Cómo obtener una instantánea de los próximos trabajos en la cola:

```
aws batch get-job-queue-snapshot --job-queue my-sm-training-fifo-jq
```

Salida:

```
{
    "frontOfQueue": {
        "jobs": [
            {
                "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
                "earliestTimeAtPosition": 1753718880
            },
            {
                "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id-2",
                "earliestTimeAtPosition": 1753718940
            }
        ],
        "lastUpdatedAt": 1753718970
    }
}
```

Cómo buscar trabajos por nombre:

```
aws batch list-service-jobs \
    --job-queue my-sm-training-fifo-jq \
    --filters name=JOB_NAME,values="my-batch-sm-job"
```

Salida:

```
{
    "jobSummaryList": [
        {
            "latestAttempt": {
                "serviceResourceId": {
                    "name": "TrainingJobArn",
                    "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
                }
            },
            "createdAt": 1753718760,
            "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
            "jobId": "your-job-id",
            "jobName": "my-batch-sm-job",
            "serviceJobType": "SAGEMAKER_TRAINING",
            "status": "RUNNING"
        }
    ]
}
```

Para obtener más información sobre la asignación del estado de trabajos, consulte [Asignar el estado del trabajo del AWS Batch servicio al estado de la SageMaker IA](service-job-status.md).

## Paso 6: Ver la salida del trabajo
<a name="getting-started-sagemaker-step-6"></a>

Una vez que termine su trabajo, podrá ver su resultado y sus registros a través de la SageMaker IA APIs. AWS Batch 

Obtenga información detallada sobre su trabajo en AWS Batch:

```
aws batch describe-service-job \
    --job-id your-job-id
```

Salida:

```
{
    "attempts": [
        {
            "serviceResourceId": {
                "name": "TrainingJobArn",
                "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
            },
            "startedAt": 1753718820,
            "stoppedAt": 1753718880,
            "statusReason": "Received status from SageMaker: Training job completed"
        }
    ],
    "createdAt": 1753718760,
    "jobArn": "arn:aws:batch:your-region:your-account-id:service-job/your-job-id",
    "jobId": "your-job-id",
    "jobName": "my-batch-sm-job",
    "jobQueue": "arn:aws:batch:your-region:your-account-id:job-queue/my-sm-training-fifo-jq",
    "latestAttempt": {
        "serviceResourceId": {
            "name": "TrainingJobArn",
            "value": "arn:aws:sagemaker:your-region:your-account-id:training-job/AWSBatch<my-simple-training-job><your-attempt-id>"
        }
    },
    "retryStrategy": {
        "attempts": 1,
        "evaluateOnExit": []
    },
    "serviceRequestPayload": "your-training-job-request-json",
    "serviceJobType": "SAGEMAKER_TRAINING",
    "startedAt": 1753718820,
    "status": "SUCCEEDED",
    "statusReason": "Received status from SageMaker: Training job completed",
    "stoppedAt": 1753718880,
    "tags": {},
    "timeoutConfig": {
        "attemptDurationSeconds": 60
    }
}
```

Este comando devuelve información completa sobre el trabajo, incluido el SageMaker ARN del trabajo de formación, que puede utilizar para acceder al trabajo directamente a través SageMaker de la IA:

```
aws sagemaker describe-training-job \
    --training-job-name AWSBatch<my-simple-training-job><your-attempt-id>
```

Para ver los CloudWatch registros de tu trabajo de formación, primero obtén el nombre del flujo de registro:

```
aws logs describe-log-streams \
    --log-group-name /aws/sagemaker/TrainingJobs \
    --log-stream-name-prefix AWSBatchmy-simple-training-job
```

Salida:

```
{
    "logStreams": [
        {
            "logStreamName": "your-log-stream-name",
            "creationTime": 1753718830,
            "firstEventTimestamp": 1753718840,
            "lastEventTimestamp": 1753718850,
            "lastIngestionTime": 1753718860,
            "uploadSequenceToken": upload-sequence-token,
            "arn": "arn:aws:logs:your-region:your-account-id:log-group:/aws/sagemaker/TrainingJobs:log-stream:AWSBatch<my-simple-training-job><your-attempt-id>/algo-1-algo-id",
            "storedBytes": 0
        }
    ]
}
```

A continuación, recupere los registros con el nombre del flujo de registro de la respuesta anterior:

```
aws logs get-log-events \
    --log-group-name /aws/sagemaker/TrainingJobs \
    --log-stream-name your-log-stream-name
```

Salida:

```
{
    "events": [
        {
            "timestamp": 1753718845,
            "message": "hello world",
            "ingestionTime": 1753718865
        }
    ],
    "nextForwardToken": "next-forward-token",
    "nextBackwardToken": "next-backward-token"
}
```

La salida del registro muestra el mensaje “hola, mundo” de su trabajo de entrenamiento, que confirma que el trabajo se ha ejecutado correctamente.

## Paso 7: Eliminar los recursos del tutorial
<a name="getting-started-sagemaker-step-7"></a>

Cuando haya completado este tutorial, elimine los recursos que creó para evitar la generación de gastos innecesarios.

En primer lugar, deshabilite y elimine la cola de trabajos:

```
aws batch update-job-queue \
    --job-queue my-sm-training-fifo-jq \
    --state DISABLED
```

Espere a que se deshabilite la cola de trabajos y, a continuación, elimínela:

```
aws batch delete-job-queue \
    --job-queue my-sm-training-fifo-jq
```

Deshabilite y elimine el entorno de servicio:

```
aws batch update-service-environment \
    --service-environment TutorialServiceEnvironment \
    --state DISABLED
```

Espere a que se deshabilite el entorno de servicio y, finalmente, elimínelo:

```
aws batch delete-service-environment \
    --service-environment TutorialServiceEnvironment
```

## Recursos adicionales
<a name="getting-started-sagemaker-additional-resources"></a>

Después de completar el tutorial, recomendamos consultar alguno de los siguientes temas:
+ Recomendamos usar PySDK para crear trabajos de servicio y enviarlos a la cola de trabajos, ya que contiene clases y utilidades auxiliares. Para ver un ejemplo del uso de PySDK, consulta los [ejemplos de SageMaker IA](https://github.com/aws/amazon-sagemaker-examples) en GitHub.
+ Obtener más información sobre [Trabajos de servicio en AWS Batch](service-jobs.md).
+ Consulte [Cargas útiles de trabajos de servicio en AWS Batch](service-job-payload.md) para las configuraciones del trabajo de entrenamiento más complejos.
+ Obtenga información sobre [Envíe un trabajo de servicio en AWS Batch](service-job-submit.md) y la API `SubmitServiceJob`.
+ Revise [Asignar el estado del trabajo del AWS Batch servicio al estado de la SageMaker IA](service-job-status.md) para comprender las transiciones entre los estados de trabajo.
+ Visite la [documentación del SDK de Python para SageMaker IA](https://sagemaker.readthedocs.io/en/stable/) para obtener más formas ricas en funciones de crear y enviar trabajos de SageMaker formación con Python.
+ Consulta [SageMakerejemplos de cuadernos para flujos](https://github.com/aws/amazon-sagemaker-examples) de trabajo de aprendizaje automático más complejos.