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

# Cómo empezar a 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)