Amazon ya no CodeCatalyst está abierto a nuevos clientes. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte [Cómo migrar desde CodeCatalyst](migration.md).

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.

# Implementación en Amazon EKS con un flujo de trabajo
<a name="deploy-action-eks"></a>

**sugerencia**  
Para ver un tutorial que muestra cómo utilizar la acción **Implementar en clúster de Kubernetes**, consulte [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md).

En esta sección, se describe cómo implementar una aplicación en contenedores en un clúster de Kubernetes mediante un flujo de trabajo. CodeCatalyst Para ello, debe añadir la acción **Implementar en clúster de Kubernetes** a su flujo de trabajo. Esta acción implementa la aplicación en un clúster de Kubernetes que haya configurado en Amazon Elastic Kubernetes Service (EKS) mediante uno o varios archivos de manifiesto de Kubernetes. Para ver un manifiesto de ejemplo, consulte [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) en [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md).

Para obtener más información sobre Kubernetes, consulte la [documentación de Kubernetes](https://kubernetes.io/docs/home/).

Para obtener más información sobre Amazon EKS, consulte [¿Qué es Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) en la *Guía del usuario de Amazon EKS*.

**Topics**
+ [Cómo funciona la acción 'Implementar en clúster de Kubernetes'](#deploy-action-eks-howitworks)
+ [Imagen del entorno en tiempo de ejecución utilizada por la acción 'Implementar en Amazon EKS'](#deploy-action-eks-runtime)
+ [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md)
+ [Incorporación de la acción 'Implementar en clúster de Kubernetes'](deploy-action-eks-adding.md)
+ [Variables de 'Implementar en clúster de Kubernetes'](deploy-action-eks-variables.md)
+ [Acción 'Implementar en clúster de Kubernetes' de YAML](deploy-action-ref-eks.md)

## Cómo funciona la acción 'Implementar en clúster de Kubernetes'
<a name="deploy-action-eks-howitworks"></a>

La acción **Implementar en clúster de Kubernetes** funciona de la siguiente manera:

1. En tiempo de ejecución, la acción instala la `kubectl` utilidad Kubernetes en la máquina de procesamiento en la que se ejecuta la acción. CodeCatalyst La acción configura `kubectl` para que apunte al clúster de Amazon EKS que proporcionó al configurar la acción. A continuación, se necesita la utilidad `kubectl` para ejecutar el comando `kubectl apply`.

1. La acción ejecuta el `kubectl apply -f my-manifest.yaml` comando, que ejecuta las instrucciones *my-manifest.yaml* para implementar la aplicación como un conjunto de contenedores y pods en el clúster configurado. Para obtener más información sobre este comando, consulte el tema [kubectl apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply) en la *documentación de referencia de Kubernetes*.

## Imagen del entorno en tiempo de ejecución utilizada por la acción 'Implementar en Amazon EKS'
<a name="deploy-action-eks-runtime"></a>

La acción **Implementar en Amazon EKS** se ejecuta en una [imagen de noviembre de 2022](build-images.md#build.previous-image). Para obtener más información, consulte [Imágenes activas](build-images.md#build-curated-images).

# Tutorial: implementación de una aplicación en Amazon EKS
<a name="deploy-tut-eks"></a>

En este tutorial, aprenderá a implementar una aplicación en contenedores en Amazon Elastic Kubernetes Service mediante CodeCatalyst un flujo de trabajo de Amazon, Amazon EKS y algunos otros servicios. AWS La aplicación implementada es un sencillo sitio web “Hello, World\$1” creado a partir de una imagen de Docker del servidor web Apache. El tutorial explica el trabajo de preparación necesario, como la configuración de una máquina de desarrollo y un clúster de Amazon EKS, y luego describe cómo crear un flujo de trabajo para crear la aplicación e implementarla en el clúster.

Una vez completada la implementación inicial, el tutorial le indica cómo realizar un cambio en el código fuente de la aplicación. Este cambio hace que se cree una nueva imagen de Docker y se envíe a su repositorio de imágenes de Docker con la nueva información de revisión. A continuación, la nueva revisión de la imagen de Docker se implementa en Amazon EKS.

**sugerencia**  
En lugar de seguir este tutorial, puede utilizar un esquema que realice una configuración completa de Amazon EKS por usted. Deberá utilizar el esquema **Implementación de aplicaciones de EKS**. Para obtener más información, consulte [Creación de un proyecto con un esquema](projects-create.md#projects-create-console-template).

**Topics**
+ [Requisitos previos](#deploy-tut-eks-prereqs)
+ [Paso 1: configuración de la máquina de desarrollo](#deploy-tut-eks-dev-env-create)
+ [Paso 2: creación de un clúster de Amazon EKS](#deploy-tut-eks-cluster)
+ [Paso 3: creación de un repositorio de imágenes de Amazon ECR](#deploy-tut-eks-ecr)
+ [Paso 4: incorporación de archivos de código fuente](#deploy-tut-eks-source-files)
+ [Paso 5: Crear roles AWS](#deploy-tut-eks-roles)
+ [Paso 6: Añadir AWS roles a CodeCatalyst](#deploy-tut-eks-import-roles)
+ [Paso 7: actualice el ConfigMap](#deploy-tut-eks-configmap)
+ [Paso 8: creación y ejecución de un flujo de trabajo](#deploy-tut-eks-workflow)
+ [Paso 9: realización de un cambio en los archivos de código fuente](#deploy-tut-eks-change)
+ [Limpieza](#deploy-tut-eks-cleanup)

## Requisitos previos
<a name="deploy-tut-eks-prereqs"></a>

Antes de comenzar este tutorial:
+ Necesitas un CodeCatalyst **espacio** en Amazon con una AWS cuenta conectada. Para obtener más información, consulte [Creación de un espacio](spaces-create.md).
+ En su espacio, necesita un proyecto vacío llamado:

  ```
  codecatalyst-eks-project
  ```

  Use la opción **Empezar desde cero** para crear este proyecto.

  Para obtener más información, consulte [Crear un proyecto vacío en Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ En tu proyecto, necesitas un **repositorio de CodeCatalyst código fuente** vacío llamado:

  ```
  codecatalyst-eks-source-repository
  ```

  Para obtener más información, consulte [Almacene código y colabore en él con los repositorios de código fuente en CodeCatalystAlmacenamiento de código y colaboración con los repositorios de código fuente](source.md).
+ En su proyecto, necesita un entorno de CodeCatalyst CI/CD (no un **entorno** de desarrollo) llamado:

  ```
  codecatalyst-eks-environment
  ```

  Configure este entorno de la siguiente manera:
  + Elija cualquier tipo, como **Sin producción**.
  + Conecta tu AWS cuenta a ella. 
  + En **Rol de IAM predeterminado**, elija cualquier rol. Especificará un rol diferente más adelante.

  Para obtener más información, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md).

## Paso 1: configuración de la máquina de desarrollo
<a name="deploy-tut-eks-dev-env-create"></a>

El primer paso de este tutorial consiste en configurar una máquina de desarrollo con algunas herramientas que utilizará a lo largo de este tutorial. Estos roles son:
+ la utilidad `eksctl`: para la creación del clúster
+ la utilidad `kubectl`: un requisito previo para `eksctl`
+ el AWS CLI ... también es un requisito previo para `eksctl`

Puede instalar estas herramientas en su máquina de desarrollo actual si tiene una, o puede usar un entorno de CodeCatalyst desarrollo, que está basado en la nube. La ventaja de un CodeCatalyst entorno de desarrollo es que es fácil de configurar y desmontar, y está integrado con otros CodeCatalyst servicios, lo que te permite completar este tutorial en menos pasos.

En este tutorial se asume que utilizarás un entorno CodeCatalyst de desarrollo.

Las siguientes instrucciones describen una forma rápida de lanzar un CodeCatalyst entorno de desarrollo y configurarlo con las herramientas necesarias, pero si desea obtener instrucciones detalladas, consulte:
+ [Creación de un entorno de desarrollo](devenvironment-create.md) en esta guía.
+ [Instalación de kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) en la **Guía del usuario de Amazon EKS**.
+ [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**.
+ [Instalación o actualización de la versión más reciente de 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 *.

**Lanzamiento de un entorno de desarrollo**

1. Abra la CodeCatalyst consola en [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Vaya a su proyecto, `codecatalyst-eks-project`.

1. En el panel de navegación, elija **Código** y, a continuación, elija **Repositorios de origen**. 

1. Elija el nombre del repositorio de código fuente, `codecatalyst-eks-source-repository`.

1. Cerca de la parte superior, elija **Crear entorno de desarrollo** y, a continuación, elija **AWS Cloud9 (en el navegador)**.

1. Asegúrese de que estén seleccionadas la opción **Trabajar en una ramificación existente** y la ramificación **principal** y, a continuación, elija **Crear**.

   Su entorno de desarrollo se abre en una nueva pestaña del navegador y el repositorio (`codecatalyst-eks-source-repository`) se clona en él.

**Instalación y configuración de kubectl**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. Escriba:

   ```
   chmod +x ./kubectl
   ```

1. Escriba:

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. Escriba:

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. Escriba:

   ```
   kubectl version --short --client
   ```

1. Compruebe que aparezca una versión.

   Ahora ha instalado `kubectl`.

**Instalación y configuración de eksctl**
**nota**  
`eksctl` no es estrictamente obligatorio porque se puede utilizar `kubectl` en su lugar. Sin embargo, `eksctl` tiene la ventaja de automatizar gran parte de la configuración del clúster y, por lo tanto, es la herramienta recomendada para este tutorial.

1. En el terminal del entorno de desarrollo, escriba:

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. Escriba:

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Escriba:

   ```
   eksctl version
   ```

1. Compruebe que aparezca una versión.

   Ahora ha instalado `eksctl`.

**Para comprobar que AWS CLI está instalado**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   aws --version
   ```

1. Compruebe que aparezca una versión para comprobar que AWS CLI está instalada.

   Complete los procedimientos restantes para configurarlo AWS CLI con los permisos de acceso necesarios AWS.

**Para configurar el AWS CLI**

Debe configurarlo AWS CLI con claves de acceso y un token de sesión para darle acceso a AWS los servicios. Las siguientes instrucciones proporcionan una forma rápida de configurar las claves y el token, pero si desea obtener instrucciones detalladas, consulte [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) en la *Guía del usuario de AWS Command Line Interface *.

1. Cree un usuario de IAM Identity Center del modo siguiente:

   1. Inicie sesión en Consola de administración de AWS y abra la AWS IAM Identity Center consola en [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).

      (Puede que tenga que seleccionar **Activar** si nunca ha iniciado sesión en IAM Identity Center con anterioridad).
**nota**  
Asegúrate de iniciar sesión con el Cuenta de AWS que está conectado a tu CodeCatalyst espacio. Para comprobar qué cuenta está conectada, vaya a su espacio y elija la pestaña **Cuentas de AWS**. Para obtener más información, consulte [Creación de un espacio](spaces-create.md).

   1. En el panel de navegación, elija **Users** y luego elija la opción **Add user**.

   1. En **Nombre de usuario**, escriba:

      ```
      codecatalyst-eks-user
      ```

   1. En **Contraseña**, elija **Generar una contraseña de un solo uso que pueda compartir con este usuario**.

   1. En **Dirección de correo electrónico** y **Confirmar dirección de correo electrónico**, introduzca una dirección de correo electrónico que no exista aún en IAM Identity Center.

   1. En **Nombre**, escriba:

      ```
      codecatalyst-eks-user
      ```

   1. En **Apellidos**, escriba:

      ```
      codecatalyst-eks-user
      ```

   1. En **Nombre de visualización**, mantenga:

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   1. Elija **Siguiente**.

   1. En la página **Agregar usuarios a grupos**, elija **Siguiente**.

   1. En la página **Revisar y agregar usuario**, compruebe la información que ha introducido y seleccione **Agregar usuario**.

      Aparece el cuadro de diálogo **Contraseña de un solo uso**.

   1. Seleccione **Copiar** y, a continuación, pegue la información de inicio de sesión en un archivo de texto. La información de inicio de sesión consta de la URL del portal de AWS acceso, un nombre de usuario y una contraseña de un solo uso.

   1. Seleccione **Cerrar**.

1. Cree un conjunto de permisos de la siguiente manera:

   1. En el panel de navegación, elija **Conjuntos de permisos** y, a continuación, elija **Crear conjunto de permisos**.

   1. Elija un conjunto **de permisos predefinido** y, a continuación, seleccione **AdministratorAccess**. Esta política concede permisos completos a todos los Servicios de AWS. 

   1. Elija **Siguiente**.

   1. En **Nombre del conjunto de permisos**, elimine `AdministratorAccess` e introduzca:

      ```
      codecatalyst-eks-permission-set
      ```

   1. Elija **Siguiente**.

   1. En la página **Revisión**, revise la información y, a continuación, elija **Crear grupo**.

1. Asigne el conjunto de permisos a `codecatalyst-eks-user` de la siguiente manera:

   1. En el panel de navegación, elija y **Cuentas de AWS**, a continuación, active la casilla de verificación situada junto a la casilla en la Cuenta de AWS que ha iniciado sesión actualmente.

   1. Seleccione **Asignar usuarios o grupos**.

   1. Elija la pestaña **Users**.

   1. Seleccione la casilla situada junto a `codecatalyst-eks-user`.

   1. Elija **Siguiente**.

   1. Seleccione la casilla situada junto a `codecatalyst-eks-permission-set`.

   1. Elija **Siguiente**.

   1. Revise la información y seleccione **Enviar**.

      Ahora tienes asignada `codecatalyst-eks-user` y `codecatalyst-eks-permission-set` a la tuya Cuenta de AWS, uniéndolas.

1. Obtenga las claves de acceso de `codecatalyst-eks-user` y el token de sesión de la siguiente manera:

   1. Asegúrese de tener la URL del portal de AWS acceso y el nombre de usuario y la contraseña de un solo uso del mismo`codecatalyst-eks-user`. Debería haber copiado esta información en un editor de texto anteriormente.
**nota**  
Si no dispone de esta información, vaya a la página de detalles de `codecatalyst-eks-user` en IAM Identity Center, elija **Restablecer contraseña**, **Generar una contraseña de un solo uso [...]** y de nuevo **Restablecer contraseña** para que aparezca la información en la pantalla.

   1. Cerrar sesión en AWS.

   1. Pegue la URL del portal de AWS acceso en la barra de direcciones del navegador.

   1. Inicie sesión con:
      + **Nombre de usuario**:

        ```
        codecatalyst-eks-user
        ```
      + **Contraseña**:

        *one-time-password*

   1. En **Establecer nueva contraseña**, introduzca una nueva contraseña y elija **Establecer nueva contraseña**.

      Aparece un cuadro de **Cuenta de AWS** en la pantalla.

   1. Elija **Cuenta de AWS** y, a continuación, elija el nombre de la Cuenta de AWS a la que asignó el usuario `codecatalyst-eks-user` y el conjunto de permisos.

   1. Junto a `codecatalyst-eks-permission-set`, seleccione **Línea de comandos o acceso mediante programación**.

   1. Copie los comandos del centro de la página. Tendrán un aspecto similar al siguiente:

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... donde *session-token* hay una cadena aleatoria larga.

1. Añada las claves de acceso y el token de sesión al AWS CLI, de la siguiente manera:

   1. Regrese a su CodeCatalyst entorno de desarrollo.

   1. En la línea de comandos del terminal, pegue los comandos que ha copiado. Pulse Intro.

      Ahora lo ha configurado AWS CLI con claves de acceso y un token de sesión. Ahora puede utilizarla AWS CLI para completar las tareas requeridas en este tutorial.
**importante**  
Si en algún momento de este tutorial ve mensajes similares a:  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
O bien:  
`ExpiredToken: The security token included in the request is expired`  
... es porque tu AWS CLI sesión ha caducado. En este caso, *no* ejecute el comando `aws configure`. En lugar de ello, siga las instrucciones del paso 4 de este procedimiento, que comienza con `Obtain codecatalyst-eks-user's access key and session token` para actualizar la sesión.

## Paso 2: creación de un clúster de Amazon EKS
<a name="deploy-tut-eks-cluster"></a>

En esta sección, creará un clúster en Amazon EKS. En las instrucciones siguientes se describe una forma rápida de crear el clúster mediante `eksctl`, pero si desea obtener instrucciones detalladas, consulte:
+ [Introducción a eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) en la **Guía del usuario de Amazon EKS**

  o
+ [Introducción a la consola y a la AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) en la **Guía del usuario de Amazon EKS** (en este tema se proporcionan instrucciones de `kubectl` para crear el clúster) 

**nota**  
La CodeCatalyst integración con Amazon EKS no admite [clústeres privados](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html).

**Antes de empezar**

Asegúrese de haber realizado las siguientes tareas en su máquina de desarrollo:
+ Ha instalado la utilidad `eksctl`.
+ Ha instalado la utilidad `kubectl`.
+ Lo instalé AWS CLI y lo configuré con claves de acceso y un token de sesión.

Para obtener más información sobre como realizar estas tareas, consulte [Paso 1: configuración de la máquina de desarrollo](#deploy-tut-eks-dev-env-create).

**Para crear un clúster**
**importante**  
No utilice la interfaz de usuario del servicio de Amazon EKS para crear el clúster, ya que el clúster no se configurará correctamente. Utilice la utilidad `eksctl` tal y como se describe en los pasos siguientes.

1. Vaya a su entorno de desarrollo.

1. Cree un clúster y los nodos:

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   Donde:
   + *codecatalyst-eks-cluster*se sustituye por el nombre que desee darle a su clúster.
   + *us-west-2*se sustituye por tu región.

   Después de 10-20 minutos, aparecerá un mensaje similar al siguiente: 

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**nota**  
Verá varios mensajes `waiting for CloudFormation stack` mientras AWS crea el clúster. Esto es normal.

1. Compruebe que el clúster se haya creado correctamente:

   ```
   kubectl cluster-info
   ```

   Verá un mensaje similar al siguiente, que indica que la creación del clúster se ha realizado correctamente:

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

## Paso 3: creación de un repositorio de imágenes de Amazon ECR
<a name="deploy-tut-eks-ecr"></a>

En esta sección, creará un repositorio de imágenes privado en Amazon Elastic Container Registry (Amazon ECR). Este repositorio almacena la imagen de Docker del tutorial.

Para obtener más información sobre Amazon ECR, consulte la *Guía del usuario de Amazon Elastic Container Registry*.

**Creación de un repositorio de imágenes en Amazon ECR**

1. Vaya a su entorno de desarrollo.

1. Cree un repositorio vacío en Amazon ECR:

   ```
   aws ecr create-repository --repository-name codecatalyst-eks-image-repo
   ```

   *codecatalyst-eks-image-repo*Sustitúyalo por el nombre que desee asignar al repositorio de Amazon ECR.

   En este tutorial se asume que el repositorio se llama `codecatalyst-eks-image-repo`.

1. Muestre los detalles del repositorio de Amazon ECR:

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-eks-image-repo
   ```

1. Anote el valor de `“repositoryUri”:` (por ejemplo, `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo`).

   Lo necesitará más adelante cuando añada el repositorio a su flujo de trabajo. 

## Paso 4: incorporación de archivos de código fuente
<a name="deploy-tut-eks-source-files"></a>

En esta sección, añadirá los archivos de código fuente de la aplicación al repositorio de código fuente (`codecatalyst-eks-source-repository`). Constan de:
+ Un archivo `index.html`: muestra un mensaje “Hello, world\$1” en el navegador.
+ Un Dockerfile: describe la imagen base que se va a usar para la imagen de Docker y los comandos de Docker que se le aplicarán.
+ Un archivo `deployment.yaml`: el manifiesto de Kubernetes que define el servicio y la implementación de Kubernetes. 

La estructura de carpetas es la siguiente:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

### index.html
<a name="deploy-tut-eks-source-files-index"></a>

El archivo `index.html` muestra un mensaje “Hello, world\$1” en el navegador. 

**Adición del archivo index.html**

1. Vaya a su entorno de desarrollo.

1. En `codecatalyst-eks-source-repository`, cree una carpeta llamada `public-html`.

1. En `/public-html`, cree un archivo llamado `index.html` con el siguiente contenido:

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello, World!</h1>
     </body>
   </html>
   ```

1. En la línea de comandos del terminal, escriba:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

   El archivo `index.html` se añade al repositorio en una carpeta `public-html`. 

### Dockerfile
<a name="deploy-tut-eks-source-files-dockerfile"></a>

El Dockerfile describe la imagen base que se va a usar para la imagen de Docker y los comandos de Docker que se le aplicarán. Para obtener más información acerca del Dockerfile, consulte la [Referencia de Dockerfile](https://docs.docker.com/engine/reference/builder/).

El Dockerfile especificado aquí indica que se debe usar la imagen base de Apache 2.4 (`httpd`). También incluye instrucciones para copiar un archivo de código fuente llamado `index.html` en una carpeta del servidor de Apache que sirve páginas web. La instrucción `EXPOSE` del Dockerfile indica a Docker que el contenedor está escuchando en el puerto 80.

**Adición del Dockerfile**

1. En `codecatalyst-eks-source-repository`, cree un archivo llamado `Dockerfile` con el siguiente contenido:

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

   No incluya la extensión del archivo.
**importante**  
El Dockerfile debe residir en la carpeta raíz de su repositorio. El comando `Docker build` del flujo de trabajo espera que esté ahí.

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

   El Dockerfile se añade a su repositorio.

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

En esta sección, añadirá un archivo `deployment.yaml` al repositorio. El archivo `deployment.yaml` es un manifiesto de Kubernetes que define dos tipos o *clases* de recursos de Kubernetes que se van a ejecutar: un “servicio” y una “implementación”.
+ El “servicio” implementa un equilibrador de carga en Amazon EC2. El equilibrador de carga le proporciona una URL pública con acceso a Internet y un puerto estándar (puerto 80) que puede usar para examinar el mensaje “Hello, World\$1”. "Hello, World\$1". 
+ La “implementación” implementa tres pods y cada uno de ellos incluirá un contenedor de Docker con el mensaje “Hello, World\$1”. "Hello, World\$1". Los tres pods se implementan en los nodos que se crearon al crear el clúster.

El manifiesto de este tutorial es breve; sin embargo, un manifiesto puede incluir cualquier número de tipos de recursos de Kubernetes, como pods, trabajos, entradas y políticas de red. Además, puede usar varios archivos de manifiesto si la implementación es compleja.

**Adición de un archivo deployment.yaml**

1. En `codecatalyst-eks-source-repository`, cree una carpeta llamada `Kubernetes`.

1. En `/Kubernetes`, cree un archivo llamado `deployment.yaml` con el siguiente contenido:

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   El archivo `deployment.yaml` se añade al repositorio en una carpeta llamada `Kubernetes`. 

Ahora ha añadido todos los archivos de código fuente.

Dedique unos minutos a comprobar su trabajo y a asegurarse de que ha colocado todos los archivos en las carpetas correctas. La estructura de carpetas es la siguiente:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## Paso 5: Crear roles AWS
<a name="deploy-tut-eks-roles"></a>

En esta sección, creará las funciones de AWS IAM que necesitará su CodeCatalyst flujo de trabajo para funcionar. Estos roles son:
+ **Función de creación**: concede a la acción de CodeCatalyst creación (en el flujo de trabajo) permiso para acceder a su AWS cuenta y escribir en Amazon ECR y Amazon EC2.
+ **Función de implementación**: otorga a la acción CodeCatalyst **Implementar en el clúster de Kubernetes** (en el flujo de trabajo) el permiso para acceder a su cuenta AWS y a Amazon EKS.

Para obtener más información sobre los roles de IAM, consulte [Roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) en la *Guía del usuario de AWS Identity and Access Management *.

**nota**  
Para ahorrar tiempo, puede crear un único rol, denominado rol `CodeCatalystWorkflowDevelopmentRole-spaceName`, en lugar de los dos roles indicados anteriormente. Para obtener más información, consulte [Creación del rol **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para su cuenta y su espacio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tenga en cuenta que el rol `CodeCatalystWorkflowDevelopmentRole-spaceName` tiene permisos muy amplios, lo que puede suponer un riesgo para la seguridad. Le recomendamos que utilice este rol solo en tutoriales y situaciones en las que la seguridad no sea un problema. En este tutorial se presupone que va a crear los dos roles indicados anteriormente.

Para crear los roles de compilación e implementación, realice la siguiente serie de procedimientos.

**1. Creación de una política de confianza para ambos roles**

1. Vaya a su entorno de desarrollo.

1. En el directorio `Cloud9-long-string`, cree un archivo llamado `codecatalyst-eks-trust-policy.json` con el siguiente contenido:

**2. Creación de la política de compilación para el rol de compilación**
+ En el directorio `Cloud9-long-string`, cree un archivo llamado `codecatalyst-eks-build-policy.json` con el siguiente contenido:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "ecr:*",
                  "ec2:*"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**nota**  
La primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.  

  ```
  "Resource": "*"
  ```

**3. Creación de una política de implementación para el rol de implementación**
+ En el directorio `Cloud9-long-string`, cree un archivo llamado `codecatalyst-eks-deploy-policy.json` con el siguiente contenido:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**nota**  
La primera vez que utilice el rol para ejecutar acciones de flujo de trabajo, use el comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.  

  ```
  "Resource": "*"
  ```

Ahora ha añadido tres documentos de política a su entorno de desarrollo. La estructura de directorios ahora debería ser similar a la siguiente:

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. Para añadir la política de compilación a AWS**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   cd /projects
   ```

1. Escriba:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-build-policy \
       --policy-document file://codecatalyst-eks-build-policy.json
   ```

1. Pulse **Intro**.

1. En el resultado del comando, anote el valor de `"arn":` (por ejemplo, `arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy`). Necesitará este ARN más adelante.

**5. Para añadir la política de despliegue a AWS**

1. Escriba:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-deploy-policy \
       --policy-document file://codecatalyst-eks-deploy-policy.json
   ```

1. Pulse **Intro**.

1. En el resultado del comando, anote el valor de `"arn":` de la política de implementación (por ejemplo, `arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy`). Necesitará este ARN más adelante.

**6. Creación del rol de compilación**

1. Escriba: 

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-build-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. Pulse **Intro**.

1. Escriba:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-eks-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy
   ```

   Where *arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy* se sustituye por el ARN de la política de construcción que mencionaste anteriormente.

1. Pulse **Intro**.

1. En la línea de comandos del terminal, escriba:

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-build-role
   ```

1. Pulse **Intro**.

1. Anote el valor de `"Arn":` del rol (por ejemplo, `arn:aws:iam::111122223333:role/codecatalyst-eks-build-role`). Necesitará este ARN más adelante.

**7. Creación del rol de implementación**

1. Escriba:

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-deploy-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. Pulse **Intro**.

1. Escriba:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-eks-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy
   ```

   Where *arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy* se sustituye por el ARN de la política de despliegue que indicó anteriormente.

1. Pulse **Intro**.

1. Escriba:

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-deploy-role
   ```

1. Pulse **Intro**.

1. Anote el valor de `"Arn":` del rol (por ejemplo, `arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role`). Necesitará este ARN más adelante.

Ahora ha creado las funciones de creación e implementación y ha anotado sus ARNs funciones.

## Paso 6: Añadir AWS roles a CodeCatalyst
<a name="deploy-tut-eks-import-roles"></a>

En este paso, agrega el rol de compilación (`codecatalyst-eks-build-role`) y el rol de implementación (`codecatalyst-eks-deploy-role`) al rol Cuenta de AWS que conectó a su espacio. Esto permite que los roles se puedan usar en el flujo de trabajo.

**Para añadir funciones de creación e implementación a su Cuenta de AWS**

1. En la CodeCatalyst consola, navega hasta tu espacio.

1. En la parte superior, elija **Configuración**.

1. En el panel de navegación, elija **Cuentas de AWS **. Aparece una lista de cuentas.

1. En la columna **Nombre CodeCatalyst para mostrar de Amazon**, copia el nombre para mostrar del Cuenta de AWS lugar en el que creaste las funciones de creación e implementación. (Puede ser un número). Necesitará este valor más adelante, cuando cree el flujo de trabajo.

1. Elija el nombre de visualización.

1. Selecciona **Administrar roles desde la consola AWS de administración**.

   Aparece la página **Añadir función de IAM a Amazon CodeCatalyst Space**. Es posible que tenga que iniciar sesión para acceder a la página.

1. Seleccione **Agregar un rol existente que haya creado en IAM**.

   Se muestra una lista desplegable. La lista muestra los roles de compilación e implementación, y todos los demás roles de IAM con una política de confianza que incluye las entidades principales de los servicios `codecatalyst-runner.amazonaws.com` y `codecatalyst.amazonaws.com`.

1. En la lista desplegable, añada:
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**nota**  
Si aparece `The security token included in the request is invalid`, es posible que se deba a que no tiene los permisos adecuados. Para solucionar este problema, cierra sesión AWS como vuelve a iniciar sesión con la AWS cuenta que utilizaste al crear tu CodeCatalyst espacio.

1. Vuelve a la CodeCatalyst consola y actualiza la página.

   Los roles de compilación e implementación deberían aparecer ahora en **Roles de IAM**.

   Estas funciones ahora están disponibles para su uso en los CodeCatalyst flujos de trabajo.

## Paso 7: actualice el ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Debe añadir el rol de implementación que creó en `ConfigMap` al archivo [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) de Kubernetes para que la acción **Implementar en clúster de Kubernetes** (en su flujo de trabajo) pueda acceder a su clúster e interactuar con él. Puede utilizar `eksctl` o `kubectl` para realizar esta tarea.

**Para configurar el archivo de ConfigMap Kubernetes mediante eksctl**
+ En el terminal del entorno de desarrollo, escriba: 

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  Donde:
  + *codecatalyst-eks-cluster*se sustituye por el nombre del clúster de Amazon EKS.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*se sustituye por el ARN de la función de implementación en la que creaste. [Paso 5: Crear roles AWS](#deploy-tut-eks-roles)
  +  *codecatalyst-eks-deploy-role*(junto a`--username`) se sustituye por el nombre de la función de implementación en [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) la que creaste.
**nota**  
Si ha decidido no crear un rol de despliegue, *codecatalyst-eks-deploy-role* sustitúyalo por el nombre del `CodeCatalystWorkflowDevelopmentRole-spaceName` rol. Para obtener más información acerca de este rol, consulte [Paso 5: Crear roles AWS](#deploy-tut-eks-roles).
  +  *us-west-2*se sustituye por su región.

  Para obtener más información sobre este comando, consulte [Administración de usuarios y roles de IAM](https://eksctl.io/usage/iam-identity-mappings/).

  Aparecerá un mensaje similar al siguiente:

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**Para configurar el archivo de Kubernetes ConfigMap mediante kubectl**

1. En el terminal del entorno de desarrollo, escriba:

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   El archivo aparece en la pantalla ConfigMap .

1. Añada el texto en cursiva de color rojo:

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   Donde:
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*se sustituye por el ARN de la función de implementación en la que creaste. [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) 
   +  *codecatalyst-eks-deploy-role*(junto a`username:`) se sustituye por el nombre de la función de implementación en [Paso 5: Crear roles AWS](#deploy-tut-eks-roles) la que creaste.
**nota**  
Si ha decidido no crear un rol de despliegue, *codecatalyst-eks-deploy-role* sustitúyalo por el nombre del `CodeCatalystWorkflowDevelopmentRole-spaceName` rol. Para obtener más información acerca de este rol, consulte [Paso 5: Crear roles AWS](#deploy-tut-eks-roles).

   Para obtener más información, consulte [Habilitación del acceso de la entidad principal de IAM a un clúster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) en la **Guía del usuario de Amazon EKS**.

Ahora ha proporcionado al rol de implementación y, por extensión, a la acción **Implementar en Amazon EKS**, permisos `system:masters` para su clúster de Kubernetes.

## Paso 8: creación y ejecución de un flujo de trabajo
<a name="deploy-tut-eks-workflow"></a>

En este paso, creará un flujo de trabajo que toma los archivos de código fuente, los compila en una imagen de Docker y, a continuación, implementa la imagen en tres pods en su clúster de Amazon EKS.

El flujo de trabajo consta de los siguientes componentes que se ejecutarán en orden:
+ Un desencadenador: este desencadenador inicia la ejecución automática del flujo de trabajo cuando se introduce un cambio en el repositorio de código fuente. Para obtener más información acerca de los desencadenadores, consulte [Inicio de un flujo de trabajo y ejecución automática mediante desencadenadores](workflows-add-trigger.md).
+ Una acción de compilación (`BuildBackend`): al activarse, la acción crea la imagen de Docker mediante el Dockerfile y envía la imagen a Amazon ECR. La acción de compilación también actualiza las variables `$REPOSITORY_URI` y `$IMAGE_TAG` en el archivo `Kubernetes` con los valores correctos y, a continuación, crea un artefacto de salida de este archivo y en los demás archivos de la carpeta `deployment.yaml`. En este tutorial, el único archivo de la carpeta `Kubernetes` es `deployment.yaml`, pero puede incluir más archivos. El artefacto se utiliza como entrada para la acción de implementación, que es la siguiente.

  Para obtener más información sobre la acción de compilación, consulte [Compilación con flujos de trabajo](build-workflow-actions.md).
+ Una acción de implementación (`DeployToEKS`): al completarse la acción de compilación, la acción de implementación busca el artefacto de salida generado por la acción de compilación (`Manifests`) y encuentra el archivo `deployment.yaml` que contiene. A continuación, la acción sigue las instrucciones del archivo `deployment.yaml` para ejecutar tres pods, cada uno de los cuales contiene un único mensaje “Hello, World\$1”. Contenedor de Docker: dentro de su clúster de Amazon EKS. 

**Para crear un flujo de trabajo**

1. Ve a la CodeCatalyst consola.

1. Vaya a su proyecto (`codecatalyst-eks-project`).

1. En el panel de navegación, elija **CI/CD** y, a continuación, elija **Flujos de trabajo**.

1. Seleccione **Crear flujo de trabajo**.

1. En **Repositorio de código fuente**, elija `codecatalyst-eks-source-repository`.

1. En **Ramificación**, elija `main`.

1. Seleccione **Crear**.

1. Elimine el código de ejemplo de YAML.

1. Añada el siguiente código de YAML para crear un nuevo archivo de definición de flujo de trabajo:
**nota**  
Para obtener más información sobre el archivo de definición del flujo de trabajo, consulte [Definición de flujo de trabajo en YAML](workflow-reference.md).
**nota**  
En el código de YAML que se muestra a continuación, puede omitir las secciones `Connections:` si lo desea. Si omite estas secciones, debe asegurarse de que el rol especificado en el campo **Rol de IAM predeterminado** del entorno incluya los permisos y las políticas de confianza de ambos roles que se describen en [Paso 6: Añadir AWS roles a CodeCatalyst](#deploy-tut-eks-import-roles). Para obtener más información sobre cómo configurar un entorno con un rol de IAM predeterminado, consulte [Creación de un entorno](deploy-environments-creating-environment.md).

   ```
   Name: codecatalyst-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   En el código anterior, sustituya:
   + Ambas instancias o *codecatalyst-eks-environment* con el nombre del entorno en el que creaste[Requisitos previos](#deploy-tut-eks-prereqs).
   + Ambas instancias *codecatalyst-account-connection* con el nombre visible de la conexión de su cuenta. El nombre de visualización puede ser un número. Para obtener más información, consulte [Paso 6: Añadir AWS roles a CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*con el nombre del rol de compilación en el que creaste[Paso 5: Crear roles AWS](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(en la `Value:` propiedad) con el URI del repositorio de Amazon ECR en [Paso 3: creación de un repositorio de imágenes de Amazon ECR](#deploy-tut-eks-ecr) el que lo creó.
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(en el `Run: aws ecr` comando) con el URI del repositorio de Amazon ECR sin el sufijo de imagen ()`/codecatalyst-eks-image-repo`.
   + *codecatalyst-eks-deploy-role*con el nombre de la función de implementación en la que creó. [Paso 5: Crear roles AWS](#deploy-tut-eks-roles)
   + Ambas instancias o *us-west-2* con el código de su AWS región. Para obtener una lista de códigos de región, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html) en la *Referencia general de AWS*.
**nota**  
Si decidió no crear funciones de creación e implementación, *codecatalyst-eks-build-role* *codecatalyst-eks-deploy-role* sustitúyalas por el nombre de la `CodeCatalystWorkflowDevelopmentRole-spaceName` función. Para obtener más información acerca de este rol, consulte [Paso 5: Crear roles AWS](#deploy-tut-eks-roles).

1. (Opcional) Seleccione **Validar** para asegurarse de que el código de YAML sea válido antes de confirmarlo.

1. Elija **Confirmar**.

1. En el cuadro de diálogo **Confirmar flujo de trabajo**, escriba lo siguiente:

   1. En **Mensaje de confirmación**, elimine el texto e introduzca:

      ```
      Add first workflow
      ```

   1. En **Repositorio**, elija `codecatalyst-eks-source-repository`.

   1. En **Nombre de la ramificación**, elija principal.

   1. Elija **Confirmar**.

   Ahora ha creado un flujo de trabajo. La ejecución del flujo de trabajo se inicia automáticamente debido al desencadenador definido en la parte superior del flujo de trabajo. En concreto, cuando confirmó (e incorporó) el archivo `workflow.yaml` en su repositorio de código fuente, el desencadenador inició la ejecución del flujo de trabajo.

**Consulta del progreso de la ejecución del flujo de trabajo**

1. **En el panel de navegación de la CodeCatalyst consola, elija **CI/CD** y, a continuación, elija Flujos de trabajo.**

1. Elija el flujo de trabajo que acaba de crear, `codecatalyst-eks-workflow`.

1. Elija **BuildBackend**ver el progreso de la compilación.

1. Elija **DeployToEKS** para ver el progreso de la implementación.

   Para obtener más información sobre cómo ver los detalles de ejecución, consulte [Visualización del estado y los detalles de la ejecución de un flujo de trabajo](workflows-view-run.md).

**Verificación de la implementación**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. A la izquierda, cerca de la parte inferior, seleccione **Equilibradores de carga**.

1. Seleccione el equilibrador de carga que se creó como parte de la implementación de Kubernetes. Si no está seguro de qué equilibrador de carga elegir, busque las siguientes etiquetas en la pestaña **Etiquetas**:
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Con el equilibrador de carga correcto seleccionado, elija la pestaña **Descripción**.

1. Copie y pegue el valor del **nombre de DNS** en la barra de dirección del navegador.

   Aparece la página web “Hello World\$1” en el navegador, lo que indica que la aplicación se ha implementado correctamente.

## Paso 9: realización de un cambio en los archivos de código fuente
<a name="deploy-tut-eks-change"></a>

En esta sección, realizará un cambio en el archivo `index.html` de su repositorio de código fuente. Este cambio hace que el flujo de trabajo cree una nueva imagen de Docker, la etiquete con un ID de confirmación, la envíe a Amazon ECR y la implemente en Amazon ECS. 

**Cambio del archivo index.html**

1. Vaya a su entorno de desarrollo.

1. En la línea de comandos del terminal, cambie a su repositorio de código fuente:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Incorpore los cambios más recientes en el flujo de trabajo:

   ```
   git pull
   ```

1. Abra `codecatalyst-eks-source-repository/public-html/index.html`.

1. En la línea 14, cambie el texto `Hello, World!` a `Tutorial complete!`

1. Añada, confirme y envíe:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   Se inicia automáticamente una ejecución del flujo de trabajo.

1. (Opcional) Escriba:

   ```
   git show HEAD
   ```

   Anote el ID de confirmación del cambio de `index.html`. Este ID de confirmación se etiquetará en la imagen de Docker que se implementará en la ejecución del flujo de trabajo que acaba de iniciar.

1. Observe el progreso de la implementación:

   1. **En la CodeCatalyst consola, en el panel de navegación, elija **CI/CD** y, a continuación, elija Flujos de trabajo.**

   1. Elija `codecatalyst-eks-workflow` para ver la última ejecución.

   1. Elija y **BuildBackend**haga clic en **DeployToEKS** para ver el progreso de la ejecución del flujo de trabajo.

1. Compruebe que la aplicación se haya actualizado de la siguiente manera:

   1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. A la izquierda, cerca de la parte inferior, seleccione **Equilibradores de carga**.

   1. Seleccione el equilibrador de carga que se creó como parte de la implementación de Kubernetes.

   1. Copie y pegue el valor del **nombre de DNS** en la barra de dirección del navegador.

      Aparece la página web “Tutorial Complete\$1” en el navegador, lo que indica que ha implementado correctamente una nueva revisión de la aplicación.

1. (Opcional) En AWS, cambie a la consola Amazon ECR y compruebe que la nueva imagen de Docker esté etiquetada con el ID de confirmación del paso 7 de este procedimiento.

## Limpieza
<a name="deploy-tut-eks-cleanup"></a>

Debe limpiar su entorno para que no se le cobre innecesariamente por los recursos de almacenamiento y computación utilizados en este tutorial.

**Eliminación**

1. Eliminar el clúster:

   1. En el terminal del entorno de desarrollo, escriba:

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Donde:
     + *us-west-2*se sustituye por tu región.
     + *codecatalyst-eks-cluster*se sustituye por el nombre del clúster que ha creado.

     Después de 5 a 10 minutos, se eliminan el clúster y los recursos asociados, incluidos, entre otros, las CloudFormation pilas, los grupos de nodos (en Amazon EC2) y los balanceadores de carga.
**importante**  
Si el `eksctl delete cluster` comando no funciona, es posible que deba actualizar sus AWS credenciales o sus credenciales. `kubectl` Si no está seguro de qué credenciales actualizar, actualice primero las AWS credenciales. Para actualizar sus credenciales de AWS , consulte [¿Cómo puedo corregir los errores «No se pueden localizar las credenciales» y ExpiredToken «»?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks). Para actualizar sus credenciales de `kubectl`, consulte [¿Cómo puedo corregir los errores de tipo Unable to connect to the server?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks).

1. En la AWS consola, limpie de la siguiente manera:

   1. En Amazon ECR, elimine `codecatalyst-eks-image-repo`.

   1. En IAM Identity Center, elimine:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. En IAM, elimine:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. En la CodeCatalyst consola, limpie de la siguiente manera:

   1. Elimine `codecatalyst-eks-workflow`.

   1. Elimine `codecatalyst-eks-environment`.

   1. Elimine `codecatalyst-eks-source-repository`.

   1. Elimine el entorno de desarrollo.

   1. Elimine `codecatalyst-eks-project`.

En este tutorial, aprendió a implementar una aplicación en un servicio de Amazon EKS mediante un CodeCatalyst flujo de trabajo y una acción de **implementación en un clúster de Kubernetes.**

# Incorporación de la acción 'Implementar en clúster de Kubernetes'
<a name="deploy-action-eks-adding"></a>

Siga estas instrucciones para añadir la acción **Implementar en clúster de Kubernetes** a su flujo de trabajo. 

**Antes de empezar**

Antes de añadir la acción **Implementar en clúster de Kubernetes** a su flujo de trabajo, debe tener preparado lo siguiente:

**sugerencia**  
Para configurar estos requisitos previos rápidamente, sigue las instrucciones de [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md).
+ Un clúster de Kubernetes en Amazon EKS. Para obtener más información sobre los clústeres, consulte [Amazon EKS clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) en la **Guía del usuario de Amazon EKS**.
+ Al menos un Dockerfile que describa cómo ensamblar la aplicación en una imagen de Docker. Para obtener más información acerca de los archivos Docker, consulte la [referencia de Docker](https://docs.docker.com/engine/reference/builder/).
+ Al menos un archivo de manifiesto de Kubernetes, que se denomina *archivo de configuración* o *configuración* en la documentación de Kubernetes. Para obtener más información, consulte [Managing resources](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/) en la documentación de Kubernetes.
+ Un rol de IAM que proporcione a la acción **Implementar en clúster de Kubernetes** la capacidad de acceder a su clúster de Amazon EKS e interactuar con él. Para obtener más información, consulte el tema [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) en la [Acción 'Implementar en clúster de Kubernetes' de YAML](deploy-action-ref-eks.md).

  Tras crear este rol, debe añadirlo a:
  + Tu ConfigMap archivo de Kubernetes. Para obtener información sobre cómo añadir un rol a un ConfigMap archivo, consulte [Habilitar el acceso principal de IAM a su clúster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) en la **Guía del usuario de Amazon EKS**.
  + CodeCatalyst. Para obtener información sobre cómo añadir una función de IAM a CodeCatalyst, consulte[Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).
+ Un CodeCatalyst espacio, un proyecto y un entorno. Tanto el espacio como el entorno deben estar conectados a la AWS cuenta en la que vaya a implementar la aplicación. Para obtener más información, consulte [Creación de un espacio](spaces-create.md), [Crear un proyecto vacío en Amazon CodeCatalyst](projects-create.md#projects-create-empty) y [Implementación en Cuentas de AWS y VPCs](deploy-environments.md).
+ Un repositorio de código fuente compatible con CodeCatalyst. El repositorio almacena los archivos de código fuente de la aplicación, los Dockerfiles y los manifiestos de Kubernetes. Para obtener más información, consulte [Almacene código y colabore en él con los repositorios de código fuente en CodeCatalystAlmacenamiento de código y colaboración con los repositorios de código fuente](source.md).

------
#### [ Visual ]

**Incorporación de la acción 'Implementar en clúster de Kubernetes' con el editor visual**

1. Abra la CodeCatalyst consola en [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Elija el proyecto.

1. En el panel de navegación, elija **CI/CD** y, a continuación, elija **Flujos de trabajo**.

1. Elija el nombre del flujo de trabajo. Puede filtrar por el nombre del repositorio de código fuente o la ramificación donde esté definido el flujo de trabajo, o bien por el nombre o el estado del flujo de trabajo.

1. Elija **Edit (Edición de)**.

1. Elija **Visual**.

1. En la parte superior izquierda, seleccione **\$1 Acciones** para abrir el catálogo de acciones.

1. En la lista desplegable, selecciona **Amazon CodeCatalyst**.

1. Busque la acción **Implementar en clúster de Kubernetes** y realice una de las siguientes acciones:
   + Elija el signo más (**\$1**) para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

     O
   + Elija **Implementar en clúster de Kubernetes**. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Descargar** para [ver el código fuente de la acción](workflows-view-source.md#workflows-view-source.title).
     + Seleccione **Añadir al flujo de trabajo** para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

1. En las pestañas **Entradas** y **Configuración**, complete los campos según sus necesidades. Para obtener una descripción de cada uno de los campos, consulte la [Acción 'Implementar en clúster de Kubernetes' de YAML](deploy-action-ref-eks.md). Esta referencia proporciona información detallada sobre cada campo (y el valor de la propiedad de YAML correspondiente) tal como aparece en el editor visual y el de YAML.

1. (Opcional) Seleccione **Validar** para validar el código de YAML del flujo de trabajo antes de confirmarlo.

1. Seleccione **Confirmar**, introduzca un mensaje de confirmación y vuelva a seleccionar **Confirmar**.

------
#### [ YAML ]

**Incorporación de la acción 'Implementar en clúster de Kubernetes' con el editor de YAML**

1. Abre la CodeCatalyst consola en [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Elija el proyecto.

1. En el panel de navegación, elija **CI/CD** y, a continuación, elija **Flujos de trabajo**.

1. Elija el nombre del flujo de trabajo. Puede filtrar por el nombre del repositorio de código fuente o la ramificación donde esté definido el flujo de trabajo, o bien por el nombre o el estado del flujo de trabajo.

1. Elija **Edit (Edición de)**.

1. Elija **YAML**.

1. En la parte superior izquierda, seleccione **\$1 Acciones** para abrir el catálogo de acciones.

1. En la lista desplegable, selecciona **Amazon CodeCatalyst**.

1. Busque la acción **Implementar en clúster de Kubernetes** y realice una de las siguientes acciones:
   + Elija el signo más (**\$1**) para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

     O
   + Elija **Implementar en clúster de Kubernetes**. Aparecerá el cuadro de diálogo de detalles de la acción. En este cuadro de diálogo:
     + (Opcional) Seleccione **Descargar** para [ver el código fuente de la acción](workflows-view-source.md#workflows-view-source.title).
     + Seleccione **Añadir al flujo de trabajo** para añadir la acción al diagrama de flujo de trabajo y abrir su panel de configuración.

1. Modifique las propiedades del código de YAML en función de sus necesidades. Encontrará una explicación de todas las propiedades disponibles en la [Acción 'Implementar en clúster de Kubernetes' de YAML](deploy-action-ref-eks.md).

1. (Opcional) Seleccione **Validar** para validar el código de YAML del flujo de trabajo antes de confirmarlo.

1. Seleccione **Confirmar**, introduzca un mensaje de confirmación y vuelva a seleccionar **Confirmar**.

------

# Variables de 'Implementar en clúster de Kubernetes'
<a name="deploy-action-eks-variables"></a>

La acción **Implementar en clúster de Kubernetes** produce y establece las siguientes variables en tiempo de ejecución. Se conocen como *variables predefinidas*.

Para obtener información sobre cómo hacer referencia a estas variables en un flujo de trabajo, consulte [Uso de variables predefinidas](workflows-using-predefined-variables.md).


| Clave | Valor | 
| --- | --- | 
|  clúster  |  El Nombre de recurso de Amazon (ARN) del clúster de Amazon EKS en el que se implementó durante la ejecución del flujo de trabajo. Ejemplo: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  deployment-platform  |  El nombre de la plataforma de implementación. Codificado en `AWS:EKS`.  | 
|  metadatos  |  Reservado. Metadatos con formato JSON relacionados con el clúster implementado durante la ejecución del flujo de trabajo.  | 
|  namespace  |  El espacio de nombres de Kubernetes en el que se implementó el clúster. Ejemplo: `default`  | 
|  recursos  |  Reservado. Metadatos con formato JSON relacionados con los recursos implementados durante la ejecución del flujo de trabajo.  | 
|  server  |  El nombre del punto de conexión del servidor de API que puede usar para comunicarse con su clúster mediante herramientas de administración como `kubectl`. Para obtener más información sobre el punto de conexión del servicio de la API, consulte [Control de acceso al punto de conexión del clúster de Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) en la **Guía del usuario de Amazon EKS**. Ejemplo: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# Acción 'Implementar en clúster de Kubernetes' de YAML
<a name="deploy-action-ref-eks"></a>

La siguiente es la definición en YAML de la acción **Implementar en clúster de Kubernetes**. Para obtener información sobre cómo utilizar esta acción, consulte [Implementación en Amazon EKS con un flujo de trabajo](deploy-action-eks.md).

Esta definición de acción existe como una sección dentro de un archivo de definición de flujo de trabajo más amplio. Para obtener más información acerca de este archivo, consulte [Definición de flujo de trabajo en YAML](workflow-reference.md).

**nota**  
La mayoría de las propiedades de YAML que se muestran a continuación tienen elementos de interfaz de usuario correspondientes en el editor visual. Para buscar un elemento de la interfaz de usuario, use **Ctrl\$1F**. El elemento aparecerá en la lista con su propiedad de YAML asociada.

```
# The workflow definition starts here.
# See Propiedades de nivel superior for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-deploy@v1
    DependsOn:
      - build-action
    Compute:  
        - Type: EC2 | Lambda
        - Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.name"></a>

(Obligatorio) 

Especifique el nombre de la acción. Todos los nombres de las acciones deben ser únicos dentro del flujo de trabajo. Los nombres de las acciones están limitados a caracteres alfanuméricos (a-z, A-Z y 0-9), guiones (-) y guiones bajos (\$1). No se permiten espacios. No puede utilizar comillas para permitir caracteres especiales ni espacios en los nombres de las acciones.

Predeterminado: `DeployToKubernetesCluster_nn`.

Interfaz de usuario correspondiente: pestaña Configuración/**Nombre de visualización de la acción**

## Identifier
<a name="deploy.action.eks.identifier"></a>

(*DeployToKubernetesCluster*/**Identifier**)

(Obligatorio)

Identifica la acción. No cambie esta propiedad a menos que desee cambiar la versión. Para obtener más información, consulte [Especificación de la versión de la acción que se va a utilizar](workflows-action-versions.md).

Predeterminado: `aws/kubernetes-deploy@v1`.

Interfaz de usuario correspondiente: Diagrama de flujo de trabajo/DeployToKubernetesCluster\$1nn/etiqueta **aws/kubernetes-deploy@v1**

## DependsOn
<a name="deploy.action.eks.dependson"></a>

(*DeployToKubernetesCluster*/**DependsOn**)

(Opcional)

Especifique la acción, el grupo de acciones o la puerta que debe ejecutarse correctamente para que esta acción se ejecute.

Para obtener más información sobre la funcionalidad “depende de”, consulte [Secuenciación de acciones](workflows-depends-on.md).

Interfaz de usuario correspondiente: pestaña Entradas/**Depende de (opcional)**

## Compute
<a name="deploy.action.eks.computename"></a>

(*DeployToKubernetesCluster*/**Compute**)

(Opcional)

El motor de computación utilizado para ejecutar las acciones del flujo de trabajo. Puede especificar el motor de computación en el nivel del flujo de trabajo o en el nivel de acción, pero no en ambos. Cuando se especifica en el nivel de flujo de trabajo, la configuración del motor de computación se aplica a todas las acciones definidas en el flujo de trabajo. En el nivel de flujo de trabajo, también puede ejecutar varias acciones en la misma instancia. Para obtener más información, consulte [Uso compartido de recursos de computación entre acciones](compute-sharing.md).

Interfaz de usuario correspondiente: *ninguna*

## Type
<a name="deploy.action.eks.computetype"></a>

(*DeployToKubernetesCluster*/Compute/**Type**)

(Obligatorio si se incluye [Compute](#deploy.action.eks.computename))

El tipo de motor de computación. Puede utilizar uno de los siguientes valores:
+ **EC2** (editor visual) o `EC2` (editor de YAML)

  Optimizado para ofrecer flexibilidad durante las ejecuciones de acciones.
+ **Lambda** (editor visual) o `Lambda` (editor de YAML)

  Velocidades de inicio de acciones optimizadas.

Para obtener más información sobre los tipos de computación, consulte [Tipos de computación](workflows-working-compute.md#compute.types).

**Interfaz de usuario correspondiente: Configuración: opcional/tipo informático tab/Advanced **

## Fleet
<a name="deploy.action.eks.computefleet"></a>

(*DeployToKubernetesCluster*/Compute/**Fleet**)

(Opcional)

Especifique la máquina o la flota que ejecutará el flujo de trabajo o las acciones del flujo de trabajo. Con las flotas bajo demanda, cuando se inicia una acción, el flujo de trabajo aprovisiona los recursos que necesita y las máquinas se destruyen cuando finaliza la acción. Ejemplos de flotas bajo demanda: `Linux.x86-64.Large`, `Linux.x86-64.XLarge`. Para obtener más información sobre las flotas bajo demanda, consulte [Propiedades de las flotas bajo demanda](workflows-working-compute.md#compute.on-demand).

Con las flotas aprovisionadas, configura un conjunto de máquinas dedicadas para ejecutar las acciones del flujo de trabajo. Estas máquinas permanecen inactivas, listas para procesar acciones de forma inmediata. Para obtener más información sobre las flotas aprovisionadas, consulte [Propiedades de flotas aprovisionadas](workflows-working-compute.md#compute.provisioned-fleets).

Si `Fleet` se omite, el valor predeterminado es `Linux.x86-64.Large`.

**Interfaz de usuario correspondiente: Configuración: opcional/flota de tab/Advanced cómputo**

## Timeout
<a name="deploy.action.eks.timeout"></a>

(*DeployToKubernetesCluster*/**Timeout**)

(Opcional)

Especifique la cantidad de tiempo en minutos (editor YAML) o en horas y minutos (editor visual) que la acción puede ejecutarse antes de que CodeCatalyst finalice la acción. El mínimo es 5 minutos y el máximo se describe en [Cuotas para flujos de trabajo en CodeCatalyst](workflows-quotas.md). El tiempo de espera predeterminado es el mismo que el tiempo de espera máximo.

Interfaz de usuario correspondiente: pestaña Configuración/**Tiempo de espera (opcional)**

## Environment
<a name="deploy.action.eks.environment"></a>

(*DeployToKubernetesCluster*/**Environment**)

(Obligatorio) 

Especifica el CodeCatalyst entorno que se va a usar con la acción. La acción se conecta a Cuenta de AWS la Amazon VPC opcional especificada en el entorno elegido. La acción utiliza la función de IAM predeterminada especificada en el entorno para conectarse a Cuenta de AWS, y utiliza la función de IAM especificada en la [conexión de Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) para conectarse a la Amazon VPC.

**nota**  
Si el rol de IAM predeterminado no tiene los permisos necesarios para la acción, puede configurarla para que utilice un rol diferente. Para obtener más información, consulte [Cambio del rol de IAM de una acción](deploy-environments-switch-role.md).

Para obtener más información sobre los entornos, consulte [Implementación en Cuentas de AWS y VPCs](deploy-environments.md) y [Creación de un entorno](deploy-environments-creating-environment.md).

Interfaz de usuario correspondiente: pestaña Configuración/**Entorno**

## Name
<a name="deploy.action.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

(Obligatorio si se incluye [Environment](#deploy.action.eks.environment))

Especifique el nombre del entorno existente que desea asociar a la acción.

Interfaz de usuario correspondiente: pestaña Configuración/**Entorno**

## Connections
<a name="deploy.action.eks.environment.connections"></a>

(*DeployToKubernetesCluster*/Environment/**Connections**)

(Opcional en las versiones más recientes de la acción; obligatorio en las versiones más antiguas)

Especifique la conexión de cuenta que desee asociar a la acción. Puede especificar un máximo de una conexión de cuenta en `Environment`.

Si no especifica una conexión de cuenta:
+ La acción utiliza la Cuenta de AWS conexión y la función de IAM predeterminada especificadas en el entorno de la consola. CodeCatalyst Para obtener información sobre cómo añadir una conexión de cuenta y un rol de IAM predeterminado al entorno, consulte [Creación de un entorno](deploy-environments-creating-environment.md).
+ El rol de IAM predeterminado debe incluir las políticas y los permisos que requiere la acción. Para determinar cuáles son esas políticas y permisos, consulte la descripción de la propiedad **Role** en la documentación de la definición de YAML de la acción.

Para obtener más información sobre las conexiones de cuenta, consulte [Permitir el acceso a AWS los recursos con conexión Cuentas de AWS](ipa-connect-account.md). Para obtener más información sobre cómo añadir una conexión de cuenta a un entorno, consulte [Creación de un entorno](deploy-environments-creating-environment.md).

Interfaz de usuario correspondiente: una de las siguientes, según la versión de la acción.
+ (Versiones más recientes) ¿tab/Environment/WhatLa configuración está lista? *my-environment* **/menú de tres puntos/ Cambiar rol**
+ **(Versiones anteriores) Pestaña de configuración/' '/ conexión de cuenta Environment/account/role AWS **

## Name
<a name="deploy.action.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Opcional)

Especifique el nombre de la conexión de cuenta.

Interfaz de usuario correspondiente: una de las siguientes, según la versión de la acción.
+ (Versiones más recientes) ¿La configuración está lista? tab/Environment/What *my-environment* **/menú de tres puntos/ Cambiar rol**
+ **(Versiones anteriores) Pestaña de configuración/' '/ conexión de cuenta Environment/account/role AWS **

## Role
<a name="deploy.action.eks.environment.connections.role"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

(Obligatorio si se incluye [Connections](#deploy.action.eks.environment.connections))

Especifique el nombre del rol de IAM que la acción **Implementar en clúster de Kubernetes** utiliza para acceder a AWS. Asegúrese de haber [agregado el rol a su CodeCatalyst espacio](ipa-connect-account-addroles.md) y de que el rol incluya las siguientes políticas.

Si no especifica un rol de IAM, la acción utilizará el rol de IAM predeterminado que aparece en el [entorno](deploy-environments.md) de la consola. CodeCatalyst Si usa el rol predeterminado en el entorno, asegúrese de que tenga las siguientes políticas.
+ La siguiente política de permisos:
**aviso**  
Limite los permisos a los que se muestran en la siguiente política. El uso de un rol con permisos más amplios puede suponer un riesgo de seguridad.

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**nota**  
La primera vez que utilice el rol, use el siguiente comodín en la instrucción de política de recursos y, a continuación, precise el ámbito de la política con el nombre del recurso cuando esté disponible.  

  ```
  "Resource": "*"
  ```
+ La siguiente política de confianza personalizada:

Asegúrese de añadir este rol a:
+ Su conexión de cuenta. Para obtener más información sobre cómo añadir un rol de IAM a una conexión de cuenta, consulte [Adición de roles de IAM a las conexiones de cuentas](ipa-connect-account-addroles.md).
+ Tu Kubernetes. ConfigMap Para obtener más información sobre cómo añadir un rol de IAM a un ConfigMap, consulte [Administrar usuarios y roles de IAM](https://eksctl.io/usage/iam-identity-mappings/) en la documentación. `eksctl`

**sugerencia**  
Consulte también las [Tutorial: implementación de una aplicación en Amazon EKS](deploy-tut-eks.md) instrucciones sobre cómo añadir un rol de IAM a una conexión de cuenta y. ConfigMap

**nota**  
Puede usar el rol `CodeCatalystWorkflowDevelopmentRole-spaceName` con esta acción, si así lo desea. Para obtener más información acerca de este rol, consulte [Creación del rol **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para su cuenta y su espacio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tenga en cuenta que el rol `CodeCatalystWorkflowDevelopmentRole-spaceName` tiene permisos de acceso total, lo que puede suponer un riesgo para la seguridad. Le recomendamos que utilice este rol solo en tutoriales y situaciones en las que la seguridad no sea un problema. 

Interfaz de usuario correspondiente: una de las siguientes, según la versión de la acción.
+ (Versiones más recientes) ¿tab/Environment/WhatLa configuración está lista? *my-environment* **/menú de tres puntos/ Cambiar rol**
+ **(Versiones anteriores) Pestaña de configuración/' '/ Rol Environment/account/role**

## Inputs
<a name="deploy.action.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

(Obligatorio si se incluye [Connections](#deploy.action.eks.environment.connections))

La sección `Inputs` define los datos que necesita la acción `DeployToKubernetesCluster` durante la ejecución de un flujo de trabajo.

**nota**  
Solo se permite una entrada (ya sea un código fuente o un artefacto) para cada acción **Implementar en Amazon EKS**.

Interfaz de usuario correspondiente: pestaña **Entradas**

## Sources
<a name="deploy.action.eks.inputs.sources"></a>

(*DeployToKubernetesCluster*/Inputs/**Sources**)

(Obligatorio si el archivo de manifiesto está almacenado en un repositorio de código fuente)

Si el archivo o los archivos de manifiesto de Kubernetes están almacenados en un repositorio de código fuente, especifique la etiqueta de dicho repositorio. Actualmente, la única etiqueta admitida es `WorkflowSource`.

Si los archivos de manifiesto no están incluidos en un repositorio de código fuente, deben residir en un artefacto generado por otra acción.

Para obtener más información sobre orígenes, consulte [Conexión de repositorios de código fuente a flujos de trabajo](workflows-sources.md).

Interfaz de usuario correspondiente: pestaña Entradas/**Orígenes (opcional)**

## Artifacts - input
<a name="deploy.action.eks.inputs.artifacts"></a>

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

(Obligatorio si el archivo de manifiesto está almacenado en un [artefacto de salida](workflows-working-artifacts-output.md) de una acción anterior)

Si el archivo o los archivos de manifiesto de Kubernetes están incluidos en un artefacto generado por una acción anterior, especifique ese artefacto aquí. Si los archivos de manifiesto no están incluidos en un artefacto, deben residir en el repositorio de código fuente.

Para obtener más información sobre los artefactos, incluidos ejemplos, consulte [Cómo compartir artefactos y archivos entre acciones](workflows-working-artifacts.md).

Interfaz de usuario correspondiente: pestaña Configuración/**Artefactos (opcional)**

## Configuration
<a name="deploy.action.eks.configuration"></a>

(*DeployToKubernetesCluster*/**Configuration**)

(Obligatorio)

Una sección en la que puede definir las propiedades de configuración de la acción.

Interfaz de usuario correspondiente: pestaña **Configuración**

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Opcional)

Especifique el espacio de nombres de Kubernetes en el que se implementará la aplicación de Kubernetes. Use `default` si no utiliza espacios de nombres con el clúster. Para obtener más información sobre los espacios de nombres, consulte [Subdividing your cluster using Kubernetes namespaces](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces) en la documentación de Kubernetes.

Si omite el espacio de nombres, se usará el valor de `default`.

Interfaz de usuario correspondiente: pestaña Configuración/**Espacio de nombres**

## Region
<a name="deploy.action.eks.region"></a>

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Obligatorio) 

Especifique la AWS región en la que residen el clúster y el servicio de Amazon EKS. Para obtener una lista de códigos de región, consulte [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes) en la *Referencia general de AWS*.

Interfaz de usuario correspondiente: pestaña Configuración/**Región**

## Cluster
<a name="deploy.action.eks.cluster"></a>

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Obligatorio)

Especifique el nombre de un clúster de Amazon EKS existente. La acción **Implementar en clúster de Kubernetes** implementará la aplicación basada en contenedores en este clúster. Para obtener más información sobre los clústeres de Amazon EKS, consulte [Clústeres](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) en la **Guía del usuario de Amazon EKS**.

Interfaz de usuario correspondiente: pestaña Configuración/**Clúster**

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Obligatorio)

Especifique la ruta a los archivos de manifiesto de Kubernetes con formato YAML, que se denominan *archivos de configuración*, *archivos config* o, simplemente, *configuraciones* en la documentación de Kubernetes.

Si utiliza varios archivos de manifiesto, colóquelos en una sola carpeta y haga referencia a esa carpeta. Kubernetes procesa los archivos de manifiesto de forma alfanumérica, así que asegúrese de anteponer números o letras en orden ascendente a los nombres de los archivos para controlar el orden de procesamiento. Por ejemplo:

`00-namespace.yaml`

`01-deployment.yaml`

Si los archivos de manifiesto residen en el repositorio de código fuente, la ruta es relativa a la carpeta raíz del repositorio de código fuente. Si los archivos residen en un artefacto de una acción del flujo de trabajo anterior, la ruta es relativa a la carpeta raíz del artefacto. 

Ejemplos:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

No utilice comodines (`*`).

**nota**  
No se admiten [gráficos de Helm](https://helm.sh/docs/topics/charts/) ni [archivos kustomization](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/).

Para obtener más información sobre los archivos de manifiesto, consulte [Organizing resource configurations](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations) en la documentación de Kubernetes.

Interfaz de usuario correspondiente: pestaña Configuración/**Manifiestos**