

 **Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Implementación de un clúster `IPv6` de Amazon EKS y nodos administrados de Amazon Linux
<a name="deploy-ipv6-cluster"></a>

En este tutorial, implementa una nube de Amazon VPC `IPv6`, un clúster de Amazon EKS con la familia `IPv6` y un grupo de nodos administrado con nodos de Amazon Linux de Amazon EC2. No se pueden implementar nodos de Windows de Amazon EC2 en un clúster `IPv6`. También puede implementar nodos de Fargate en su clúster, aunque esas instrucciones no se proporcionarán en este tema por motivos de simplicidad.

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

Realice los siguientes pasos antes de comenzar el tutorial:

Instale y configure las siguientes herramientas y recursos que necesitará para crear y administrar un clúster de Amazon EKS.
+ Recomendamos que conozca toda la configuración e implemente un clúster con la configuración que satisfaga sus requisitos. Para obtener más información, consulte [Creación de un clúster de Amazon EKS](create-cluster.md), [Simplificación del ciclo de vida de los nodos con grupos de nodos administrados](managed-node-groups.md) y las [Consideraciones](cni-ipv6.md) sobre este tema. Solo puede habilitar algunos ajustes de la configuración cuando cree su clúster.
+ La herramienta de línea de comandos de `kubectl` está instalada en su dispositivo o AWS CloudShell. La versión puede ser la misma o hasta una versión secundaria anterior o posterior a la versión de Kubernetes de su clúster. Por ejemplo, si la versión del clúster es `1.29`, puede usar la versión `1.28`, `1.29` o `1.30` de `kubectl` con él. Para instalar o actualizar `kubectl`, consulte [Configuración de `kubectl` y `eksctl`](install-kubectl.md).
+ La entidad principal de seguridad de IAM que está utilizando debe contar con permisos para trabajar con los roles de IAM de Amazon EKS y los roles vinculados al servicio, AWS CloudFormation, además de una VPC y recursos relacionados. Para obtener más información, consulte [Acciones](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html) y Uso de roles vinculados a servicios en la [Guía del usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html).
+ Si usa eksctl, instale la versión `0.215.0` o posterior en su equipo. Para instalar o actualizar esta versión, consulte la sección de [Instalación](https://eksctl.io/installation) en la documentación de `eksctl`.
+ La versión `2.12.3` o posterior, o bien, la versión `1.27.160` o posterior de la AWS interfaz de la línea de comandos (AWS CLI) instalada y configurada en su dispositivo o AWS CloudShell. Para comprobar su versión actual, utilice `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Los administradores de paquetes, como `yum`, `apt-get` o Homebrew para macOS, suelen estar atrasados varias versiones respecto de la versión de la AWS CLI más reciente. Para instalar la versión más reciente, consulte [Instalación](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) y [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 la interfaz de la línea de comandos de AWS*. La versión de AWS CLI instalada en AWS CloudShell también puede estar atrasada varias versiones respecto de la versión más reciente. Para actualizarla, consulte [Instalación de la CLI de AWS en su directorio principal](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) en la *Guía del usuario de AWS CloudShell*. Si utiliza AWS CloudShell, es posible que deba [instalar la versión  2.12.3 o posterior, o bien, la versión 1.27.160 o posterior de la CLI de AWS](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software), ya que la versión predeterminada de la CLI de AWS instalada en AWS CloudShell puede ser una versión anterior.

Puede utilizar eksctl o la CLI para implementar un clúster `IPv6`.

## Implementación de un clúster IPv6 con eksctl
<a name="_deploy_an_ipv6_cluster_with_eksctl"></a>

1. Creación del archivo `ipv6-cluster.yaml`. Copie el comando que sigue en su dispositivo. Realice las siguientes modificaciones en el comando según sea necesario y, a continuación, ejecute el comando modificado:
   + Reemplace *my-cluster* por el nombre de su clúster. El nombre solo puede contener caracteres alfanuméricos (con distinción de mayúsculas y minúsculas) y guiones. Debe comenzar con un carácter alfanumérico y no puede tener más de 100 caracteres. El nombre debe ser único dentro de la región de AWS y la cuenta de AWS en las que va a crear el clúster.
   + Reemplace *region-code* por cualquier región de AWS en la que se admita Amazon EKS. Para ver una lista de las regiones de AWS, consulte [Puntos de conexión y cuotas de Amazon EKS](https://docs.aws.amazon.com/general/latest/gr/eks.html) en la Guía de referencia general de AWS.
   + El valor de `version` con la versión de su clúster. Para obtener más información, consulte las [versiones compatibles de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions.html).
   + Reemplace *my-nodegroup* con un nombre para su grupo de nodos. El nombre del grupo de nodos no puede tener más de 63 caracteres. Debe empezar por una letra o un dígito, pero también puede incluir guiones y guiones bajos como caracteres no iniciales.
   + Reemplace *t3.medium* por cualquier [tipo de instancia de AWS Nitro System](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances).

     ```
     cat >ipv6-cluster.yaml <<EOF
     ---
     apiVersion: eksctl.io/v1alpha5
     kind: ClusterConfig
     
     metadata:
       name: my-cluster
       region: region-code
       version: "X.XX"
     
     kubernetesNetworkConfig:
       ipFamily: IPv6
     
     addons:
       - name: vpc-cni
         version: latest
       - name: coredns
         version: latest
       - name: kube-proxy
         version: latest
     
     iam:
       withOIDC: true
     
     managedNodeGroups:
       - name: my-nodegroup
         instanceType: t3.medium
     EOF
     ```

1. Creación de su clúster.

   ```
   eksctl create cluster -f ipv6-cluster.yaml
   ```

   La creación del clúster tarda varios minutos. No continúe hasta que vea la última línea de salida, que se parece a la siguiente salida.

   ```
   [...]
   [✓]  EKS cluster "my-cluster" in "region-code" region is ready
   ```

1. Confirme que a los pods predeterminados se les asignan direcciones `IPv6`.

   ```
   kubectl get pods -n kube-system -o wide
   ```

   Un ejemplo de salida sería el siguiente.

   ```
   NAME                       READY   STATUS    RESTARTS   AGE     IP                                       NODE                                            NOMINATED NODE   READINESS GATES
   aws-node-rslts             1/1     Running   1          5m36s   2600:1f13:b66:8200:11a5:ade0:c590:6ac8   ip-192-168-34-75.region-code.compute.internal   <none>           <none>
   aws-node-t74jh             1/1     Running   0          5m32s   2600:1f13:b66:8203:4516:2080:8ced:1ca9   ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   coredns-85d5b4454c-cw7w2   1/1     Running   0          56m     2600:1f13:b66:8203:34e5::                ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   coredns-85d5b4454c-tx6n8   1/1     Running   0          56m     2600:1f13:b66:8203:34e5::1               ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   kube-proxy-btpbk           1/1     Running   0          5m36s   2600:1f13:b66:8200:11a5:ade0:c590:6ac8   ip-192-168-34-75.region-code.compute.internal   <none>           <none>
   kube-proxy-jjk2g           1/1     Running   0          5m33s   2600:1f13:b66:8203:4516:2080:8ced:1ca9   ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   ```

1. Confirme que a los servicios predeterminados se les asignan direcciones `IPv6`.

   ```
   kubectl get services -n kube-system -o wide
   ```

   Un ejemplo de salida sería el siguiente.

   ```
   NAME       TYPE        CLUSTER-IP          EXTERNAL-IP   PORT(S)         AGE   SELECTOR
   kube-dns   ClusterIP   fd30:3087:b6c2::a   <none>        53/UDP,53/TCP   57m   k8s-app=kube-dns
   ```

1. (Opcional) [Implemente una aplicación de muestra](sample-deployment.md) o implemente el [Controlador del equilibrador de carga de AWS](aws-load-balancer-controller.md) y una aplicación de muestra para equilibrar la carga de aplicaciones HTTP con [Redirección de tráfico de aplicaciones y HTTP con los equilibradores de carga de aplicaciones](alb-ingress.md) o el tráfico de red con [Dirija el tráfico de TCP y UDP con equilibradores de carga de red](network-load-balancing.md) en pods de `IPv6`.

1. Cuando haya terminado con el clúster y los nodos que creó para este tutorial, debería limpiar los recursos que creó con el siguiente comando.

   ```
   eksctl delete cluster my-cluster
   ```

## Implementación de un clúster IPv6 con la CLI de AWS
<a name="deploy_an_ipv6_cluster_with_shared_aws_cli"></a>

**importante**  
Debe completar todos los pasos de este procedimiento como el mismo usuario. Ejecute el siguiente comando para comprobar el usuario actual:  

  ```
  aws sts get-caller-identity
  ```
Debe completar todos los pasos de este procedimiento en el mismo intérprete de comandos. Varios pasos utilizan variables establecidas en pasos anteriores. Los pasos que utilizan variables no funcionarán de forma adecuada si los valores de las variables se establecen en un intérprete de comandos diferente. Si utiliza [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) para completar el siguiente procedimiento, recuerde que, si no interactúa con él a través del teclado o el puntero durante 20 o 30 minutos aproximadamente, se cerrará la sesión del intérprete de comandos. Los procesos en ejecución no cuentan como interacciones.
Las instrucciones están escritas para el intérprete de comandos Bash y es posible que deban ajustarse para otros intérpretes de comandos.

Reemplace todos los valores de ejemplo en los pasos de este procedimiento por sus propios valores.

1. Ejecute los siguientes comandos para establecer algunas variables utilizadas en pasos posteriores. Reemplace *region-code* por la región de AWS en la que desea implementar sus recursos. El valor puede ser cualquier región de AWS que sea compatible con Amazon EKS. Para ver una lista de las regiones de AWS, consulte [Puntos de conexión y cuotas de Amazon EKS](https://docs.aws.amazon.com/general/latest/gr/eks.html) en la Guía de referencia general de AWS. Reemplace *my-cluster* por el nombre de su clúster. El nombre solo puede contener caracteres alfanuméricos (con distinción de mayúsculas y minúsculas) y guiones. Debe comenzar con un carácter alfanumérico y no puede tener más de 100 caracteres. El nombre debe ser único dentro de la región de AWS y la cuenta de AWS en las que va a crear el clúster. Reemplace *my-nodegroup* con un nombre para su grupo de nodos. El nombre del grupo de nodos no puede tener más de 63 caracteres. Debe empezar por una letra o un dígito, pero también puede incluir guiones y guiones bajos como caracteres no iniciales. Reemplace *111122223333* por el ID de su cuenta.

   ```
   export region_code=region-code
   export cluster_name=my-cluster
   export nodegroup_name=my-nodegroup
   export account_id=111122223333
   ```

1. Cree una Amazon VPC con subredes privadas y públicas que cumplan con los requisitos de Amazon EKS y `IPv6`.

   1. Ejecute el siguiente comando para establecer una variable para el nombre de su pila de AWS CloudFormation. Puede reemplazar *my-eks-ipv6-vpc* por el nombre que elija.

      ```
      export vpc_stack_name=my-eks-ipv6-vpc
      ```

   1. Creación de una VPC `IPv6` a partir de una plantilla de AWS CloudFormation.

      ```
      aws cloudformation create-stack --region $region_code --stack-name $vpc_stack_name \
        --template-url https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/amazon-eks-ipv6-vpc-public-private-subnets.yaml
      ```

      La pila tarda unos minutos en crearse. Ejecute el siguiente comando. No continúe con el siguiente paso hasta que la salida del comando sea `CREATE_COMPLETE`.

      ```
      aws cloudformation describe-stacks --region $region_code --stack-name $vpc_stack_name --query Stacks[].StackStatus --output text
      ```

   1. Recupere los ID de las subredes públicas que se crearon.

      ```
      aws cloudformation describe-stacks --region $region_code --stack-name $vpc_stack_name \
          --query='Stacks[].Outputs[?OutputKey==`SubnetsPublic`].OutputValue' --output text
      ```

      Un ejemplo de salida sería el siguiente.

      ```
      subnet-0a1a56c486EXAMPLE,subnet-099e6ca77aEXAMPLE
      ```

   1. Habilite la opción de asignación automática de direcciones `IPv6` para las subredes públicas que se crearon.

      ```
      aws ec2 modify-subnet-attribute --region $region_code --subnet-id subnet-0a1a56c486EXAMPLE --assign-ipv6-address-on-creation
      aws ec2 modify-subnet-attribute --region $region_code --subnet-id subnet-099e6ca77aEXAMPLE --assign-ipv6-address-on-creation
      ```

   1. Recupere los nombres de las subredes y los grupos de seguridad creados mediante la plantilla desde la pila de AWS implementada y almacénelos en variables para utilizarlos en un paso posterior.

      ```
      security_groups=$(aws cloudformation describe-stacks --region $region_code --stack-name $vpc_stack_name \
          --query='Stacks[].Outputs[?OutputKey==`SecurityGroups`].OutputValue' --output text)
      
      public_subnets=$(aws cloudformation describe-stacks --region $region_code --stack-name $vpc_stack_name \
          --query='Stacks[].Outputs[?OutputKey==`SubnetsPublic`].OutputValue' --output text)
      
      private_subnets=$(aws cloudformation describe-stacks --region $region_code --stack-name $vpc_stack_name \
          --query='Stacks[].Outputs[?OutputKey==`SubnetsPrivate`].OutputValue' --output text)
      
      subnets=${public_subnets},${private_subnets}
      ```

1. Cree un rol de IAM de clúster y adjúntelo a la política administrada de IAM de Amazon EKS. Los clústeres de Kubernetes administrados por Amazon EKS realizan llamadas a otros servicios de AWS en su nombre para administrar los recursos que utiliza con el servicio.

   1. Ejecute el siguiente comando para crear un archivo `eks-cluster-role-trust-policy.json`.

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

   1. Ejecute el siguiente comando para establecer una variable para el nombre de su rol. Puede reemplazar *myAmazonEKSClusterRole* por cualquier nombre que elija.

      ```
      export cluster_role_name=myAmazonEKSClusterRole
      ```

   1. Creación del rol.

      ```
      aws iam create-role --role-name $cluster_role_name --assume-role-policy-document file://"eks-cluster-role-trust-policy.json"
      ```

   1. Recupere el ARN del rol de IAM y almacénelo en una variable para un paso posterior.

      ```
      CLUSTER_IAM_ROLE=$(aws iam get-role --role-name $cluster_role_name --query="Role.Arn" --output text)
      ```

   1. Adjunte la política administrada de IAM por Amazon EKS requerida al rol.

      ```
      aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEKSClusterPolicy --role-name $cluster_role_name
      ```

1. Creación de su clúster.

   ```
   aws eks create-cluster --region $region_code --name $cluster_name --kubernetes-version 1.XX \
      --role-arn $CLUSTER_IAM_ROLE --resources-vpc-config subnetIds=$subnets,securityGroupIds=$security_groups \
      --kubernetes-network-config ipFamily=ipv6
   ```

   1. NOTA: Es posible que reciba un error que indique que una de las zonas de disponibilidad de su solicitud no tiene capacidad suficiente para crear un clúster de Amazon EKS. Si esto ocurre, el mensaje de error indicará las zonas de disponibilidad que admiten un clúster nuevo. Intente crear el clúster de nuevo con al menos dos subredes ubicadas en las zonas de disponibilidad admitidas para su cuenta. Para obtener más información, consulte [Capacidad insuficiente](troubleshooting.md#ice).

      El clúster tarda varios minutos en crearse. Ejecute el siguiente comando. No continúe con el siguiente paso hasta que la salida del comando sea `ACTIVE`.

      ```
      aws eks describe-cluster --region $region_code --name $cluster_name --query cluster.status
      ```

1. Creación o actualización de un archivo `kubeconfig` para su clúster para que pueda comunicarse con él.

   ```
   aws eks update-kubeconfig --region $region_code --name $cluster_name
   ```

   De forma predeterminada, el archivo de `config` se crea en `~/.kube` o la configuración del clúster nuevo se agrega a un archivo de `config` existente en `~/.kube`.

1. Creación de un rol de IAM de nodo.

   1. Ejecute el siguiente comando para crear un archivo `vpc-cni-ipv6-policy.json`.

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ec2:AssignIpv6Addresses",
                      "ec2:DescribeInstances",
                      "ec2:DescribeTags",
                      "ec2:DescribeNetworkInterfaces",
                      "ec2:DescribeInstanceTypes"
                  ],
                  "Resource": "*"
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "ec2:CreateTags"
                  ],
                  "Resource": [
                      "arn:aws:ec2:*:*:network-interface/*"
                  ]
              }
          ]
      }
      ```

   1. Creación de la política de IAM.

      ```
      aws iam create-policy --policy-name AmazonEKS_CNI_IPv6_Policy --policy-document file://vpc-cni-ipv6-policy.json
      ```

   1. Ejecute el siguiente comando para crear un archivo `node-role-trust-relationship.json`.

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

   1. Ejecute el siguiente comando para establecer una variable para el nombre de su rol. Puede reemplazar *AmazonEKSNodeRole* por el nombre que elija.

      ```
      export node_role_name=AmazonEKSNodeRole
      ```

   1. Creación del rol de IAM.

      ```
      aws iam create-role --role-name $node_role_name --assume-role-policy-document file://"node-role-trust-relationship.json"
      ```

   1. Adjunte la política de IAM al rol de IAM.

      ```
      aws iam attach-role-policy --policy-arn arn:aws:iam::$account_id:policy/AmazonEKS_CNI_IPv6_Policy \
          --role-name $node_role_name
      ```
**importante**  
Para simplificar este tutorial, la política se adjunta a este rol de IAM. Sin embargo, en un clúster de producción, recomendamos adjuntar la política a un rol de IAM independiente. Para obtener más información, consulte [Configuración del complemento de CNI de Amazon VPC para utilizar IRSA](cni-iam-role.md).

   1. Adjunte al rol de IAM las dos políticas administradas por IAM necesarias.

      ```
      aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy \
        --role-name $node_role_name
      aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly \
        --role-name $node_role_name
      ```

   1. Recupere el ARN del rol de IAM y almacénelo en una variable para un paso posterior.

      ```
      node_iam_role=$(aws iam get-role --role-name $node_role_name --query="Role.Arn" --output text)
      ```

1. Creación de un grupo de nodos administrados.

   1. Visualización de los ID de las subredes que creó en un paso anterior.

      ```
      echo $subnets
      ```

      Un ejemplo de salida sería el siguiente.

      ```
      subnet-0a1a56c486EXAMPLE,subnet-099e6ca77aEXAMPLE,subnet-0377963d69EXAMPLE,subnet-0c05f819d5EXAMPLE
      ```

   1. Creación de grupo de nodos. Sustituya *0a1a56c486EXAMPLE*, *099e6ca77aEXAMPLE*, *0377963d69EXAMPLE* y *0c05f819d5EXAMPLE* por los valores devueltos en la salida del paso anterior. Asegúrese de eliminar las comas entre los ID de subredes de la salida anterior en el siguiente comando. Puede reemplazar *t3.medium* por cualquier [tipo de instancia de AWS Nitro System](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances).

      ```
      aws eks create-nodegroup --region $region_code --cluster-name $cluster_name --nodegroup-name $nodegroup_name \
          --subnets subnet-0a1a56c486EXAMPLE subnet-099e6ca77aEXAMPLE subnet-0377963d69EXAMPLE subnet-0c05f819d5EXAMPLE \
          --instance-types t3.medium --node-role $node_iam_role
      ```

      El grupo de nodos tarda unos minutos en crearse. Ejecute el siguiente comando. No continúe con el siguiente paso hasta que la salida devuelta sea `ACTIVE`.

      ```
      aws eks describe-nodegroup --region $region_code --cluster-name $cluster_name --nodegroup-name $nodegroup_name \
          --query nodegroup.status --output text
      ```

1. Confirme que a los pods predeterminados se les asignen direcciones `IPv6` en la columna `IP`.

   ```
   kubectl get pods -n kube-system -o wide
   ```

   Un ejemplo de salida sería el siguiente.

   ```
   NAME                       READY   STATUS    RESTARTS   AGE     IP                                       NODE                                            NOMINATED NODE   READINESS GATES
   aws-node-rslts             1/1     Running   1          5m36s   2600:1f13:b66:8200:11a5:ade0:c590:6ac8   ip-192-168-34-75.region-code.compute.internal   <none>           <none>
   aws-node-t74jh             1/1     Running   0          5m32s   2600:1f13:b66:8203:4516:2080:8ced:1ca9   ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   coredns-85d5b4454c-cw7w2   1/1     Running   0          56m     2600:1f13:b66:8203:34e5::                ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   coredns-85d5b4454c-tx6n8   1/1     Running   0          56m     2600:1f13:b66:8203:34e5::1               ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   kube-proxy-btpbk           1/1     Running   0          5m36s   2600:1f13:b66:8200:11a5:ade0:c590:6ac8   ip-192-168-34-75.region-code.compute.internal   <none>           <none>
   kube-proxy-jjk2g           1/1     Running   0          5m33s   2600:1f13:b66:8203:4516:2080:8ced:1ca9   ip-192-168-253-70.region-code.compute.internal  <none>           <none>
   ```

1. Confirme que a los servicios predeterminados se les asignen direcciones `IPv6` en la columna `IP`.

   ```
   kubectl get services -n kube-system -o wide
   ```

   Un ejemplo de salida sería el siguiente.

   ```
   NAME       TYPE        CLUSTER-IP          EXTERNAL-IP   PORT(S)         AGE   SELECTOR
   kube-dns   ClusterIP   fd30:3087:b6c2::a   <none>        53/UDP,53/TCP   57m   k8s-app=kube-dns
   ```

1. (Opcional) [Implemente una aplicación de muestra](sample-deployment.md) o implemente el [Controlador del equilibrador de carga de AWS](aws-load-balancer-controller.md) y una aplicación de muestra para equilibrar la carga de aplicaciones HTTP con [Redirección de tráfico de aplicaciones y HTTP con los equilibradores de carga de aplicaciones](alb-ingress.md) o el tráfico de red con [Dirija el tráfico de TCP y UDP con equilibradores de carga de red](network-load-balancing.md) en pods de `IPv6`.

1. Cuando haya terminado con el clúster y los nodos que creó para este tutorial, debería limpiar los recursos que creó con los siguientes comandos. Asegúrese de no estar utilizando ninguno de los recursos fuera de este tutorial antes de eliminarlos.

   1. Si realiza este paso en un intérprete de comandos diferente al que utilizó para completar los pasos anteriores, establezca los valores de todas las variables utilizadas previamente y reemplace los valores de ejemplo por los que especificó en los pasos anteriores. Si está completando este paso en el mismo intérprete de comandos en el que completó los pasos anteriores, vaya al siguiente paso.

      ```
      export region_code=region-code
      export vpc_stack_name=my-eks-ipv6-vpc
      export cluster_name=my-cluster
      export nodegroup_name=my-nodegroup
      export account_id=111122223333
      export node_role_name=AmazonEKSNodeRole
      export cluster_role_name=myAmazonEKSClusterRole
      ```

   1. Eliminación de su grupo de nodos.

      ```
      aws eks delete-nodegroup --region $region_code --cluster-name $cluster_name --nodegroup-name $nodegroup_name
      ```

      La eliminación tarda unos minutos. Ejecute el siguiente comando. No continúe con el siguiente paso si se devuelve alguna salida.

      ```
      aws eks list-nodegroups --region $region_code --cluster-name $cluster_name --query nodegroups --output text
      ```

   1. Elimine el clúster.

      ```
      aws eks delete-cluster --region $region_code --name $cluster_name
      ```

      El clúster tarda unos minutos en eliminarse. Antes de continuar, asegúrese de que el clúster se elimine con el siguiente comando.

      ```
      aws eks describe-cluster --region $region_code --name $cluster_name
      ```

      No continúe con el siguiente paso hasta que la salida sea similar a la siguiente.

      ```
      An error occurred (ResourceNotFoundException) when calling the DescribeCluster operation: No cluster found for name: my-cluster.
      ```

   1. Eliminación de los resultados de IAM que creó. Reemplace *AmazonEKS\$1CNI\$1IPv6\$1Policy* por el nombre que eligió si eligió un nombre diferente al que utilizó en los pasos anteriores.

      ```
      aws iam detach-role-policy --role-name $cluster_role_name --policy-arn arn:aws:iam::aws:policy/AmazonEKSClusterPolicy
      aws iam detach-role-policy --role-name $node_role_name --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
      aws iam detach-role-policy --role-name $node_role_name --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly
      aws iam detach-role-policy --role-name $node_role_name --policy-arn arn:aws:iam::$account_id:policy/AmazonEKS_CNI_IPv6_Policy
      aws iam delete-policy --policy-arn arn:aws:iam::$account_id:policy/AmazonEKS_CNI_IPv6_Policy
      aws iam delete-role --role-name $cluster_role_name
      aws iam delete-role --role-name $node_role_name
      ```

   1. Eliminación de la pila de AWS CloudFormation que creó la VPC.

      ```
      aws cloudformation delete-stack --region $region_code --stack-name $vpc_stack_name
      ```