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.

# CodePipeline tutoriales
<a name="tutorials"></a>

Tras completar los pasos[Empezar con CodePipeline](getting-started-codepipeline.md), puede probar uno de los AWS CodePipeline tutoriales de esta guía del usuario.

**Topics**
+ [

# Tutorial: Implemente en instancias de Amazon EC2 con CodePipeline
](tutorials-ec2-deploy.md)
+ [

# Tutorial: Cree e inserte una imagen de Docker en Amazon ECR con CodePipeline (tipo V2)
](tutorials-ecr-build-publish.md)
+ [

# Tutorial: Implemente en Amazon EKS con CodePipeline
](tutorials-eks-deploy.md)
+ [

# Tutorial: creación de una canalización que ejecute comandos mediante computación (tipo V2)
](tutorials-commands.md)
+ [

# Tutorial: Usar etiquetas de Git para iniciar la canalización
](tutorials-github-tags.md)
+ [

# Tutorial: filtrado de solicitudes de extracción por nombres de ramificación para iniciar una canalización (tipo V2)
](tutorials-github-featurebranches.md)
+ [

# Tutorial: Uso de variables a nivel de canalización
](tutorials-pipeline-variables.md)
+ [

# Tutorial: Crear una canalización simple (bucket de S3)
](tutorials-simple-s3.md)
+ [

# Tutorial: Crear una canalización sencilla (CodeCommit repositorio)
](tutorials-simple-codecommit.md)
+ [

# Tutorial: Crear una canalización de cuatro etapas
](tutorials-four-stage-pipeline.md)
+ [

# Tutorial: Configurar una regla de CloudWatch eventos para recibir notificaciones por correo electrónico sobre los cambios de estado de la canalización
](tutorials-cloudwatch-sns-notifications.md)
+ [

# Tutorial: Crea una canalización que compile y pruebe tu aplicación para Android con AWS Device Farm
](tutorials-codebuild-devicefarm.md)
+ [

# Tutorial: Crea una canalización que pruebe tu aplicación para iOS con AWS Device Farm
](tutorials-codebuild-devicefarm-S3.md)
+ [

# Tutorial: Crear una canalización que se implemente en Service Catalog
](tutorials-S3-servicecatalog.md)
+ [

# Tutorial: Cree una canalización con AWS CloudFormation
](tutorials-cloudformation.md)
+ [

# Tutorial: Crear una canalización que utilice variables de las acciones de AWS CloudFormation despliegue
](tutorials-cloudformation-action.md)
+ [

# Tutorial: Implementación estándar de Amazon ECS con CodePipeline
](ecs-cd-pipeline.md)
+ [

# Tutorial: Creación de una canalización con una fuente y ECS-to-CodeDeploy una implementación de Amazon ECR
](tutorials-ecs-ecr-codedeploy.md)
+ [

# Tutorial: Crear una canalización que implemente una habilidad de Amazon Alexa
](tutorials-alexa-skills-kit.md)
+ [

# Tutorial: Crear una canalización que utilice Amazon S3 como proveedor de implementación
](tutorials-s3deploy.md)
+ [

# Tutorial: Cree una canalización que publique su aplicación sin servidor en el AWS Serverless Application Repository
](tutorials-serverlessrepo-auto-publish.md)
+ [

# Tutorial: Implementaciones de funciones Lambda con CodePipeline
](tutorials-lambda-deploy.md)
+ [

# Tutorial: Uso de variables con acciones de invocación de Lambda
](tutorials-lambda-variables.md)
+ [

# Tutorial: Usa una acción de AWS Step Functions invocación en una canalización
](tutorials-step-functions.md)
+ [

# Tutorial: Crear una canalización que se utilice AWS AppConfig como proveedor de despliegue
](tutorials-AppConfig.md)
+ [

# Tutorial: Utilice un clon completo con una fuente de GitHub canalización
](tutorials-github-gitclone.md)
+ [

# Tutorial: Utilice un clon completo con una fuente de CodeCommit canalización
](tutorials-codecommit-gitclone.md)
+ [

# Tutorial: Crear una canalización con acciones AWS CloudFormation StackSets de despliegue
](tutorials-stackset-deployment.md)
+ [

# Tutorial: Cómo crear una regla de verificación de variables para una canalización como una condición de entrada
](tutorials-varcheckrule.md)

# Tutorial: Implemente en instancias de Amazon EC2 con CodePipeline
<a name="tutorials-ec2-deploy"></a>

Este tutorial le ayuda a crear una acción de despliegue CodePipeline que despliegue el código en las instancias que haya configurado en Amazon EC2.

**nota**  
Como parte de la creación de una canalización en la consola, para los artefactos se utilizará un depósito de artefactos de CodePipeline S3. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
La acción de implementación de `EC2` solo está disponible para canalizaciones de tipo V2.

## Requisitos previos
<a name="tutorials-ec2-deploy-prereqs"></a>

Para poder usar este tutorial para crear su propia canalización de implementación continua debe tener instalados algunos recursos. Esto es lo que necesita para empezar:

**nota**  
Todos estos recursos deben crearse en la misma región. AWS 
+ Un repositorio de control de código fuente (se utiliza en este tutorial GitHub) donde agregará un `script.sh` archivo de muestra.
+ Debe usar un rol de CodePipeline servicio existente que se haya actualizado con los permisos para esta acción. Para actualizar su rol de servicio, consulte [Permisos de la política de rol de servicio para la acción de implementación de EC2](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action).

Una vez satisfechos estos requisitos previos, puede continuar con el tutorial y crear su canalización de implementación continua.

## Paso 1: creación de instancias de Amazon EC2 en Linux
<a name="tutorials-ec2-deploy-instances"></a>

En este paso, va a crear las instancias de Amazon EC2 en las que va a implementar una aplicación de ejemplo. Como parte de este proceso, cree un rol de instancia en IAM si aún no ha creado un rol de instancia en la región en la que desea crear los recursos.

**Para crear un rol de instancia**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

1. En el panel de la consola, elija **Roles**.

1. Elija **Crear rol**.

1. En **Seleccionar el tipo de entidad de confianza**, seleccione **Servicio de AWS**. En **Elegir un caso de uso**, seleccione **EC2**. En **Select your use case (Seleccionar su caso de uso)**, elija **EC2**. Elija **Siguiente**.

1. Busque y seleccione la política denominada **`AmazonSSMManagedEC2InstanceDefaultPolicy`**. 

1. Busque y seleccione la política denominada **`AmazonSSMManagedInstanceCore`**. Elija **Siguiente: Etiquetas**.

1. Elija **Siguiente: Revisar**. Escriba el nombre del rol (por ejemplo, **EC2InstanceRole**).
**nota**  
Anote el nombre del rol para utilizarlo en el siguiente paso. Tendrá que elegir este rol cuando cree la instancia.
**nota**  
Agregará permisos a este rol para permitir el acceso al bucket de artefactos de S3 para su canalización una vez creada la canalización.

   Elija **Crear rol**.

**Para lanzar las instancias**

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

1. En la barra de navegación lateral, elija **Instancias** y seleccione **Lanzar instancias** en la parte superior de la página.

1. En **Name (Nombre)**, escriba **MyInstances**. Esto asigna a la instancia una **clave** de etiqueta **Name** y un **valor** de etiqueta **MyInstances**. 

1. En **Imágenes de aplicaciones y sistemas operativos (Amazon Machine Image)**, busque la opción AMI de **Amazon Linux** con el AWS logotipo y asegúrese de que esté seleccionada. (Esta AMI se describe como AMI de Amazon Linux 2 (HVM) y se denomina "Free tier eligible" (Apta para capa gratuita).)

1. En **Tipo de instancia**, elija el tipo `t2.micro` apto para la capa gratuita como configuración de hardware de la instancia.

1. En **Par de claves (inicio de sesión)**, seleccione un par de claves o cree uno. 

1. En **Configuración de red**, asegúrese de que el estado sea **Habilitar**.

1. Amplíe **Advanced details** (Detalles avanzados). En **Perfil de instancia de IAM**, elija el rol de IAM que creó en el procedimiento anterior (por ejemplo, **EC2InstanceRole**).
**nota**  
No deje el rol de instancia en blanco, ya que esto crea un rol predeterminado y no selecciona el rol que ha creado.

1. En **Resumen**, en **Número de instancias**, especifique `2`.

1. Seleccione **Iniciar instancia**. 

1. Puede ver el estado del lanzamiento en la página **Instances**. Al lanzar una instancia, su estado inicial es `pending`. Una vez iniciada la instancia, el estado cambia a `running` y recibe un nombre de DNS público. (Si la columna **Public DNS** no se muestra, haga clic en el icono **Show/Hide** y después seleccione **Public DNS**.)

## Paso 2: agregación de los permisos del bucket de artefactos al rol de instancia de EC2
<a name="tutorials-ec2-deploy-role-s3"></a>

Debe actualizar el rol de instancia de EC2 que creó para su instancia a fin de que pueda acceder al bucket de artefactos de su canalización. 

**nota**  
Al crear la instancia, se crea o se utiliza un rol de instancia de EC2 existente. Para evitar `Access Denied` errores, debes añadir permisos de bucket de S3 a la función de instancia para conceder a la instancia permisos de acceso al bucket de CodePipeline artefactos. Cree un rol predeterminado o actualice el rol actual con el permiso `s3:GetObject` limitado al bucket de artefactos correspondiente a la región de su canalización.

1. Navega hasta tu canalización en la CodePipeline consola. Seleccione **Configuración**. Vea el nombre y la ubicación del almacén de artefactos de una canalización existente. Anote el nombre de recurso de Amazon (ARN) del bucket de artefactos y cópielo.

1. Vaya a la consola de IAM y elija **Roles (Roles)**. Elija el rol de instancia que creó en el paso 1 de este tutorial.

1. En la pestaña **Permisos**, elija **Añadir política en línea**.

1. Agregue el siguiente JSON al documento de política y sustituya el valor del campo `Resource` por el ARN del bucket.

   ```
   {
       "Effect": "Allow",
       "Principal": "*",
       "Action": "s3:GetObject",
       "Resource": "arn:aws:s3:::BucketName"
   }
   ```

1. Elija **Actualizar**.

## Paso 3: agregación del archivo de script al repositorio
<a name="tutorials-ec2-deploy-file"></a>

Pegue este texto de ejemplo para crear el archivo `script.sh` para el paso posterior al script de la implementación.

```
echo "Hello World!" 
```

**Para añadir un archivo `script.sh` a su repositorio de código fuente**

1. Abra un editor de texto y luego copie y pegue el archivo anterior en un nuevo archivo.

1. Confirme la operación e inserte el archivo `script.sh` en el repositorio de código fuente.

   1. Añada el archivo.

      ```
      git add .
      ```

   1. Valide el cambio con.

      ```
      git commit -m "Adding script.sh."
      ```

   1. Envíe la confirmación.

      ```
      git push
      ```

   Anote la ruta en su repositorio.

   ```
   /MyDemoRepo/test/script.sh
   ```

## Paso 4: creación de una canalización
<a name="tutorials-ec2-deploy-pipeline"></a>

Usa el CodePipeline asistente para crear las etapas de tu canalización y conectar tu repositorio de origen.

**Para crear la canalización**

1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Usar la función de servicio existente** y, a continuación, elija la función de CodePipeline servicio que se ha actualizado con los permisos necesarios para esta acción. Para configurar el rol CodePipeline de servicio para esta acción, consulte[Permisos de la política de rol de servicio para la acción de implementación de EC2](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action).

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de origen**, elija **GitHub (a través de GitHub la aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Repository name (Nombre de repositorio)**, elija el nombre de su repositorio de GitHub .

   Elija **Siguiente**.

1. En la página **Paso 4: agregación de la etapa de compilación**, seleccione **Omitir**.

1. En la página **Paso 5: agregación de la etapa de implementación**, elija **EC2**.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. En el **directorio de destino**, especifique el directorio de la instancia en la que desee realizar la implementación, por ejemplo, `/home/ec2-user/testhelloworld`.
**nota**  
Especifique el directorio de implementación que desea que utilice la acción en la instancia. La acción automatizará la creación del directorio especificado en la instancia como parte de la implementación.

   1. Para **PostScript**, introduzca la ruta y el nombre de archivo del script, por ejemplo`test/script.sh`.

   1. Elija **Siguiente**.

1. En la página **Step 6: Review**, revise la configuración de la canalización y elija **Create pipeline** para crear la canalización.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. Cuando la canalización se haya ejecutado correctamente, elija **Ver detalles** para consultar los registros de la acción y ver la salida de la acción de computación administrada.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## Paso 5: Pon a prueba tu canalización
<a name="tutorials-ec2-deploy-test"></a>

Su canalización debe tener todo lo necesario para ejecutar una implementación AWS continua end-to-end nativa. Ahora, pruebe su funcionalidad enviando un cambio de código al repositorio de código fuente.

**Para probar la canalización**

1. Realice una modificación del código en el repositorio de código fuente configurado, valide y envíe el cambio.

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleccione su canalización de la lista.

1. Vea el progreso en la canalización a través de sus etapas. La canalización debería completarse y la acción implementar el script en las instancias.

1. Para obtener más información sobre la solución de problemas, consulte [Error en la acción de implementación de EC2 con el mensaje `No such file`](troubleshooting.md#troubleshooting-ec2-deploy).

# Tutorial: Cree e inserte una imagen de Docker en Amazon ECR con CodePipeline (tipo V2)
<a name="tutorials-ecr-build-publish"></a>

Este tutorial le ayuda a crear una acción de compilación CodePipeline que ejecute y envíe su imagen de Docker a Amazon ECR tras un cambio en el código fuente. En este tutorial, también se muestra cómo agregar una acción de implementación de Amazon ECS que implemente la imagen insertada.

**importante**  
Como parte de la creación de una canalización en la consola, for Artifacts Bucket utilizará un bucket de artefactos de S3. CodePipeline (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
Este tutorial describe la acción de ECRBuild AndPublish creación de una CodePipeline canalización con un repositorio de GitHub origen y una acción estándar de Amazon ECS para la implementación en un clúster de Amazon ECS. Para ver un tutorial que utiliza una canalización con un repositorio de imágenes ECR como fuente de una acción de implementación de Amazon ECS a CodeDeploy azul/verde, consulte. CodePipeline [Tutorial: Creación de una canalización con una fuente y ECS-to-CodeDeploy una implementación de Amazon ECR](tutorials-ecs-ecr-codedeploy.md)

**importante**  
Esta acción utiliza la CodeBuild computación CodePipeline administrada para ejecutar comandos en un entorno de compilación. Si ejecuta la acción de Comandos, se le cobrarán cargos por separado en AWS CodeBuild.

## Requisitos previos
<a name="tutorials-ecr-build-publish-prereqs"></a>

Para poder usar este tutorial para crear su propia canalización de implementación continua debe tener instalados algunos recursos. Esto es lo que necesita para empezar:

**nota**  
Todos estos recursos deben crearse en la misma AWS región.
+ Un repositorio de control de código fuente (se utiliza en este tutorial GitHub) en el que añadirá lo siguiente para este tutorial:
  + En el paso 1, añadirá un ejemplo de Dockerfile a su repositorio fuente como artefacto de entrada para la acción de ECRBuild AndPublish compilación en él. CodePipeline
  + En el paso 2, agregará un archivo imagedefinitions.json de muestra a su repositorio de origen como requisito para la acción de implementación estándar de Amazon ECS en. CodePipeline
+ Un repositorio de imágenes de Amazon ECR que contiene una imagen compilada desde el Dockerfile. Para obtener más información, consulte [Creación de un repositorio](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) e [Inserción de una imagen](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) en la *Guía del usuario de Amazon Elastic Container Registry*.
+ Un servicio y un clúster de Amazon ECS creados en la misma región que el repositorio de imágenes. Para obtener más información, consulte [Creación de un clúster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) y [Creación de un servicio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

Una vez satisfechos estos requisitos previos, puede continuar con el tutorial y crear su canalización de implementación continua.

## Paso 1: agregación de un Dockerfile al repositorio de origen
<a name="tutorials-ecr-build-publish-file"></a>

En este tutorial, se utiliza la ECRBuild AndPublish acción para crear la imagen de Docker y enviarla a Amazon ECR. La acción de cómputo gestionado se CodePipeline utiliza CodeBuild para ejecutar los comandos de inicio de sesión y inserción de imágenes en el ECR. No necesita añadir un `buildspec.yml` archivo a su repositorio de código fuente para saber CodeBuild cómo hacerlo. Para este ejemplo, solo debe proporcionar el Dockerfile en el repositorio tal y como se indica a continuación.

Pegue este texto de ejemplo para crear su archivo `Dockerfile`. Este Dockerfile de ejemplo es el mismo que el utilizado en las instrucciones de las imágenes de ECR en los requisitos previos.

```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest

# Install dependencies
RUN yum update -y && \
 yum install -y httpd

# Install apache and write hello world message
RUN echo 'Hello World!' > /var/www/html/index.html

# Configure apache
RUN echo 'mkdir -p /var/run/httpd' >> /root/run_apache.sh && \
 echo 'mkdir -p /var/lock/httpd' >> /root/run_apache.sh && \
 echo '/usr/sbin/httpd -D FOREGROUND' >> /root/run_apache.sh && \
 chmod 755 /root/run_apache.sh

EXPOSE 80

CMD /root/run_apache.sh
```

**Para añadir un archivo `Dockerfile` a su repositorio de código fuente**

1. Abra un editor de texto y luego copie y pegue el Dockerfile anterior en un archivo nuevo.

1. Confirme la operación e inserte el archivo `Dockerfile` en el repositorio de código fuente.

   1. Añada el archivo.

      ```
      git add .
      ```

   1. Valide el cambio con.

      ```
      git commit -m "Adding Dockerfile."
      ```

   1. Envíe la confirmación.

      ```
      git push
      ```

   Asegúrese de colocar el archivo en el nivel raíz del repositorio.

   ```
   / Dockerfile
   ```

## Paso 2: agregación del archivo imagedefinitions.json a su repositorio de origen
<a name="w2aac13b9c15"></a>

En este tutorial, se utiliza la acción de implementación estándar de Amazon ECS CodePipeline para implementar el contenedor en el clúster de Amazon ECS. La acción de implementación estándar de Amazon ECS requiere un archivo imagedefinitions.json que contenga el nombre y el URI de la imagen. Para obtener más información sobre el archivo imagedefinitions.json, consulte [Archivo imagedefinitions.json para las acciones de implementación estándar de](file-reference.md#pipelines-create-image-definitions).

Pegue este texto de ejemplo para crear su archivo `imagedefinitions.json`. Use el nombre del Dockerfile, por ejemplo, `hello-world`, y use el URI del repositorio de Amazon ECR donde está almacenada la imagen.

```
[
  {
    "name": "hello-world",
    "imageUri": "ACCOUNT-ID.dkr.ecr.us-east-1.amazonaws.com/actions/image-repo"
  }
]
```

**Cómo agregar un archivo `imagedefinitions.json` a su repositorio de origen**

1. Abra un editor de texto y luego copie y pegue el archivo anterior en un archivo nuevo.

1. Confirme la operación e inserte el archivo `imagedefinitions.json` en el repositorio de código fuente.

   1. Añada el archivo.

      ```
      git add .
      ```

   1. Valide el cambio con.

      ```
      git commit -m "Adding imagedefinitions.json."
      ```

   1. Envíe la confirmación.

      ```
      git push
      ```

   Asegúrese de colocar el archivo en el nivel raíz del repositorio.

   ```
   / imagedefinitions.json
   ```

## Paso 3: creación de una canalización
<a name="tutorials-ecr-build-publish-pipeline"></a>

Utilice el CodePipeline asistente para crear las etapas de la canalización y conectar el repositorio de origen.

**Para crear la canalización**

1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de origen**, elija **GitHub (a través de GitHub la aplicación).**

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Repository name (Nombre de repositorio)**, elija el nombre de su repositorio de GitHub .

   1. En la **Ramificación predeterminada**, elige la ramificación que quiere especificar cuando la canalización se inicie manualmente o con un evento de origen que no sea una etiqueta de Git. Si la fuente del cambio no es el desencadenador o si la ejecución de una canalización se inició manualmente, el cambio utilizado será la confirmación de HEAD desde la ramificación predeterminada.

   Elija **Siguiente**.

1. En la página **Paso 4: Añadir una fase de compilación**, elija **Otros proveedores de compilación **ECRBuildAndPublish****.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ecrbuild-wizard.png)

   1. En **Nombre del repositorio de ECR**, elija su repositorio de imágenes.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: agregación de la etapa de implementación**, elija **Omitir etapa de implementación**. Agregará la acción de ECS en el paso siguiente.

1. En la página **Paso 7: Revisar**, revisa la configuración de la canalización y selecciona **Crear canalización** para crear la canalización.

1. Edite su canalización para agregar la acción de implementación de Amazon ECS a la canalización:

   1. En la parte superior derecha, elija **Edit (Editar)**.

   1. En la parte inferior del diagrama, seleccione **\$1 Add stage (Añadir etapa)**. En **Nombre de la etapa**, escriba un nombre; por ejemplo, **Deploy**.

   1. Elija **\$1 Add action group (Añadir grupo de acciones)**.

   1. En **Nombre de la acción**, escriba un nombre. 

   1. En **Proveedor de acción**, elija Amazon ECS. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. En **Artefactos de entrada**, elija el artefacto de entrada de la etapa de origen, como `SourceArtifact`. 

   1. En **Nombre del clúster**, elija el clúster de en el que se ejecuta el servicio.

   1. En **Nombre de servicio**, elija el servicio que desea actualizar.

   1. Seleccione **Save**.

   1. En la etapa que está editando, elija **Done (Listo)**. En el panel de AWS CodePipeline , elija **Save (Guardar)** y, a continuación, elija **Save (Guardar)** cuando aparezca el mensaje de advertencia.

   1. Para enviar los cambios y comenzar una compilación de canalización, seleccione **Publicar modificación** y, a continuación, **Publicar**.

1. Una vez ejecutada la canalización, consulte la estructura y el estado de la canalización.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ecrbuild-ecsaction.png)

1. Cuando la canalización se haya ejecutado correctamente, elija **Ver detalles** para consultar los registros de la acción y ver la salida de la acción de computación administrada.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ecrbuild-logs.png)

1. Solucione los problemas de cualquier acción fallida. Por ejemplo, la acción de implementación de ECS puede fallar si el archivo imagedefinitions.json no está en el repositorio de origen. A continuación, se muestra un ejemplo del mensaje de error que aparece cuando falta el archivo imagedefinitions.json.   
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ecrbuild-ecsdebug.png)

## Paso 4: Probar la canalización
<a name="tutorials-ecr-build-publish-test"></a>

Tu canalización debe tener todo lo necesario para ejecutar una implementación AWS continua end-to-end nativa. Ahora, pruebe su funcionalidad enviando un cambio de código al repositorio de código fuente.

**Para probar la canalización**

1. Realice una modificación del código en el repositorio de código fuente configurado, valide y envíe el cambio.

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleccione su canalización de la lista.

1. Vea el progreso en la canalización a través de sus etapas. Su canalización debería completarse y su acción insertar la imagen de Docker en ECR que se creó a partir de la modificación del código.

# Tutorial: Implemente en Amazon EKS con CodePipeline
<a name="tutorials-eks-deploy"></a>

Este tutorial le ayuda a crear una acción de implementación CodePipeline que despliegue el código en un clúster que haya configurado en Amazon EKS.

La acción de EKS admite clústeres de EKS públicos y privados. Los clústeres privados son el tipo recomendado por EKS, pero se admiten ambos.

**nota**  
Como parte de la creación de una canalización en la consola, CodePipeline para los artefactos se utilizará un depósito de artefactos de S3. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
Esta acción utiliza la CodeBuild informática CodePipeline gestionada para ejecutar comandos en un entorno de compilación. Si ejecuta la acción de Comandos, se le cobrarán cargos por separado en AWS CodeBuild.

**nota**  
La acción de implementación de `EKS` solo está disponible para canalizaciones de tipo V2.

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

Para poder usar este tutorial para crear su propia canalización de implementación continua debe tener instalados algunos recursos. Esto es lo que necesita para empezar:

**nota**  
Todos estos recursos deben crearse en la misma AWS región.
+ Un repositorio de control de código fuente (se utiliza en este tutorial GitHub) donde agregará un `deployment.yaml` archivo de muestra.
+ Debe usar un rol de CodePipeline servicio existente que actualizará con los permisos para esta acción que [Paso 3: Actualiza la política de roles de CodePipeline servicio en IAM](#tutorials-eks-deploy-role) se indican a continuación. Los permisos necesarios dependen del tipo de clúster que cree. Para obtener más información, consulte [Permisos para las políticas de roles de servicio](action-reference-EKS.md#action-reference-EKS-service-role).
+ Una imagen funcional y una etiqueta de repositorio que haya insertado en ECR o en su repositorio de imágenes.

Una vez satisfechos estos requisitos previos, puede continuar con el tutorial y crear su canalización de implementación continua.

## Paso 1: creación de un clúster en Amazon EKS (opcional)
<a name="tutorials-eks-deploy-cluster"></a>

Si lo desea, puede crear un clúster de EKS con un punto de conexión público o privado. 

En los siguientes pasos, se crea un clúster público o privado en EKS. Este paso es opcional si ya ha creado el clúster.

### Creación de un clúster público en Amazon EKS
<a name="tutorials-eks-deploy-cluster-public"></a>

En este paso, se crea un clúster en EKS.

**Creación de un clúster público**

1. Abra la consola de EKS y elija **Crear clúster**.

1. En **Nombre**, asigne un nombre al clúster. Elija **Next (Siguiente)**.

1. Seleccione **Create (Crear)**.

### Creación de un clúster privado en Amazon EKS
<a name="tutorials-eks-deploy-cluster-private"></a>

Si decide crear un clúster con un punto de conexión privado, asegúrese de asociar únicamente las subredes privadas y de que estas tengan conexión a Internet.

Realice los cinco pasos secundarios siguientes para crear un clúster con un punto de conexión privado.

**Creación de una VPC en la consola**

1. Abra la consola de VPC y elija **Crear VPC**.

1. En **Configuración de VPC**, seleccione **VPC y más**.

1. Elija crear una subred pública y cuatro subredes privadas. Seleccione **Creación de VPC**.

1. En la página de subredes, elija **Privada**. 

**Determinación de las subredes privadas en la VPC**

1. Navegue hasta la VPC y seleccione el ID de VPC para abrir la página de detalles de la VPC.

1. En la página de detalles de la VPC, elija la pestaña **Mapa de recursos**.

1. Vea el diagrama y anote sus subredes privadas. Las subredes se muestran con etiquetas que indican su estado público o privado, y cada subred está asignada a una tabla de enrutamiento.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/eks-deploy-subnets.png)

   Tenga en cuenta que en un clúster privado todas las subredes serán privadas.

1. Cree una subred pública para alojar la puerta de enlace NAT. Solo puede adjuntar una gateway de Internet a una VPC a la vez.

**Creación de una puerta de enlace NAT en la subred pública**

1. En la subred pública, cree una puerta de enlace NAT. Navegue hasta la consola de VPC y, a continuación, elija **Puertas de enlace de Internet**. Elija **Crear puerta de enlace de Internet**.

1. En Nombre, escriba el nombre de la puerta de enlace de Internet. Elija **Crear puerta de enlace de Internet**.

Actualice la tabla de enrutamiento de la subred privada para que dirija el tráfico a la puerta de enlace NAT.

**Agregación de la puerta de enlace NAT a las tablas de enrutamiento de las subredes privadas**

1. Navegue hasta la consola de VPC y, a continuación, elija **Subredes**.

1. Elija cada subred privada y, a continuación, la tabla de enrutamiento de esa subred en la página de detalles. Elija **Editar tabla de enrutamiento**. 

1. Actualice la tabla de enrutamiento de la subred privada para que dirija el tráfico de Internet a la puerta de enlace NAT. Seleccione **Añadir ruta**. Elija **Puerta de enlace NAT** entre las opciones para agregar. Elija la puerta de enlace de Internet que creó.

1. Para la subred pública, cree una tabla de enrutamiento personalizada. Verifique que la lista de control de acceso (ACL) de red de la subred pública permita el tráfico de entrada de la subred privada.

1. Seleccione **Save changes (Guardar cambios)**.

En este paso, se crea un clúster en EKS.

**Creación de un clúster privado**

1. Abra la consola de EKS y elija **Crear clúster**.

1. En **Nombre**, asigne un nombre al clúster. Elija **Siguiente**.

1. Especifique su VPC y otra información de configuración. Seleccione **Crear**.

El clúster de EKS puede ser público o privado. Este paso es para clústeres que tienen SOLO un punto de conexión privado. Asegúrese de que el clúster sea privado.

## Paso 2: configuración de un clúster privado en Amazon EKS
<a name="tutorials-eks-deploy-cluster-private-configure"></a>

Este paso solo es aplicable si ha creado un clúster privado. Este paso es para clústeres que tienen SOLO un punto de conexión privado. 

**Configuración de su clúster**

1. Asocie las subredes privadas únicamente en el clúster de EKS bajo la pestaña **Redes**. Asocie las subredes privadas capturadas en la sección **Determinación de las subredes privadas en la VPC** de [Paso 1: creación de un clúster en Amazon EKS (opcional)](#tutorials-eks-deploy-cluster).

1. Asegúrese de que las subredes privadas tengan acceso a Internet, ya que CodePipeline almacenan y recuperan los artefactos del depósito de artefactos de S3 para su canalización.

## Paso 3: Actualiza la política de roles de CodePipeline servicio en IAM
<a name="tutorials-eks-deploy-role"></a>

En este paso, actualizará un rol de CodePipeline servicio existente, por ejemplo`cp-service-role`, con los permisos necesarios CodePipeline para conectarse a su clúster. Si no dispone de un rol, cree uno.

Actualice su rol de CodePipeline servicio con los siguientes pasos.

**Para actualizar su política CodePipeline de roles de servicio**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

1. En el panel de la consola, elija **Roles**.

1. Busque su función CodePipeline de servicio, por ejemplo. `cp-service-role`

1. Agregue una nueva política insertada.

1. En el **Editor de políticas**, especifique lo siguiente.
   + Para un clúster público, agregue los siguientes permisos.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             }
         ]
     }
     ```

------
   + Para un clúster privado, agregue los siguientes permisos. Los clústeres privados requerirán permisos adicionales para su VPC, según corresponda.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterfacePermission",
                 "Resource": "*",
                 "Condition": {
                     "ArnEquals": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:DeleteNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             }
         ]
     }
     ```

------

1. Elija **Actualizar política**.

## Paso 4: Cree una entrada de acceso para el rol CodePipeline de servicio
<a name="tutorials-eks-deploy-access-entry"></a>

En este paso, crea una entrada de acceso en el clúster que añadirá la función de CodePipeline servicio que actualizó en el paso 3, junto con una política de acceso gestionado.

1. Abra la consola de EKS y navegue hasta el clúster.

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

1. En **Entradas de acceso de IAM**, elija **Crear entrada de acceso**.

1. En **ARN de entidad principal de IAM**, introduzca el rol que acaba de actualizar para la acción, como `cp-service-role`. Elija **Siguiente**.

1. En la página **Paso 2: agregación de una política de acceso**, en **Nombre de la política**, elija la política administrada para el acceso, como `AmazonEKSClusterAdminPolicy`. Elija **Add Policy (Agregar política)**. Elija **Siguiente**.
**nota**  
Esta es la política que utiliza la CodePipeline acción para comunicarse con Kubernetes. Como práctica recomendada, para limitar los permisos de la política con privilegio mínimo, en lugar de la política administrativa, asocie una política personalizada.

1. En la página Revisar, elija **Crear**.

## Paso 5: creación de un repositorio de origen y agregación de los archivos de configuración `helm chart`
<a name="tutorials-eks-deploy-source"></a>

En este paso, se crea un archivo de configuración adecuado para la acción (archivo de manifiesto de Kubernetes o gráfico de Helm) y luego se almacena en el repositorio de origen. Utilice el archivo de configuración adecuado. [Para obtener más información, consulta https://kubernetes. ](https://kubernetes.io/docs/reference/kubectl/quick-reference/)io/docs/reference/kubectl/quick[-reference/ o https://helm. sh/docs/topics/charts](https://helm.sh/docs/topics/charts/)/.
+ Para Kubernetes, utilice un archivo de manifiesto.
+ Para Helm, utilice un gráfico de Helm.

1. Cree o utilice un GitHub repositorio existente.

1. Cree una nueva estructura en su repositorio para los archivos de gráfico de Helm, como se muestra en el siguiente ejemplo.

   ```
   mychart
   |-- Chart.yaml
   |-- charts
   |-- templates
   |   |-- NOTES.txt
   |   |-- _helpers.tpl
   |   |-- deployment.yaml
   |   |-- ingress.yaml
   |   `-- service.yaml
   `-- values.yaml
   ```

1. Agregue el archivo en el nivel raíz del repositorio.

## Paso 6: creación de una canalización
<a name="tutorials-eks-deploy-pipeline"></a>

Usa el CodePipeline asistente para crear las etapas de tu canalización y conectar tu repositorio de origen.

**Para crear la canalización**

1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyEKSPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Rol de servicio**, seleccione el rol de servicio que actualizó en el paso 3.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: Añadir la fase de origen**, en **Source provider**, selecciona **crear una conexión con tu GitHub repositorio**.

1. En la página **Paso 4: agregación de la etapa de compilación**, seleccione **Omitir**.

1. En la página **Paso 5: agregación de la etapa de implementación**, elija **Amazon EKS**.  
![\[Deploy configuration form with Helm selected, showing fields for release name and chart location.\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/eks-action-example.png)

   1. En **Tipo de configuración de implementación**, elija **Helm**.

   1. En **Ubicación del gráfico de Helm**, introduzca el nombre de la versión, como `my-release`. Para **Ubicación del gráfico de Helm**, introduzca la ruta de los archivos de gráfico de Helm, como `mychart`.

   1. Elija **Siguiente**.

1. En la página **Step 6: Review**, revise la configuración de la canalización y elija **Create pipeline** para crear la canalización.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/eks-deploy-pipeline.png)

1. Cuando la canalización se haya ejecutado correctamente, elija **Ver detalles** para ver los registros de la acción y su salida.

# Tutorial: creación de una canalización que ejecute comandos mediante computación (tipo V2)
<a name="tutorials-commands"></a>

En este tutorial, va a configurar una canalización que ejecutará constantemente comandos de compilación mediante la acción de Comandos en una etapa de compilación. Para obtener más información acerca de la acción de Comandos, consulte [Referencia de la acción de Comandos](action-reference-Commands.md).

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para crear artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

## Requisitos previos
<a name="tutorials-commands-prereq"></a>

Debe disponer de lo siguiente:
+ Un repositorio. GitHub Puedes usar el GitHub repositorio en el que lo creaste[Tutorial: Utilice un clon completo con una fuente de GitHub canalización](tutorials-github-gitclone.md).

## Paso 1: Crea los archivos fuente y envíalos a tu GitHub repositorio
<a name="tutorials-commands-push"></a>

En esta sección, debe crear e insertar los archivos de fuente al repositorio que utiliza la canalización para la etapa de origen. Para este ejemplo, se produce y se inserta lo siguiente: 
+ Un archivo `README.txt`.

**Para crear archivos de fuente**

1. Cree un archivo con el siguiente texto:

   ```
   Sample readme file
   ```

1. Guarde el archivo como `README.txt`.

**Para enviar archivos a tu GitHub repositorio**

1. Envíe o cargue los archivos en el repositorio de . Estos archivos son el artefacto de código fuente creado por el asistente **Create Pipeline (Crear canalización)** para la acción de implementación en AWS CodePipeline. Sus archivos deberían ser parecidos a estos en su directorio local:

   ```
   README.txt
   ```

1. Para utilizar la línea de comandos de Git desde un repositorio clonado en el equipo local:

   1. Ejecute el siguiente comando para preparar todos los archivos de una vez:

      ```
      git add -A
      ```

   1. Ejecute el siguiente comando para confirmar los archivos con un mensaje de confirmación.

      ```
      git commit -m "Added source files"
      ```

   1. Ejecute el siguiente comando para enviar los archivos de su repositorio local al repositorio de :

      ```
      git push
      ```

## Paso 2: Crear la canalización
<a name="tutorials-commands-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una acción GitHub (a través de la GitHub aplicación) para el repositorio donde se almacenan los archivos de origen.
+ Una etapa de compilación con la acción de Comandos.

**Para crear una canalización con el asistente**

1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyCommandsPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.
**nota**  
Si utiliza un rol de servicio existente, para utilizar la acción de Comandos tendrá que agregar los siguientes permisos para el rol de servicio. Reduzca los permisos al nivel de recursos de la canalización a través de los permisos basados en recursos de la declaración de la política del rol de servicio. Para obtener más información, consulte la política de ejemplo en [Permisos para las políticas de roles de servicio](action-reference-Commands.md#action-reference-Commands-policy).  
registros: CreateLogGroup
registros: CreateLogStream
registros: PutLogEvents

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de código fuente**, selecciona **GitHub (a través de GitHub la aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Nombre del repositorio**, elige el nombre de tu GitHub repositorio.com. 

   1. En la **Ramificación predeterminada**, elige la ramificación que quiere especificar cuando la canalización se inicie manualmente o con un evento de origen que no sea una etiqueta de Git. Si la fuente del cambio no es el desencadenador o si la ejecución de una canalización se inició manualmente, el cambio utilizado será la confirmación de HEAD desde la ramificación predeterminada. Opcionalmente, también puede especificar webhooks con filtrado (desencadenadores). Para obtener más información, consulte [Automatización del inicio de las canalizaciones mediante desencadenadores y filtrado](pipelines-triggers.md).

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, seleccione **Comandos**.
**nota**  
Si ejecuta la acción de Comandos, se le cobrarán cargos por separado en AWS CodeBuild.

   Ejecute los comandos siguientes: 

   ```
   ls
   echo hello world
   cat README.txt
   echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}
   ```

   Elija **Siguiente**.  
![\[Página Paso 4: agregación de la etapa de compilación para una nueva canalización con la acción de comandos\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/commands-wizard-screen.png)

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En **Paso 6: agregación de la etapa de implementación**, elija **Omitir la etapa de implementación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 7: Revisar**, revisa la información y, a continuación, selecciona **Crear canalización**.

1. Como último paso para crear la acción, agregue una variable de entorno a la acción que dé como resultado una variable de salida para la acción. En la acción de Comandos, elija **Editar**. En la pantalla **Editar**, especifique un espacio de nombres de variables para la acción introduciendo `compute` en el campo **Espacio de nombres de variables**.

   Agregue la variable CodeBuild de salida y`AWS_Default_Region`, a continuación, elija **Agregar variable**.  
![\[La página Editar de la acción de Comandos\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/commands-output-edit-var.png)

## Paso 3: ejecución de una canalización y verificación de los comandos de compilación
<a name="tutorials-commands-update"></a>

Publique algún cambio para ejecutar su canalización. Compruebe que los comandos de compilación se hayan ejecutado; para ello, consulte el historial de ejecución, los registros de compilación y las variables de salida.

**Para ver los registros de acciones y las variables de salida**

1. Después de que la canalización se ejecute correctamente, podrá ver los registros y el resultado de la acción.

1. Para ver las variables de salida de la acción, seleccione **Historial** y, a continuación, seleccione **Línea temporal**. 

   Vea la variable de salida que se agregó a la acción. El resultado de la acción de Comandos muestra la variable de salida resuelta en la región de la acción.  
![\[Resultado de la acción de Comandos que muestra la variable de salida resuelta en la región de la acción\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/commands-output-variable.png)

1. Para ver los registros de la acción, seleccione **Ver detalles** de la acción de Comandos realizada correctamente. Vea los registros de la acción de Comandos.  
![\[Ejemplos de registros de la acción de Comandos\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/commands-output-logs.png)

# Tutorial: Usar etiquetas de Git para iniciar la canalización
<a name="tutorials-github-tags"></a>

En este tutorial, crearás una canalización que se conecte a tu GitHub repositorio donde la acción de origen esté configurada para el tipo de activador de etiquetas de Git. Cuando se crea una etiqueta Git en una confirmación, se inicia su canalización. En este ejemplo, se muestra cómo crear una canalización que permita filtrar las etiquetas en función de la sintaxis del nombre de la etiqueta. Para obtener más información acerca de filtros con patrones de glob, consulte [Trabajar con patrones glob en la sintaxis](syntax-glob.md).

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para los artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

Este tutorial se conecta a GitHub través del `CodeStarSourceConnection` tipo de acción.

**nota**  
Esta característica no está disponible en las regiones de Asia-Pacífico (Hong Kong), África (Ciudad del Cabo), Medio Oriente (Baréin), Europa (Zúrich). Para hacer referencia a otras acciones disponibles, consulte [Integraciones de productos y servicios con CodePipeline](integrations.md). Para ver consideraciones sobre esta acción en la región de Europa (Milán), consulte la nota que aparece en [CodeStarSourceConnection para Bitbucket Cloud GitHub, GitHub Enterprise Server, GitLab .com y acciones GitLab autogestionadas](action-reference-CodestarConnectionSource.md).

**Topics**
+ [

## Requisitos previos
](#tutorials-github-tags-prereq)
+ [

## Paso 1: Abre CloudShell y clona tu repositorio
](#w2aac13c16c15)
+ [

## Paso 2: Crear una canalización para activarla en las etiquetas de Git
](#tutorials-github-tags-pipeline)
+ [

## Paso 3: Etiquetar las confirmaciones para publicarlas
](#w2aac13c16c19)
+ [

## Paso 4: Publicar los cambios y ver los registros
](#tutorials-github-tags-view)

## Requisitos previos
<a name="tutorials-github-tags-prereq"></a>

Antes de empezar, debe hacer lo siguiente:
+ Crea un GitHub repositorio con tu GitHub cuenta.
+ Ten tus GitHub credenciales preparadas. Cuando utilice el Consola de administración de AWS para configurar una conexión, se le pedirá que inicie sesión con sus GitHub credenciales. 

## Paso 1: Abre CloudShell y clona tu repositorio
<a name="w2aac13c16c15"></a>

Puede usar una interfaz de línea de comandos para clonar su repositorio, realizar confirmaciones y añadir etiquetas. Este tutorial lanza una CloudShell instancia para la interfaz de línea de comandos.

1. Inicie sesión en Consola de administración de AWS.

1. En la barra de navegación superior, selecciona el AWS icono. Se muestra la página principal de la Consola de administración de AWS .

1. En la barra de navegación superior, selecciona el AWS CloudShell icono. CloudShell se abre. Espere a que se cree el CloudShell entorno.
**nota**  
Si no ves el CloudShell icono, asegúrate de que estás en una [región compatible con CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). En este tutorial se da por sentado que está en la región de Oeste de EE. UU. (Oregón).

1. En GitHub, navega hasta tu repositorio. Elija **Código**, y a continuación, elija **HTTPS**. Copie la ruta. La dirección para clonar el repositorio Git se copia en el portapapeles.

1. Ejecute el siguiente comando para clonar el repositorio.

   ```
   git clone https://github.com/<account>/MyGitHubRepo.git
   ```

1. Introduce tu GitHub cuenta `Username` y `Password` cuando se te pida. Para la entrada `Password`, debe usar un token creado por el usuario en lugar de la contraseña de su cuenta.

## Paso 2: Crear una canalización para activarla en las etiquetas de Git
<a name="tutorials-github-tags-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una conexión a tu GitHub repositorio y a tu acción.
+ Una etapa de creación con una acción de AWS CodeBuild creación.

**Para crear una canalización con el asistente**

1. Inicia sesión en la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyGitHubTagsPipeline**.

1. En **Tipo de canalización**, mantenga la selección predeterminada en **V2**. Los tipos de canalización difieren en características y precio. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md).

1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Si opta por utilizar su función de CodePipeline servicio actual, asegúrese de haber añadido el permiso de `codestar-connections:UseConnection` IAM a su política de función de servicio. Para obtener instrucciones sobre la función de CodePipeline servicio, consulte [Añadir permisos a la función de CodePipeline servicio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. Para **Configuración avanzada** deje los valores predeterminados. En **Artifact store** (Almacén de artefactos), elija **Default location** (Ubicación predeterminada) para utilizar el almacén de artefactos predeterminado, como el bucket de artefacto de Amazon S3 que se estableció como predeterminado, para la canalización en la región que seleccionó para esta.
**nota**  
Este no es el bucket de origen para su código fuente. Este es el almacén de artefactos de la canalización. Cada canalización debe tener su propio almacén de artefactos independiente, como un bucket de S3.

   Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de origen**, elija **GitHub (mediante GitHub aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Repository name (Nombre de repositorio)**, elija el nombre de su repositorio de GitHub.

   1. En la **Ramificación predeterminada**, elige la ramificación que quiere especificar cuando la canalización se inicie manualmente o con un evento de origen que no sea una etiqueta de Git. Si la fuente del cambio no es el desencadenador o si la ejecución de una canalización se inició manualmente, el cambio utilizado será la confirmación de HEAD desde la ramificación predeterminada.

   1. En **Eventos de webhook**, en **Tipo de filtro**, elija **Etiquetas**.

      En el campo **Etiquetas o patrones**, especifique `release*`.
**importante**  
Las canalizaciones que comiencen con un tipo de desencadenador de etiquetas Git se configurarán para los eventos de WebHookV2 y no utilizarán el evento Webhook (detección de cambios en todos los eventos push) para iniciar la canalización.

   Elija **Siguiente**.

1. En **Add build stage (Añadir etapa de compilación)**, añada una etapa de compilación:

   1. En **Build provider (Proveedor de compilación)**, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **En **Imagen**, escoja: 5.0. aws/codebuild/standard**

   1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Anote el nombre de su función de servicio. CodeBuild Necesitará el nombre del rol para el paso final de este tutorial.

   1. En **Buildspec**, para **Build specifications** (Especificaciones de la compilación), elija **Insert build commands** (Insertar comandos de compilación). Elija **Cambiar a editor** y pegue lo siguiente en **Comandos de compilación**:

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Selecciona **Continuar a CodePipeline**. Esto vuelve a la CodePipeline consola y crea un CodeBuild proyecto que utiliza los comandos de compilación para la configuración. El proyecto de compilación usa un rol de servicio para administrar Servicio de AWS los permisos. Es posible que este paso tarde un par de minutos.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**.

## Paso 3: Etiquetar las confirmaciones para publicarlas
<a name="w2aac13c16c19"></a>

Después de crear tu canalización y especificar las etiquetas de Git, puedes etiquetar las confirmaciones en tu GitHub repositorio. En estos pasos, etiquetará una confirmación con la etiqueta `release-1`. Cada confirmación de un repositorio de Git debe tener una etiqueta Git única. Si elige la confirmación y la etiqueta, podrá incorporar los cambios de distintas ramificaciones a la implementación de su canalización. Ten en cuenta que el nombre de la etiqueta release no se aplica al concepto de lanzamiento en GitHub.

1. Haz referencia a la confirmación copiada que IDs deseas etiquetar. Para ver las confirmaciones en cada rama, en la CloudShell terminal, ingresa el siguiente comando para capturar la confirmación IDs que deseas etiquetar: 

   ```
   git log
   ```

1. En la CloudShell terminal, introduce el comando para etiquetar tu confirmación y envíala al origen. Después de etiquetar la confirmación, use el comando de inclusión git para enviar la etiqueta al origen. En el siguiente ejemplo, introduzca el siguiente comando para usar la etiqueta `release-1` en la segunda confirmación con ID `49366bd`. Esta etiqueta se filtrará mediante el filtro de etiquetas `release*` de la canalización e iniciará la canalización.

   ```
   git tag release-1 49366bd
   ```

   ```
   git push origin release-1
   ```  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/git-tags-pipeline.png)

## Paso 4: Publicar los cambios y ver los registros
<a name="tutorials-github-tags-view"></a>

1. Después de que la canalización se ejecute correctamente, en la etapa de implementación, elija **Ver registro**.

   En **Registros**, consulta el resultado de la CodeBuild compilación. Los comandos muestran el valor de la variable introducida.

1. En la página **Historial**, consulte la columna **Desencadenadores**. Consulta el tipo de disparador **GitTag : release-1**.

# Tutorial: filtrado de solicitudes de extracción por nombres de ramificación para iniciar una canalización (tipo V2)
<a name="tutorials-github-featurebranches"></a>

En este tutorial, crearás una canalización que se conecte a tu repositorio GitHub .com, donde se configura la acción de origen para iniciar la canalización con una configuración de activación que filtra las solicitudes de incorporación de cambios. Cuando se produce un evento de solicitud de extracción específico para una ramificación específica, se inicia la canalización. En este ejemplo, se muestra cómo crear una canalización que permita filtrar por nombres de ramificación. Para obtener más información acerca de cómo trabajar con desencadenadores, consulte [Agregación de filtros para los tipos de eventos de solicitud de inserción y extracción (CLI)](pipelines-filter.md#pipelines-filter-cli). Para obtener más información acerca del filtrado con patrones regex en formato glob, consulte [Trabajar con patrones glob en la sintaxis](syntax-glob.md).

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para crear artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

Este tutorial se conecta a GitHub .com a través del `CodeStarSourceConnection` tipo de acción.

**Topics**
+ [

## Requisitos previos
](#tutorials-github-featurebranches-prereq)
+ [

## Paso 1: creación de una canalización que iniciar con una solicitud de extracción de ramificaciones específicas
](#tutorials-github-featurebranches-pipeline)
+ [

## Paso 2: Crea y fusiona una solicitud de incorporación de cambios en GitHub .com para iniciar las ejecuciones de tu canalización
](#tutorials-github-featurebranches-pullrequest)

## Requisitos previos
<a name="tutorials-github-featurebranches-prereq"></a>

Antes de empezar, debe hacer lo siguiente:
+ Crea un repositorio GitHub .com con tu cuenta GitHub .com.
+ Ten tus GitHub credenciales preparadas. Cuando utilices el Consola de administración de AWS para configurar una conexión, se te pedirá que inicies sesión con tus GitHub credenciales. 

## Paso 1: creación de una canalización que iniciar con una solicitud de extracción de ramificaciones específicas
<a name="tutorials-github-featurebranches-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una conexión a tu repositorio y acción de GitHub .com.
+ Una etapa de creación con una acción de AWS CodeBuild creación.

**Para crear una canalización con el asistente**

1. Inicia sesión en la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyFilterBranchesPipeline**.

1. En **Tipo de canalización**, mantenga la selección predeterminada en **V2**. Los tipos de canalización difieren en características y precio. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md).

1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Si opta por utilizar su función de CodePipeline servicio actual, asegúrese de haber añadido el permiso de `codeconnections:UseConnection` IAM a su política de función de servicio. Para obtener instrucciones sobre la función de CodePipeline servicio, consulte [Añadir permisos a la función de CodePipeline servicio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. Para **Configuración avanzada** deje los valores predeterminados. En **Artifact store** (Almacén de artefactos), elija **Default location** (Ubicación predeterminada) para utilizar el almacén de artefactos predeterminado, como el bucket de artefacto de Amazon S3 que se estableció como predeterminado, para la canalización en la región que seleccionó para esta.
**nota**  
Este no es el bucket de origen para su código fuente. Este es el almacén de artefactos de la canalización. Cada canalización debe tener su propio almacén de artefactos independiente, como un bucket de S3.

   Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de origen**, elija **GitHub (a través de GitHub la aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Nombre del repositorio**, elige el nombre de tu GitHub repositorio.com.

   1. En **Tipo de desencadenador**, seleccione **Especificar filtro**.

      En **Tipo de evento**, seleccione **Solicitud de extracción**. Seleccione todos los eventos de la solicitud de extracción para que el evento se produzca para las solicitudes de extracción creadas, actualizadas o cerradas.

      En **Ramificaciones**, en el campo **Incluir**, introduzca `main*`.  
![\[Imagen que muestra la opción “Incluir ramificaciones” seleccionada con un valor de main* para un desencadenador con un tipo de evento de solicitud de extracción\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/pullreq-example-triggers-edit.png)
**importante**  
Las canalizaciones que se inicien con este tipo de desencadenador se configurarán para los eventos de WebhookV2 y no utilizarán el evento de Webhook (detección de cambios en todos los eventos de inserción) para iniciar la canalización.

   Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, en **Proveedor de compilación**, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización. Elija o cree el proyecto de compilación como se indica en [Tutorial: Usar etiquetas de Git para iniciar la canalización](tutorials-github-tags.md). Esta acción solo se usará en este tutorial como la segunda etapa necesaria para crear la canalización.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, selecciona **Omitir fase de despliegue** y, a continuación, acepta el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**.

## Paso 2: Crea y fusiona una solicitud de incorporación de cambios en GitHub .com para iniciar las ejecuciones de tu canalización
<a name="tutorials-github-featurebranches-pullrequest"></a>

En esta sección, va a crear y combinar una solicitud de extracción. Esto inicia la canalización, con una ejecución para la solicitud de extracción abierta y una ejecución para la solicitud de extracción cerrada.

**Para crear una solicitud de extracción e iniciar la canalización**

1. En GitHub .com, para crear una solicitud de extracción, haz un cambio en el archivo README.md de una rama de funciones y envía una solicitud de extracción a esa rama. `main` Confirme el cambio con un mensaje como `Update README.md for PR`.

1. La canalización se inicia con la revisión de código fuente, que muestra el mensaje **Código fuente** de la solicitud de extracción como **Update README.md for PR**.  
![\[Imagen que muestra el mensaje de código fuente de la solicitud de extracción con el siguiente texto: Update README.md for PR\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/pullreq-example.png)

1. Elija **Historial**. En el historial de ejecución de canalizaciones, consulte los eventos de estado de las solicitudes de extracción CREATED y MERGED que iniciaron las ejecuciones de canalización.  
![\[Imagen que muestra el historial de ejecución de canalizaciones con los eventos de estado de las solicitudes de extracción CREATED y MERGED que iniciaron las ejecuciones de canalización\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/pullreq-example-history.png)

# Tutorial: Uso de variables a nivel de canalización
<a name="tutorials-pipeline-variables"></a>

En este tutorial, crearás una canalización en la que añadirás una variable a nivel de canalización y ejecutarás una acción de CodeBuild creación que generará el valor de la variable.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para crear artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**Topics**
+ [

## Requisitos previos
](#tutorials-pipeline-variables-prereq)
+ [

## Paso 1: Crear la canalización y compilar el proyecto
](#tutorials-pipeline-variables-pipeline)
+ [

## Paso 2: Publicar los cambios y ver los registros
](#tutorials-pipeline-variables-view)

## Requisitos previos
<a name="tutorials-pipeline-variables-prereq"></a>

Antes de empezar, debe hacer lo siguiente:
+ Crea un repositorio. CodeCommit 
+ Añada un archivo .txt al repositorio.

## Paso 1: Crear la canalización y compilar el proyecto
<a name="tutorials-pipeline-variables-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una conexión a tu CodeCommit repositorio.
+ Una etapa de creación con una acción de AWS CodeBuild creación.

**Para crear una canalización con el asistente**

1. Inicia sesión en la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyVariablesPipeline**.

1. En **Tipo de canalización**, mantenga la selección predeterminada en **V2**. Los tipos de canalización difieren en características y precio. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md).

1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Si opta por utilizar su función de CodePipeline servicio actual, asegúrese de haber añadido el permiso de `codeconnections:UseConnection` IAM a su política de función de servicio. Para obtener instrucciones sobre la función de CodePipeline servicio, consulte [Añadir permisos a la función de CodePipeline servicio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. En **Variables**, seleccione **Añadir variable**. En **Name (Nombre)**, escriba `timeout`. En **Predeterminado**, escriba 1000. En la descripción, introduzca la siguiente descripción: **Timeout**.

   Esto creará una variable en la que podrá declarar el valor cuando comience la ejecución de la canalización. Los nombres de las variables deben coincidir con `[A-Za-z0-9@\-_]+` y pueden ser cualquier cosa excepto una cadena vacía.

1. Para **Configuración avanzada** deje los valores predeterminados. En **Artifact store** (Almacén de artefactos), elija **Default location** (Ubicación predeterminada) para utilizar el almacén de artefactos predeterminado, como el bucket de artefacto de Amazon S3 que se estableció como predeterminado, para la canalización en la región que seleccionó para esta.
**nota**  
Este no es el bucket de origen para su código fuente. Este es el almacén de artefactos de la canalización. Cada canalización debe tener su propio almacén de artefactos independiente, como un bucket de S3.

   Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Source provider (Proveedor de código fuente)**, elija **AWS CodeCommit**.

   1. En **Nombre del repositorio** y **Nombre de la ramificación**, elija su repositorio y ramificación.

   Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, agregue una etapa de compilación:

   1. En **Build provider (Proveedor de compilación)**, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **En **Imagen**, escoja: 5.0. aws/codebuild/standard**

   1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Anote el nombre de su función de servicio. CodeBuild Necesitará el nombre del rol para el paso final de este tutorial.

   1. En **Buildspec**, para **Build specifications** (Especificaciones de la compilación), elija **Insert build commands** (Insertar comandos de compilación). Elija **Cambiar a editor** y pegue lo siguiente en **Comandos de compilación**: En la especificación de compilación, se utilizará la variable de cliente `$CUSTOM_VAR1` para generar la variable de canalización en el registro de compilación. En el siguiente paso, creará la variable de salida `$CUSTOM_VAR1` como variable de entorno.

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - echo $CUSTOM_VAR1
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Selecciona **Continuar a CodePipeline**. Esto vuelve a la CodePipeline consola y crea un CodeBuild proyecto que utiliza los comandos de compilación para la configuración. El proyecto de compilación usa un rol de servicio para administrar Servicio de AWS los permisos. Es posible que este paso tarde un par de minutos.

   1. En **Variables de entorno *(opcional)***, para crear una variable de entorno como variable de entrada para la acción de creación que resolverá la variable a nivel de canalización, elija **Añadir variable de entorno**. Esto creará la variable especificada en la especificación de compilación como `$CUSTOM_VAR1`. En **Name (Nombre)**, escriba `CUSTOM_VAR1`. En **Valor**, escriba `#{variables.timeout}`. En **Tipo**, elija `Plaintext`.

      El `#{variables.timeout}` valor de la variable de entorno se basa en el espacio de nombres de la variable a nivel de canalización `variables` y en la variable a nivel de canalización `timeout` creada para la canalización en el paso 7.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. **En la página **Paso 6: Añadir fase de despliegue, seleccione Omitir fase** **de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando Omitir de nuevo.** Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**.

## Paso 2: Publicar los cambios y ver los registros
<a name="tutorials-pipeline-variables-view"></a>

1. Después de que la canalización se ejecute correctamente, en la etapa de implementación, elija **Ver detalles**.

   En la página de detalles, elija la pestaña **Registros**. Vea el resultado de la CodeBuild compilación. Los comandos muestran el valor de la variable introducida.

1. En el panel de navegación de la izquierda, elija **Historial**.

   Elija la ejecución reciente y, a continuación, elija la pestaña **Variables**. Vea el valor resuelto de la variable de canalización.

# Tutorial: Crear una canalización simple (bucket de S3)
<a name="tutorials-simple-s3"></a>

La forma más sencilla de crear una canalización es usar el asistente de **creación de canalización** de la AWS CodePipeline consola. 

En este tutorial, creará una canalización de dos etapas que utiliza un bucket de código fuente de S3 versionado y CodeDeploy lanzará una aplicación de muestra. 

**nota**  
Si Amazon S3 es el proveedor de origen de la canalización, debe comprimir los archivos de origen en un solo archivo.zip y cargarlo en el bucket de origen. También puede cargar un archivo sin comprimir; sin embargo, se producirá un error en las acciones posteriores que esperan un archivo.zip.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente para crear artefactos. CodePipeline (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

Una vez creada esta canalización simple, le agregará otra etapa para después deshabilitar y volver a habilitar la transición entre etapas.

**importante**  
Muchas de las acciones que añades a la canalización en este procedimiento implican AWS recursos que debes crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

Antes de comenzar, debe completar los requisitos previos de [Empezar con CodePipeline](getting-started-codepipeline.md).

**Topics**
+ [

## Paso 1: creación de un bucket de origen de S3 para la aplicación
](#s3-create-s3-bucket)
+ [

## Paso 2: Crear instancias Windows de Amazon EC2 e instalar el agente CodeDeploy
](#S3-create-instances)
+ [

## Paso 3: Crea una aplicación en CodeDeploy
](#S3-create-deployment)
+ [

## Paso 4: Crea tu primera canalización en CodePipeline
](#s3-create-pipeline)
+ [

## (Opcional) Paso 5: Agregar otra etapa a la canalización
](#s3-add-stage)
+ [

## (Opcional) Paso 6: deshabilitar y habilitar las transiciones entre etapas en CodePipeline
](#s3-configure-transitions)
+ [

## Paso 7: Limpiar recursos
](#s3-clean-up)

## Paso 1: creación de un bucket de origen de S3 para la aplicación
<a name="s3-create-s3-bucket"></a>

Puede almacenar sus aplicaciones o archivos de código fuente en cualquier ubicación con control de versiones. En este tutorial, va a crear un bucket de S3 para los archivos de la aplicación de ejemplo y a habilitar en él el control de versiones. Una vez habilitado el control de versiones, copiará las aplicaciones de ejemplo a ese bucket. 

**Para crear un bucket de S3**

1. Inicie sesión en la consola en Consola de administración de AWS. Abra la consola de S3.

1. Elija **Crear bucket**.

1. En **Bucket Name (Nombre del bucket)**, escriba el nombre del bucket (por ejemplo: **awscodepipeline-demobucket-example-date**).
**nota**  
Como todos los nombres de bucket en Amazon S3 deben ser únicos, elija un nombre que no sea el que aparece en el ejemplo. Puede cambiar el nombre del ejemplo simplemente añadiéndole la fecha. Anote este nombre, ya que lo necesitará durante el resto de este tutorial.

   En **Región**, elija la región en la que quiere crear la canalización (por ejemplo, **Oeste de EE. UU. (Oregón)**) y elija **Crear bucket**.

1. Una vez creado el bucket, aparecerá un banner donde se indicará que la operación se ha realizado correctamente. Elija **Go to bucket details (Acceder a los detalles del bucket)**.

1. En la pestaña **Properties (Propiedades)**, elija **Versioning (Control de versiones)**. Elija **Enable versioning (Habilitar control de versiones)** y haga clic en **Save (Guardar)**.

   Cuando se habilita este control de versiones, Amazon S3 guarda todas las versiones de cada objeto en el bucket.

1. En la pestaña **Permissions (Permisos)**, deje los valores predeterminados. Para obtener más información sobre los permisos de los objetos y los buckets de S3, consulte [Especificación de permisos en una política](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html).

1. A continuación, descargue un ejemplo y guárdelo en una carpeta o directorio del equipo local.

   1. Elija una de las siguientes opciones. Elija `SampleApp_Windows.zip` si desea seguir los pasos de este tutorial en instancias de Windows Server.
      + Si desea realizar la implementación en instancias de Amazon Linux mediante CodeDeploy, descargue la aplicación de muestra aquí: [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip).
      + Si desea realizar la implementación en instancias de Windows Server mediante CodeDeploy, descargue la aplicación de muestra aquí: [SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip).

      La aplicación de ejemplo contiene los siguientes archivos para realizar la implementación con CodeDeploy: 
      + `appspec.yml`— El archivo de especificaciones de la aplicación (AppSpecarchivo) es un archivo con formato [YAML](http://www.yaml.org) que se utiliza CodeDeploy para gestionar una implementación. *Para obtener más información sobre el AppSpec archivo, consulte la [referencia al CodeDeploy AppSpec archivo](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) en la Guía del AWS CodeDeploy usuario.*
      + `index.html`: el archivo de índice contiene la página de inicio de la aplicación de ejemplo implementada.
      + `LICENSE.txt`: el archivo de licencia contiene la información de licencia de la aplicación de ejemplo.
      + Archivos para scripts: la aplicación de ejemplo usa scripts para escribir archivos de texto en una ubicación de la instancia. Se escribe un archivo para cada uno de los diversos eventos del ciclo de vida de la CodeDeploy implementación, de la siguiente manera:
        + (Solo ejemplos de Linux) Carpeta `scripts`: la carpeta contiene los siguientes scripts de intérprete de comandos para instalar las dependencias e iniciar y detener la aplicación de ejemplo para la implementación automatizada: `install_dependencies`, `start_server` y `stop_server`.
        + (Solo ejemplo de Windows) `before-install.bat`: se trata de un script por lotes para el evento de ciclo de vida de implementación, que se ejecutará para eliminar los archivos antiguos escritos durante implementaciones anteriores de este ejemplo y crear una ubicación en su instancia en la que escribir los archivos nuevos.

   1. Descargue el archivo comprimido (en zip). No descomprima el archivo.

1. En la consola de Amazon S3, para su bucket suba el archivo:  

   1. Seleccione **Cargar**. 

   1. Arrastre y suelte el archivo o elija **Add files (Agregar archivos)** y busque el archivo.

   1. Seleccione **Cargar**.

## Paso 2: Crear instancias Windows de Amazon EC2 e instalar el agente CodeDeploy
<a name="S3-create-instances"></a>

**nota**  
Este tutorial contiene ejemplos de los pasos necesarios para crear instancias de Amazon EC2 de Windows. Si desea ver los pasos de ejemplo para crear instancias de Amazon EC2 para Linux, consulte [Paso 3: Crear una instancia Linux Amazon EC2 e instalar el agente CodeDeploy](tutorials-simple-codecommit.md#codecommit-create-deployment). Cuando le pidan el número de instancias que se van a crear, especifique **2** instancias.

En este paso, va a crear instancias de Amazon EC2 de Windows Server en las que implementará una aplicación de ejemplo. Como parte de este proceso, se crea un rol de instancia con políticas que permiten instalar y administrar el CodeDeploy agente en las instancias. El CodeDeploy agente es un paquete de software que permite utilizar una instancia en CodeDeploy las implementaciones. También debe adjuntar políticas que permiten a la instancia recuperar los archivos que el CodeDeploy agente utiliza para implementar la aplicación y permitir que SSM administre la instancia.

**Para crear un rol de instancia**

1. Abra la consola de IAM en). [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. En el panel de la consola, elija **Roles**.

1. Elija **Crear rol**.

1. En **Seleccionar el tipo de entidad de confianza**, seleccione **Servicio de AWS**. En **Choose a use case (Elija un caso de uso)**, seleccione **EC2** y **Next: Permissions (Siguiente: Permisos)**.

1. Busque y seleccione la política denominada **`AmazonEC2RoleforAWSCodeDeploy`**.

1. Busque y seleccione la política denominada **`AmazonSSMManagedInstanceCore`**. Elija **Siguiente: Etiquetas**.

1. Elija **Siguiente: Revisar**. Escriba el nombre del rol (por ejemplo, **EC2InstanceRole**).
**nota**  
Anote el nombre del rol para utilizarlo en el siguiente paso. Tendrá que elegir este rol cuando cree la instancia.

   Elija **Crear rol**.

**Para lanzar las instancias**

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

1. En la barra de navegación lateral, elija **Instancias** y seleccione **Lanzar instancias** en la parte superior de la página.

1. En **Nombre y etiquetas**, en **Nombre**, introduzca **MyCodePipelineDemo**. Esto asigna a las instancias una **clave** de etiqueta **Name** y un **valor** de etiqueta **MyCodePipelineDemo**. Más adelante, se crea una CodeDeploy aplicación que despliega la aplicación de ejemplo en las instancias. CodeDeployselecciona las instancias que se van a implementar en función de las etiquetas.

1. En **Imágenes de aplicaciones y sistema operativo (imagen de máquina de Amazon)**, elija **Windows**. (Esta AMI se describe como **Microsoft Windows Server 2019 Base** y tiene la etiqueta "Free tier eligible" (Apta para el nivel gratuito) y se encuentra en **Inicio rápido**).

1. En **Tipo de instancia**, elija el tipo `t2.micro` apto para la capa gratuita como configuración de hardware de la instancia.

1. En **Par de claves (inicio de sesión)**, seleccione un par de claves o cree uno. 

   Puede elegir **Continuar sin un par de claves**.
**nota**  
A efectos de este tutorial, puede continuar sin utilizar un par de claves. Si desea usar SSH para conectarse a sus instancias, cree o use un par de claves.

1. En **Configuración de red**, haga lo siguiente:

   En **Asignar automáticamente IP pública**, asegúrese de que el estado sea **Activar**.
   + Junto a **Assign a security group (Asignar un grupo de seguridad)**, elija **Create a new security group (Crear un nuevo grupo de seguridad)**.
   + En la fila de **SSH**, en **Tipo de origen**, elija **Mi IP**.
   + Elija **Añadir grupo de seguridad**, **HTTP** y en **Tipo de origen**, elija **Mi IP**.

1. Amplíe **Advanced details** (Detalles avanzados). En **Perfil de instancia de IAM**, elija el rol de IAM que creó en el procedimiento anterior (por ejemplo, **EC2InstanceRole**).

1. En **Resumen**, en **Número de instancias**, introduzca `2`.

1. Seleccione **Iniciar instancia**.

1. Elija **Ver todas las instancias** para cerrar la página de confirmación y volver a la consola.

1. Puede ver el estado del lanzamiento en la página **Instances**. Al lanzar una instancia, su estado inicial es `pending`. Una vez iniciada la instancia, el estado cambia a `running` y recibe un nombre de DNS público. (Si la columna **Public DNS** no se muestra, haga clic en el icono **Show/Hide** y después seleccione **Public DNS**.)

1. Puede que transcurran unos minutos hasta que la instancia esté lista para conectarse. Verifique que su instancia ha pasado las comprobaciones de estado. Puede ver esta información en la columna **Status Checks (Comprobaciones de estado)**.

## Paso 3: Crea una aplicación en CodeDeploy
<a name="S3-create-deployment"></a>

En CodeDeploy, una *aplicación* es un identificador, en forma de nombre, del código que se quiere implementar. CodeDeploy usa este nombre para garantizar que se haga referencia a la combinación correcta de revisión, configuración de implementación y grupo de implementación durante una implementación. Seleccione el nombre de la CodeDeploy aplicación que cree en este paso cuando cree la canalización más adelante en este tutorial.

Primero debe crear un rol de servicio CodeDeploy para usarlo. Si ya ha creado un rol de servicio, no necesita crear otro.

**Para crear un rol CodeDeploy de servicio**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

1. En el panel de la consola, elija **Roles**.

1. Elija **Crear rol**.

1. En **Seleccionar entidad de confianza**, elija **Servicio de AWS**. En **Use case** (Caso de uso), elija **CodeDeploy**. Elija una **CodeDeploy**de las opciones de la lista. Elija **Siguiente**. La política administrada `AWSCodeDeployRole` ya está asociada al rol.

1. Elija **Siguiente**.

1. Especifique un nombre para el rol (por ejemplo, **CodeDeployRole**) y elija **Create role (Crear rol)**.

**Para crear una aplicación en CodeDeploy**

1. Abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).

1. **Si la página **Aplicaciones** no aparece, en el AWS CodeDeploy menú, seleccione Aplicaciones.**

1. Elija **Creación de aplicación**.

1. En **Application name (Nombre de aplicación)**, escriba `MyDemoApplication`. 

1. En **Plataforma de informática**, elija **EC2/On-Premises**.

1. Elija **Creación de aplicación**.

**Para crear un grupo de despliegue en CodeDeploy**

1. En la página que muestra su aplicación, elija **Create deployment group (Crear grupo de implementaciones)**.

1. En **Nombre de grupo de implementación**, escriba **MyDemoDeploymentGroup**.

1. En **Rol de servicio**, elija el rol de servicio de que creó anteriormente. Debe usar un rol de servicio que confíe, como mínimo, AWS CodeDeploy con la confianza y los permisos descritos en [Crear un rol de servicio para CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-create-service-role.html). Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (consola)](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#getting-started-get-service-role-console).

1. En **Deployment type (Tipo de implementación)**, elija **In-place (In situ)**.

1. En **Environment configuration (Configuración de entorno)**, elija **Amazon EC2 Instances (Instancias de Amazon EC2)**. Elija **Name (Nombre)** en el campo **Key (Clave)** y, en el campo **Value (Valor)**, escriba **MyCodePipelineDemo**. 
**importante**  
En la clave **Nombre**, debe elegir el mismo valor que asignó a la instancia EC2 cuando la creó. Si etiquetó la instancia con un término distinto de **MyCodePipelineDemo**, asegúrese de usarlo aquí.

1. En **Configuración del agente con AWS Systems Manager**, seleccione **Ahora y programe las actualizaciones**. Primero, instale el agente en la instancia. La instancia de Windows ya está configurada con el agente SSM y ahora se actualizará con el CodeDeploy agente.

1. En **Configuración de implementación**, elija `CodeDeployDefault.OneAtaTime`.

1. En **Equilibrador de carga**, asegúrese de que no esté seleccionado el cuadro **Habilitar equilibrio de carga**. No es necesario configurar un balanceador de carga ni elegir un grupo de destino para este ejemplo. Tras anular la selección de la casilla de verificación, no se muestran las opciones del equilibrador de carga.

1. En la sección **Avanzado**, deje los valores predeterminados.

1. Elija **Crear grupo de implementación**.

## Paso 4: Crea tu primera canalización en CodePipeline
<a name="s3-create-pipeline"></a>

En esta parte del tutorial se crea la canalización. El ejemplo se ejecuta automáticamente en la canalización.

**Para crear un proceso de publicación CodePipeline automatizado**

1. Inicie sesión Consola de administración de AWS y abra la CodePipeline consola en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyFirstPipeline**. 
**nota**  
Si elige otro nombre para la canalización, utilícelo en lugar de **MyFirstPipeline** durante el resto de este tutorial. Después de crear una canalización, no podrá cambiar el nombre. Los nombres de canalizaciones están sujetos a algunas limitaciones. Para obtener más información, consulte [Cuotas en AWS CodePipeline](limits.md). 

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Service role (Rol de servicio)**, realice una de las operaciones siguientes:
   + Elija **Nueva función de servicio** para CodePipeline poder crear una nueva función de servicio en IAM.
   + Elija **Existing service role (Rol de servicio existente)** para utilizar un rol de servicio que ya se ha creado en IAM. En **Role name (Nombre del rol)**, elija el nombre del rol de servicio en la lista.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **Amazon S3**. En **Bucket**, escriba el nombre del bucket de S3·que creó en [Paso 1: creación de un bucket de origen de S3 para la aplicación](#s3-create-s3-bucket). En la **clave del objeto de S3**, escriba la clave del objeto con o sin una ruta de archivo y recuerde incluir la extensión de archivo. Por ejemplo, en `SampleApp_Windows.zip`, escriba el nombre del archivo de ejemplo tal y como aparece en este ejemplo:

   ```
   SampleApp_Windows.zip
   ```

   Elija **Next Step** (Paso siguiente).

   En **Change detection options**, deje los valores predeterminados. Esto permite CodePipeline usar Amazon CloudWatch Events para detectar cambios en el bucket de origen.

    Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la fase de despliegue**, en **Proveedor de despliegue**, seleccione **CodeDeploy **. El campo **Región** tiene el mismo valor predeterminado Región de AWS que tu canalización. En **Application name (Nombre de la aplicación)**, escriba `MyDemoApplication` o haga clic en el botón **Refresh (Actualizar)** y, a continuación, elija el nombre de la aplicación en la lista. En **Deployment group (Grupo de implementación)**, escriba **MyDemoDeploymentGroup** o elija un grupo de la lista. A continuación, elija **Next (Siguiente)**. 
**nota**  
El nombre "Deploy" (Implementación) es el que se asigna de forma predeterminada a la etapa creada en **Step 4: Add deploy stage (Paso 4: Agregar la etapa de implementación)**, mientras que "Source" (Código fuente) es el nombre que recibe la primera etapa de la canalización. 

1. En el **paso 7: Revisar**, revisa la información y, a continuación, selecciona **Crear canalización**.

1. La canalización comienza a ejecutarse. Puede ver los mensajes de progreso y de éxito y fracaso a medida que en el CodePipeline ejemplo se despliega una página web en CodeDeploy cada una de las instancias de Amazon EC2 de la implementación.

¡Enhorabuena\$1 Acaba de crear una canalización sencilla en. CodePipeline La canalización tiene dos etapas:
+ Una etapa denominada **Source (Código fuente)**, que detecta los cambios en la aplicación de ejemplo con control de versiones almacenada en el bucket de S3 y los transfiere a la canalización.
+ Una etapa **Deploy (Implementación)** que implementa dichos cambios en las instancias EC2 con CodeDeploy. 

Ahora compruebe los resultados.

**Para comprobar que la canalización se ha ejecutado correctamente**

1. Vea el progreso inicial de la canalización. El estado de cada etapa cambia de **No executions yet** (Sin ejecuciones) a **In Progress** (En curso) y después a **Succeeded** (Realizado correctamente) o **Failed** (Error). La canalización debería completar la primera ejecución en unos minutos.

1. Cuando el estado de la acción aparezca como **Realizado correctamente**, en el área de estado de la etapa **Implementar**, elija **Detalles**. Esto abre la CodeDeploy consola.

1. En la pestaña **Grupo de implementaciones** de la sección **Eventos del ciclo de vida de la implementación**, elija el ID de la instancia. Se abrirá la consola de EC2.

1. En la pestaña **Description (Descripción)**, en **Public DNS (DNS público)**, copie la dirección y después péguela en la barra de direcciones de su explorador web. Vea la página de índice de la aplicación de ejemplo que cargó en el bucket de S3.

   La página web muestra la aplicación de ejemplo que cargó en el bucket de S3.

Para obtener más información sobre las etapas, las acciones y cómo funcionan las canalizaciones, consulte [CodePipeline conceptos ](concepts.md).

## (Opcional) Paso 5: Agregar otra etapa a la canalización
<a name="s3-add-stage"></a>

Ahora agregaremos otra etapa a la canalización para implementar desde los servidores de ensayo a los servidores de producción utilizando CodeDeploy. En primer lugar, debe crear otro grupo de despliegue CodePipelineDemoApplication en CodeDeploy. A continuación tiene que añadir una etapa con una acción que utilice ese grupo de implementaciones. Para añadir otra etapa, utilice la CodePipeline consola o la AWS CLI para recuperar y editar manualmente la estructura de la canalización en un archivo JSON y, a continuación, ejecute el **update-pipeline** comando para actualizar la canalización con los cambios.

**Topics**
+ [

### Cree un segundo grupo de despliegues en CodeDeploy
](#s3-add-stage-part-1)
+ [

### Agregar el grupo de implementación como otra etapa de la canalización
](#s3-add-stage-part-2)

### Cree un segundo grupo de despliegues en CodeDeploy
<a name="s3-add-stage-part-1"></a>

**nota**  
En esta parte del tutorial, va a crear un segundo grupo de implementaciones, pero la implementación se hará en las mismas instancias de Amazon EC2 usadas anteriormente. Esto solo se hace con fines ilustrativos. Está diseñado a propósito para no mostrarle cómo se muestran los errores. CodePipeline

**Para crear un segundo grupo de despliegue en CodeDeploy**

1. Abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).

1. Elija **Applications (Aplicaciones)** y, en la lista de aplicaciones, elija `MyDemoApplication`.

1. Elija la pestaña **Deployment groups (Grupos de implementaciones)** y , a continuación, **Create deployment group (Crear grupo de implementaciones)**.

1. En la página **Create deployment group (Crear grupo de implementaciones)**, en **Deployment group name (Nombre de grupo de implementaciones)**, escriba un nombre para el segundo grupo de implementaciones, como **CodePipelineProductionFleet**.

1. En **Función de servicio**, elija la misma función CodeDeploy de servicio que utilizó para la implementación inicial (no la función de CodePipeline servicio).

1. En **Deployment type (Tipo de implementación)**, elija **In-place (In situ)**.

1. En **Environment configuration (Configuración de entorno)**, elija **Amazon EC2 Instances (Instancias de Amazon EC2)**. Elija **Nombre** en el cuadro **Clave** y, en el cuadro **Valor**, seleccione `MyCodePipelineDemo` en la lista. Mantenga la configuración predeterminada de **Deployment settings (Ajustes de implementación)**. 

1. En **Deployment configuration (Configuración de implementación)**, elija `CodeDeployDefault.OneAtaTime`.

1. En **Load Balancer (Balanceador de carga)**, anule la selección de **Enable load balancing (Habilitar balanceo de carga)**.

1.  Elija **Crear grupo de implementación**.

### Agregar el grupo de implementación como otra etapa de la canalización
<a name="s3-add-stage-part-2"></a>

Ahora que tiene otro grupo de implementación, puede agregar una etapa que lo utilice para realizar la implementación en las mismas instancias EC2 que usamos antes. Puede usar la CodePipeline consola o la AWS CLI para agregar esta etapa. 

**Topics**
+ [

#### Crear una tercera etapa (consola)
](#s3-add-stage-part-2-console)
+ [

#### Crear una tercera etapa (CLI)
](#s3-add-stage-part-2-cli)

#### Crear una tercera etapa (consola)
<a name="s3-add-stage-part-2-console"></a>

Puede utilizar la CodePipeline consola para añadir una nueva etapa que utilice el nuevo grupo de despliegue. Como este grupo de implementación utiliza las instancias EC2 que ya habíamos empleado, la acción de implementación en esta etapa produce un error. 

1. Inicie sesión Consola de administración de AWS y abra la CodePipeline consola en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En **Name (Nombre)**, elija el nombre de la canalización que ha creado, MyFirstPipeline. 

1. En la página de detalles de la canalización, elija **Edit**. 

1. En la página **Edit (Editar)**, elija **\$1 Add stage (Añadir etapa)** para añadir una etapa inmediatamente después de la etapa Deploy (Implementar).   
![\[Imagen que muestra el botón + Agregar etapa en la pantalla de edición\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)

1. En **Add stage (Añadir etapa)**, in **Stage name (Nombre de etapa)**, escriba **Production**. Elija **Add stage (Añadir etapa)**.

1. En la nueva etapa, elija **\$1Add action group (\$1Añadir grupo de acciones)**.

1. En **Edit action (Editar acción)**, en **Action name (Nombre de acción)**, escriba **Deploy-Second-Deployment**. En **Action provider**, en **Deploy**, elija **CodeDeploy**.

1. En la CodeDeploy sección, en **Nombre de la aplicación**, elige una opción `MyDemoApplication` de la lista desplegable, tal y como hiciste cuando creaste la canalización. En **Deployment group (Grupo de implementación)**, elija el grupo de implementaciones que acaba de crear, **CodePipelineProductionFleet**. En **Input artifacts (Artefactos de entrada)**, elija el artefacto de entrada de la acción de origen. Seleccione **Save**.

1. En la página **Edit (Editar)**, elija **Save (Guardar)**. En **Save pipeline changes (Guardar los cambios de la canalización)**, elija **Save (Guardar)**.

1. Aunque se ha añadido la nueva etapa a la canalización, aparece el estado **No executions yet (Sin ejecuciones)** porque no se han producido cambios que activen otra ejecución de la canalización. Tiene que volver a ejecutar manualmente la última revisión para ver cómo se ejecuta la canalización editada. En la página de detalles de canalización, elija **Liberar cambio** y, a continuación, elija **Liberar** cuando se le solicite. Esto ejecuta la revisión más reciente disponible en cada ubicación de código fuente especificada en una acción de código fuente a través de la canalización. 

   Como alternativa, para volver AWS CLI a ejecutar la canalización, desde una terminal de tu máquina Linux, macOS o Unix local, o desde una línea de comandos de tu máquina Windows local, ejecuta el **start-pipeline-execution** comando especificando el nombre de la canalización. De este modo se ejecuta por segunda vez la aplicación del bucket de código fuente en la canalización.

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   Este comando devuelve un objeto `pipelineExecutionId`.

1. Vuelve a la CodePipeline consola y, en la lista de canalizaciones, selecciona **MyFirstPipeline**abrir la página de visualización.

   La canalización muestra tres etapas y el estado del artefacto en ejecución a lo largo de esas tres etapas. Pueden que transcurran cinco minutos hasta que el proceso de canalización se ejecute en todas las etapas. Verá las implementaciones en las primeras dos etapas, tal como antes, pero la etapa **Production (Producción)** mostrará que la acción **Deploy-Second-Deployment** no se ha realizado correctamente.

1. En la acción **Deploy-Second-Deployment**, elija **Details**. Se le redirigirá a la página de la implementación CodeDeploy. En este caso, el error se ha producido porque el primer grupo de instancias se ha implementado en todas las instancias EC2 y no han quedado instancias para el segundo grupo de implementación.
**nota**  
Se trata de un error de diseño, para mostrar lo que ocurre cuando se produce un error en una etapa de la canalización.

#### Crear una tercera etapa (CLI)
<a name="s3-add-stage-part-2-cli"></a>

Aunque utilizar la AWS CLI para añadir una fase a la canalización es más complejo que utilizar la consola, proporciona una mayor visibilidad de la estructura de la canalización.

**Para crear una tercera etapa en la canalización**

1. Abra una sesión de terminal en su máquina Linux, macOS o Unix local o a través del símbolo del sistema en su equipo Windows local y ejecute el comando para mostrar la estructura de la canalización que acaba de crear. Para **MyFirstPipeline**, debería escribir el siguiente comando: 

   ```
   aws codepipeline get-pipeline --name "MyFirstPipeline"
   ```

   Este comando devuelve la estructura de MyFirstPipeline. La primera parte del resultado debería tener un aspecto similar al siguiente:

   ```
   {
       "pipeline": {
           "roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service",
           "stages": [
       ...
   ```

   La última parte de la salida incluye los metadatos de la canalización y debería tener un aspecto similar al siguiente:

   ```
       ...
           ],
           "artifactStore": {
               "type": "S3"
               "location": "amzn-s3-demo-bucket",
           },
           "name": "MyFirstPipeline",
           "version": 4
       },
       "metadata": {
           "pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline",
           "updated": 1501626591.112,
           "created": 1501626591.112
       }
   }
   ```

1. Copie y pegue esta estructura en un editor de texto sin formato y guarde el archivo como **pipeline.json**. Para su comodidad, guarde este archivo en el mismo directorio en el que ejecuta los comandos **aws codepipeline**.
**nota**  
Puede enviar JSON directamente a un archivo con el comando **get-pipeline** del modo siguiente:  

   ```
   aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
   ```

1. Copie la sección de la etapa **Implementar** y péguela después de las primeras dos etapas. Al ser una etapa de implementación, al igual que la etapa **Implementar**, la utilizará como plantilla de la tercera etapa. 

1. Cambie el nombre de la etapa y los detalles del grupo de implementación. 

   En el siguiente ejemplo, se muestra el archivo JSON que se va a agregar al archivo pipeline.json después de la etapa **Implementar**. Edite los elementos resaltados con valores nuevos. No olvide incluir una coma para separar las definiciones de las etapas **Implementar** y **Producción**.

   ```
   ,
   {
       "name": "Production",
        "actions": [
           {
            "inputArtifacts": [
                {
                 "name": "MyApp"
                }
              ],
             "name": "Deploy-Second-Deployment",
             "actionTypeId": {
                 "category": "Deploy",
                 "owner": "AWS",
                 "version": "1",
                 "provider": "CodeDeploy"
                 },
            "outputArtifacts": [],
            "configuration": {
                 "ApplicationName": "CodePipelineDemoApplication",
                 "DeploymentGroupName": "CodePipelineProductionFleet"
                  },
            "runOrder": 1
           }
       ]
   }
   ```

1. Si está trabajando con la estructura de la canalización recuperada mediante el comando **get-pipeline**, debe eliminar las líneas `metadata` del archivo JSON. De lo contrario, el comando **update-pipeline** no puede utilizarlo. Elimine las líneas `"metadata": { }` y los campos `"updated"`, `"created"` y `"pipelineARN"`.

   Por ejemplo, quite las siguientes líneas de la estructura:

   ```
   "metadata": {  
     "pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
     "created": "date",
     "updated": "date"
     }
   ```

   Guarde el archivo.

1. Ejecute el comando **update-pipeline**, especificando el archivo JSON de la canalización, de forma similar a como se muestra a continuación:

   ```
   aws codepipeline update-pipeline --cli-input-json file://pipeline.json
   ```

   Este comando devuelve la estructura completa de la canalización actualizada.
**importante**  
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.

1.  Ejecute el comando **start-pipeline-execution** y especifique el nombre de la canalización. De este modo se ejecuta por segunda vez la aplicación del bucket de código fuente en la canalización.

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   Este comando devuelve un objeto `pipelineExecutionId`.

1. Abra la CodePipeline consola y elija una opción **MyFirstPipeline**de la lista de canalizaciones.

   La canalización muestra tres etapas y el estado del artefacto en ejecución a lo largo de esas tres etapas. Pueden que transcurran cinco minutos hasta que el proceso de canalización se ejecute en todas las etapas. Aunque la implementación se realiza correctamente en las primeras dos etapas, tal como antes, la etapa **Production** muestra que se ha producido un error en la acción de **Deploy-Second-Deployment**. 

1. En la acción **Deploy-Second-Deployment**, elija **Details** para ver los detalles del error. Se le redirigirá a la página de detalles de la CodeDeploy implementación. En este caso, el error se ha producido porque el primer grupo de instancias se ha implementado en todas las instancias EC2 y no han quedado instancias para el segundo grupo de implementación. 
**nota**  
Se trata de un error de diseño, para mostrar lo que ocurre cuando se produce un error en una etapa de la canalización.

## (Opcional) Paso 6: deshabilitar y habilitar las transiciones entre etapas en CodePipeline
<a name="s3-configure-transitions"></a>

La transición entre las etapas de una canalización puede habilitarse y deshabilitarse. Deshabilitar una transición entre etapas permite controlar manualmente las transiciones entre una etapa y otra. Por ejemplo, puede ser conveniente ejecutar las dos primeras etapas de una canalización, pero deshabilitar las transiciones a la tercera hasta que esté listo para implementar en la producción, o mientras investiga un problema o un error en esa etapa.

**Para deshabilitar y habilitar las transiciones entre las etapas de una CodePipeline canalización**

1. Abre la CodePipeline consola y elige una opción **MyFirstPipeline**de la lista de canalizaciones.

1. En la página de detalles de la canalización, elija el botón **Deshabilitar la transición** situado entre la segunda etapa, **Implementar** y la tercera etapa que agregó en la sección anterior (**Producción**).

1. En el cuadro de diálogo **Disable transition (Deshabilitar transición)**, escriba un motivo para deshabilitar la transición entre las etapas y después elija **Disable (Deshabilitar)**.

   La flecha entre etapas muestra un icono y cambia de color, y aparece el botón **Enable transition (Habilitar transición)**.  
![\[Imagen que muestra el motivo introducido para deshabilitar la transición como “Deshabilitar la transición mientras soluciono el error”\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)

1. Cargue nuevamente la muestra en el bucket de S3. Como el bucket tiene varias versiones, este cambio inicia la canalización. 

1. Vuelva a la página de detalles de la canalización y observe el estado de las etapas. La vista de canalización cambia para mostrar el progreso y el éxito de las primeras dos etapas, pero no se realizan cambios en la tercera etapa. Este proceso puede tardar unos minutos.

1. Habilite la transición eligiendo el botón **Enable transition (Habilitar transición)** entre las dos etapas. En el cuadro de diálogo **Enable transition**, elija **Enable**. La etapa comienza a ejecutarse en unos minutos e intenta procesar el artefacto que ya se ha ejecutado en las dos primeras etapas de la canalización.
**nota**  
Si desea que esta tercera etapa se lleve a cabo correctamente, edite el grupo de CodePipelineProductionFleet despliegues antes de habilitar la transición y especifique un conjunto diferente de instancias de EC2 en las que se despliegue la aplicación. Para obtener más información acerca de cómo hacerlo, consulte [Cambio en la configuración de un grupo de implementaciones](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html). Si crea más instancias EC2, se podrían generar costos adicionales. 

## Paso 7: Limpiar recursos
<a name="s3-clean-up"></a>

Puede reutilizar algunos de los recursos que ha creado aquí en [Tutorial: Crear una canalización de cuatro etapas](tutorials-four-stage-pipeline.md). Por ejemplo, puede reutilizar la CodeDeploy aplicación y el despliegue. Puede configurar una acción de compilación con un proveedor, por ejemplo CodeBuild, un servicio de compilación totalmente gestionado en la nube. También puede configurar una acción de compilación que utilice un proveedor con un servidor o un sistema de compilación, como Jenkins.

Sin embargo, una vez completado este o cualquier otro tutorial, debe eliminar la canalización y los recursos que utiliza para que no se le cobre por el uso continuado de esos recursos. En primer lugar, elimine la canalización, después la CodeDeploy aplicación y sus instancias de Amazon EC2 asociadas y, por último, el bucket de S3.

**Para limpiar los recursos usados en este tutorial**

1. Para limpiar sus CodePipeline recursos, siga las instrucciones de [Eliminar una canalización en AWS CodePipeline](pipelines-delete.md).

1. Para limpiar CodeDeploy los recursos, sigue las instrucciones de [Para limpiar los recursos (consola)](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console).

1. Para eliminar el bucket de S3, siga las instrucciones que se especifican en [Eliminar o vaciar un bucket de S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html). Si no tiene intención de crear más canalizaciones, elimine el bucket de S3 creado para almacenar los artefactos de la canalización. Para obtener más información acerca de este bucket, consulte [CodePipeline conceptos ](concepts.md).

# Tutorial: Crear una canalización sencilla (CodeCommit repositorio)
<a name="tutorials-simple-codecommit"></a>

En este tutorial, se utiliza CodePipeline para implementar el código mantenido en un CodeCommit repositorio en una única instancia de Amazon EC2. Su canalización se activa cuando introduce un cambio en el CodeCommit repositorio. La canalización implementa los cambios en una instancia de Amazon EC2 como servicio CodeDeploy de implementación.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente para fabricar artefactos. CodePipeline (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

La canalización tiene dos etapas:
+ Una etapa de origen (**Source**) para la acción de origen. CodeCommit 
+ Una etapa de despliegue (**Despliegue**) para la acción CodeDeploy de despliegue.

La forma más sencilla de empezar AWS CodePipeline es utilizar el asistente **Create Pipeline** de la CodePipeline consola.

**nota**  
Antes de empezar, asegúrate de haber configurado tu cliente Git para que funcione con él CodeCommit. Para obtener instrucciones, consulte [Configuración para CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html).

## Paso 1: Crea un CodeCommit repositorio
<a name="codecommit-create-repository"></a>

En primer lugar, se crea un repositorio en CodeCommit. Su canalización obtendrá el código fuente de este repositorio cuando se ejecute. También se crea un repositorio local en el que se mantiene y actualiza el código antes de enviarlo al CodeCommit repositorio.

**Para crear un CodeCommit repositorio**



1. Abra la CodeCommit consola en [https://console.aws.amazon.com/codecommit/](https://console.aws.amazon.com/codecommit/).

1. En el selector de regiones, elige Región de AWS dónde quieres crear el repositorio y la canalización. Para obtener más información, consulte [Puntos de conexión y Regiones de AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html).

1. En la página **Repositorios**, seleccione **Crear repositorio**.

1. En la página **Create repository (Crear repositorio)**, en **Repository name (Nombre del repositorio)**, escriba un nombre para el repositorio (por ejemplo, **MyDemoRepo**).

1. Seleccione **Crear**.

**nota**  
Los pasos restantes de este tutorial se utilizan **MyDemoRepo** para el nombre del CodeCommit repositorio. Si elige otro nombre, asegúrese de utilizarlo durante todo el tutorial.

**Para configurar un repositorio local**

En este paso, configurará un repositorio local para conectarse a su repositorio remoto de CodeCommit.
**nota**  
No es necesario configurar un repositorio local. También puede usar la consola para cargar archivos, tal y como se describe en [Paso 2: Agrega un código de muestra a tu CodeCommit repositorio](#codecommit-add-code).

1. Con el nuevo repositorio abierto en la consola, elija **Clone URL (Clonar URL)** en la parte superior derecha de la página y, a continuación, elija **Clone SSH (Clonar SSH)**. La dirección para clonar el repositorio Git se copia en el portapapeles.

1. En el terminal o en la línea de comandos, acceda a un directorio local en el que desea que se almacene el repositorio local. En este tutorial, utilizamos `/tmp`.

1. Ejecute el siguiente comando para clonar el repositorio, sustituyendo la dirección SSH por la que ha copiado en el paso anterior. Este comando crea un directorio denominado `MyDemoRepo`. Copie una aplicación de ejemplo en este directorio.

   ```
   git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
   ```

## Paso 2: Agrega un código de muestra a tu CodeCommit repositorio
<a name="codecommit-add-code"></a>

En este paso, descarga el código de una aplicación de muestra que se creó para un tutorial de CodeDeploy ejemplo y lo añadirá a su CodeCommit repositorio.



1. A continuación, descargue un ejemplo y guárdelo en una carpeta o directorio del equipo local.

   1. Elija una de las siguientes opciones. Elija `SampleApp_Linux.zip` si desea seguir los pasos de este tutorial en instancias de Linux.
      + Si desea realizar la implementación en instancias de Amazon Linux mediante CodeDeploy, descargue la aplicación de muestra aquí: [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip).
      + Si desea realizar la implementación en instancias de Windows Server mediante CodeDeploy, descargue la aplicación de muestra aquí: [SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip).

      La aplicación de ejemplo contiene los siguientes archivos para realizar la implementación con CodeDeploy: 
      + `appspec.yml`— El archivo de especificaciones de la aplicación (AppSpecarchivo) es un archivo con formato [YAML](http://www.yaml.org) que se utiliza CodeDeploy para gestionar una implementación. *Para obtener más información sobre el AppSpec archivo, consulte la [referencia al CodeDeploy AppSpec archivo](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) en la Guía del AWS CodeDeploy usuario.*
      + `index.html`: el archivo de índice contiene la página de inicio de la aplicación de ejemplo implementada.
      + `LICENSE.txt`: el archivo de licencia contiene la información de licencia de la aplicación de ejemplo.
      + Archivos para scripts: la aplicación de ejemplo usa scripts para escribir archivos de texto en una ubicación de la instancia. Se escribe un archivo para cada uno de los diversos eventos del ciclo de vida de la CodeDeploy implementación, de la siguiente manera:
        + (Solo ejemplos de Linux) Carpeta `scripts`: la carpeta contiene los siguientes scripts de intérprete de comandos para instalar las dependencias e iniciar y detener la aplicación de ejemplo para la implementación automatizada: `install_dependencies`, `start_server` y `stop_server`.
        + (Solo ejemplo de Windows) `before-install.bat`: se trata de un script por lotes para el evento de ciclo de vida de implementación, que se ejecutará para eliminar los archivos antiguos escritos durante implementaciones anteriores de este ejemplo y crear una ubicación en su instancia en la que escribir los archivos nuevos.

   1. Descargue el archivo comprimido (en zip).

1. Descomprima los archivos de [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) en el directorio local que creó anteriormente (por ejemplo, `/tmp/MyDemoRepo` o`c:\temp\MyDemoRepo`).

   Asegúrese de colocar los archivos directamente en su repositorio local. No incluya una carpeta `SampleApp_Linux`. En la máquina Linux, macOS o Unix local, por ejemplo, su directorio y la jerarquía de archivos deberían verse así:

   ```
   /tmp
      └-- MyDemoRepo
          │-- appspec.yml
          │-- index.html
          │-- LICENSE.txt
          └-- scripts
              │-- install_dependencies
              │-- start_server
              └-- stop_server
   ```

1. Para cargar archivos en el repositorio, utilice alguno de los métodos siguientes.

   1. Para usar la CodeCommit consola para cargar los archivos: 

      1. Abre la CodeCommit consola y elige tu repositorio en la lista de **repositorios**.

      1. Elija **Add file (Añadir archivo)** y, a continuación, **Upload file (Cargar archivo)**. 

      1. Seleccione **Choose file (Elegir archivo)** y, a continuación, busque el archivo. Para añadir un archivo a una carpeta, seleccione **Crear archivo** y, a continuación, introduce el nombre de la carpeta con el nombre del archivo, por ejemplo `scripts/install_dependencies`. Pegue los siguientes contenidos en el nuevo archivo.

         Para confirmar el cambio, introduzca su nombre de usuario y la dirección de correo electrónico. 

         Seleccione **Confirmar cambios**.

      1. Repita este paso para cada archivo.

         El contenido del repositorio debería ser similar al siguiente:

         ```
                │-- appspec.yml
                │-- index.html
                │-- LICENSE.txt
                └-- scripts
                    │-- install_dependencies
                    │-- start_server
                    └-- stop_server
         ```

   1. Para usar los comandos de git para cargar sus archivos: 

      1. Cambiar los directorios a su repositorio local:

         ```
         (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
         (For Windows) cd c:\temp\MyDemoRepo
         ```

      1. Ejecute el siguiente comando para preparar todos los archivos de una vez:

         ```
         git add -A
         ```

      1. Ejecute el siguiente comando para confirmar los archivos con un mensaje de confirmación:

         ```
         git commit -m "Add sample application files"
         ```

      1. Ejecute el siguiente comando para enviar los archivos de su repositorio local al repositorio de CodeCommit:

         ```
         git push
         ```

1. Los archivos que descargaste y agregaste a tu repositorio local ya se han agregado a la `main` rama de tu CodeCommit `MyDemoRepo` repositorio y están listos para ser incluidos en una canalización.

## Paso 3: Crear una instancia Linux Amazon EC2 e instalar el agente CodeDeploy
<a name="codecommit-create-deployment"></a>

En este paso, va a crear una instancia de Amazon EC2 en la que va a implementar una aplicación de ejemplo. Como parte de este proceso, cree un rol de instancia que permita instalar y administrar el CodeDeploy agente en la instancia. El CodeDeploy agente es un paquete de software que permite utilizar una instancia en CodeDeploy las implementaciones. También debe adjuntar políticas que permiten a la instancia recuperar los archivos que el CodeDeploy agente utiliza para implementar la aplicación y permitir que SSM administre la instancia.

**Para crear un rol de instancia**

1. Abra la consola de IAM en). [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. En el panel de la consola, elija **Roles**.

1. Elija **Crear rol**.

1. En **Seleccionar el tipo de entidad de confianza**, seleccione **Servicio de AWS**. En **Elegir un caso de uso**, seleccione **EC2**. En **Select your use case (Seleccionar su caso de uso)**, elija **EC2**. Elija **Siguiente: permisos**.

1. Busque y seleccione la política denominada **`AmazonEC2RoleforAWSCodeDeploy`**. 

1. Busque y seleccione la política denominada **`AmazonSSMManagedInstanceCore`**. Elija **Siguiente: Etiquetas**.

1. Elija **Siguiente: Revisar**. Escriba el nombre del rol (por ejemplo, **EC2InstanceRole**).
**nota**  
Anote el nombre del rol para utilizarlo en el siguiente paso. Tendrá que elegir este rol cuando cree la instancia.

   Elija **Crear rol**.

**Lanzamiento de una instancia de**

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

1. En la barra de navegación lateral, elija **Instancias** y seleccione **Lanzar instancias** en la parte superior de la página.

1. En **Name (Nombre)**, escriba **MyCodePipelineDemo**. Esto asigna a la instancia una **clave** de etiqueta **Name** y un **valor** de etiqueta **MyCodePipelineDemo**. Más adelante, se crea una CodeDeploy aplicación que despliega la aplicación de ejemplo en esta instancia. CodeDeployselecciona las instancias que se van a implementar en función de las etiquetas.

1. En **Imágenes de aplicaciones y sistemas operativos (Amazon Machine Image)**, busque la opción AMI de **Amazon Linux** con el AWS logotipo y asegúrese de que esté seleccionada. (Esta AMI se describe como AMI de Amazon Linux 2 (HVM) y se denomina "Free tier eligible" (Apta para capa gratuita).)

1. En **Tipo de instancia**, elija el tipo `t2.micro` apto para la capa gratuita como configuración de hardware de la instancia.

1. En **Par de claves (inicio de sesión)**, seleccione un par de claves o cree uno. 

   Puede elegir **Continuar sin un par de claves**.
**nota**  
A efectos de este tutorial, puede continuar sin utilizar un par de claves. Si desea usar SSH para conectarse a sus instancias, cree o use un par de claves.

1. En **Configuración de red**, haga lo siguiente:

   En **Asignar automáticamente IP pública**, asegúrese de que el estado sea **Activar**.

   Para el grupo de seguridad creado, elija **HTTP** y, a continuación, en **Tipo de origen**, elija **Mi IP**.

1. Amplíe **Advanced details** (Detalles avanzados). En **Perfil de instancia de IAM**, elija el rol de IAM que creó en el procedimiento anterior (por ejemplo, **EC2InstanceRole**).

1. En **Resumen**, en **Número de instancias**, introduzca `1`.

1. Seleccione **Iniciar instancia**. 

1. Puede ver el estado del lanzamiento en la página **Instances**. Al lanzar una instancia, su estado inicial es `pending`. Una vez iniciada la instancia, el estado cambia a `running` y recibe un nombre de DNS público. (Si la columna **Public DNS** no se muestra, haga clic en el icono **Show/Hide** y después seleccione **Public DNS**.)

## Paso 4: Cree una aplicación en CodeDeploy
<a name="codecommit-create-codedeploy-app"></a>

En CodeDeploy, una [https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) es un recurso que contiene la aplicación de software que desea implementar. Más adelante, utilizará esta aplicación CodePipeline para automatizar las implementaciones de la aplicación de muestra en su instancia de Amazon EC2.

En primer lugar, debe crear un rol que permita CodeDeploy realizar las implementaciones. A continuación, debe crear una aplicación de CodeDeploy .

**Para crear un rol de CodeDeploy servicio**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

1. En el panel de la consola, elija **Roles**.

1. Elija **Crear rol**.

1. En **Seleccionar entidad de confianza**, elija **Servicio de AWS**. En **Use case** (Caso de uso), elija **CodeDeploy**. Elija una **CodeDeploy**de las opciones que aparecen en la lista. Elija **Siguiente**. La política administrada `AWSCodeDeployRole` ya está asociada al rol.

1. Elija **Siguiente**.

1. Especifique un nombre para el rol (por ejemplo, **CodeDeployRole**) y elija **Create role (Crear rol)**.

**Para crear una aplicación en CodeDeploy**

1. Abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)

1. Si la página **Aplicaciones** no aparece, en el menú, elija **Aplicaciones**.

1. Elija **Creación de aplicación**.

1. En **Application name (Nombre de aplicación)**, escriba **MyDemoApplication**. 

1. En **Plataforma de informática**, elija **EC2/On-Premises**.

1. Elija **Creación de aplicación**.

**Para crear un grupo de despliegue en CodeDeploy**

Un [https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) es un recurso que define la configuración relacionada con la implementación, como las instancias que implementar y con qué rapidez implementarlas.

1. En la página que muestra su aplicación, elija **Create deployment group (Crear grupo de implementaciones)**.

1. En **Nombre de grupo de implementación**, escriba **MyDemoDeploymentGroup**.

1. En **Rol de servicio**, elija el ARN del rol de servicio que creó anteriormente (por ejemplo, **`arn:aws:iam::account_ID:role/CodeDeployRole`**).

1. En **Deployment type (Tipo de implementación)**, elija **In-place (In situ)**.

1. En **Environment configuration (Configuración de entorno)**, elija **Amazon EC2 Instances (Instancias de Amazon EC2)**. En el campo **Clave**, introduzca **Name**. En el campo **Valor**, escriba el nombre que utilizó para etiquetar la instancia (por ejemplo, **MyCodePipelineDemo**).

1. En **Configuración del agente con AWS Systems Manager**, seleccione **Ahora y programe las actualizaciones**. Primero, instale el agente en la instancia. La instancia de Linux ya está configurada con el agente SSM y ahora se actualizará con el CodeDeploy agente.

1. En **Deployment configuration (Configuración de implementación)**, elija `CodeDeployDefault.OneAtaTime`.

1. En **Equilibrador de carga**, asegúrese de que no esté seleccionada la opción **Habilitar equilibrio de carga**. No es necesario configurar un balanceador de carga ni elegir un grupo de destino para este ejemplo.

1. Elija **Crear grupo de implementación**.

## Paso 5: Crea tu primera canalización en CodePipeline
<a name="codecommit-create-pipeline"></a>

Ya está preparado para crear y ejecutar su primera canalización. En este paso, crearás una canalización que se ejecutará automáticamente cuando el código se inserte en tu CodeCommit repositorio.

**Para crear una CodePipeline canalización**

1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

   Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyFirstPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **CodeCommit**. En **Nombre del repositorio**, elija el nombre del CodeCommit repositorio en [Paso 1: Crea un CodeCommit repositorio](#codecommit-create-repository) el que lo creó. En **Branch name (Nombre de la ramificación)**, elija `main` y, a continuación, elija **Next step (Paso siguiente)**.

   Tras seleccionar el nombre y la sucursal del repositorio, aparecerá un mensaje con la regla de Amazon CloudWatch Events que se va a crear para esta canalización. 

   En **Change detection options**, deje los valores predeterminados. Esto permite CodePipeline utilizar Amazon CloudWatch Events para detectar cambios en el repositorio de origen.

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. Elija **Siguiente**.
**nota**  
En este tutorial, va a implementar código que no requiere ningún servicio de compilación, por lo que puede omitir este paso. Sin embargo, si es necesario compilar el código fuente antes de implementarlo en instancias, puede configurar [CodeBuild](https://aws.amazon.com/codebuild/) en este paso.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la fase de despliegue**, en **Proveedor de despliegue**, seleccione **CodeDeploy**. En **Application name (Nombre de aplicación)**, escriba **MyDemoApplication**. En **Deployment group (Grupo de implementación)**, elija **MyDemoDeploymentGroup** y, a continuación, elija **Next step (Paso siguiente)**.

1. En el **paso 7: Revisar**, revise la información y, a continuación, seleccione **Crear canalización**.

1. La canalización comienza a ejecutarse después de crearla. Descarga el código del CodeCommit repositorio y crea una CodeDeploy implementación en la instancia de EC2. Puede ver los mensajes de progreso y de éxito y error a medida que en el CodePipeline ejemplo se implementa la página web en CodeDeploy la instancia de Amazon EC2 de la implementación.  
![\[Vista de una canalización que comienza a ejecutarse en la CodePipeline consola.\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

¡Enhorabuena\$1 Acabas de crear una canalización sencilla en CodePipeline. 

A continuación, podrá verificar los resultados.

**Para comprobar que la canalización se ha ejecutado correctamente**

1. Vea el progreso inicial de la canalización. El estado de cada etapa cambia de **No executions yet** (Sin ejecuciones) a **In Progress** (En curso) y después a **Succeeded** (Realizado correctamente) o **Failed** (Error). La canalización debería completar la primera ejecución en unos minutos.

1. Cuando aparezca **Sucessed** en el estado de la canalización, en el área de estado de la etapa de **despliegue**, seleccione **CodeDeploy**. Esto abre la CodeDeploy consola. Si no se muestra **Succeeded (Correcto)** consulte [Solución de problemas CodePipeline](troubleshooting.md).

1.  En la pestaña **Implementaciones**, elija el ID de la implementación. En la página de la implementación, en la sección **Eventos del ciclo de vida de la implementación**, elija el ID de la instancia. Se abrirá la consola de EC2.

1. En la pestaña **Description (Descripción)**, en **Public DNS (DNS público)**, copie la dirección (por ejemplo, `ec2-192-0-2-1.us-west-2.compute.amazonaws.com`) y después péguela en la barra de direcciones de su explorador web.

   Aparece la página web de la aplicación de muestra que descargaste e insertaste en tu CodeCommit repositorio.

Para obtener más información sobre las etapas, las acciones y cómo funcionan las canalizaciones, consulte [CodePipeline conceptos ](concepts.md).

## Paso 6: Modifica el código de tu CodeCommit repositorio
<a name="codecommit-push-code"></a>

Se ha configurado la canalización de modo que se ejecute siempre que se realicen cambios en el código de su repositorio de CodeCommit. En este paso, realizará cambios en el archivo HTML que forma parte de la CodeDeploy aplicación de ejemplo del CodeCommit repositorio. Cuando envíe estos cambios, la canalización se ejecuta de nuevo y los cambios que realice estarán visibles en la dirección web a la que accedió anteriormente.

1. Cambiar los directorios a su repositorio local:

   ```
   (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
   (For Windows) cd c:\temp\MyDemoRepo
   ```

1. Use un editor de texto para modificar el archivo `index.html`:

   ```
   (For Linux or Unix)gedit index.html
   (For OS X)open –e index.html
   (For Windows)notepad index.html
   ```

1. Revise el contenido del archivo `index.html` para cambiar el color de fondo y parte del texto de la página web y, a continuación, guarde el archivo. 

   ```
   <!DOCTYPE html>
   <html>
   <head>
     <title>Updated Sample Deployment</title>
     <style>
       body {
         color: #000000;
         background-color: #CCFFCC;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
           
       h1 {
         font-size: 250%;
         font-weight: normal;
         margin-bottom: 0;
       }
       
       h2 {
         font-size: 175%;
         font-weight: normal;
         margin-bottom: 0;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Updated Sample Deployment</h1></div>
     <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div>
     <div align="center">
       <p>Learn more:</p> 
       <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p>
     </div>
   </body>
   </html>
   ```

1. Confirme e inserte los cambios en su CodeCommit repositorio ejecutando los siguientes comandos, uno a la vez:

   ```
   git commit -am "Updated sample application files"
   ```

   ```
   git push
   ```

**Para comprobar que la canalización se ha ejecutado correctamente**

1. Vea el progreso inicial de la canalización. El estado de cada etapa cambia de **No executions yet** (Sin ejecuciones) a **In Progress** (En curso) y después a **Succeeded** (Realizado correctamente) o **Failed** (Error). La ejecución de la canalización debería completarse en unos minutos.

1. Cuando aparezca **Succeeded (Correcto)** en el estado de la acción, actualice la página de demostración a la que ha accedido anteriormente en el navegador.

   En la página web actualizada se mostrará:

## Paso 7: Limpiar recursos
<a name="codecommit-clean-up"></a>

Puede utilizar algunos de los recursos que ha creado en este tutorial para otros tutoriales de esta guía. Por ejemplo, puedes reutilizar la CodeDeploy aplicación y el despliegue. Sin embargo, una vez completado este o cualquier otro tutorial, debe eliminar la canalización y los recursos que utiliza para que no se le cobre por el uso continuado de esos recursos. En primer lugar, elimine la canalización, después la CodeDeploy aplicación y su instancia de Amazon EC2 asociada y, por último, el CodeCommit repositorio.

**Para limpiar los recursos usados en este tutorial**

1. Para limpiar sus CodePipeline recursos, siga las instrucciones de [Eliminar una canalización en AWS CodePipeline](pipelines-delete.md).

1. Para limpiar sus CodeDeploy recursos, siga las instrucciones del [tutorial sobre cómo limpiar los recursos de Deployment](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up).

1. Para eliminar el CodeCommit repositorio, siga las instrucciones de [Eliminar un CodeCommit repositorio](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html).

## Paso 8: Documentación adicional
<a name="codecommit-optional-tasks"></a>

Más información sobre cómo CodePipeline funciona:
+ Para obtener más información sobre las etapas, las acciones y cómo funcionan las canalizaciones, consulte [CodePipeline conceptos ](concepts.md).
+ Para obtener información sobre las acciones que puede realizar con ellas CodePipeline, consulte[Integraciones con tipos de CodePipeline acciones](integrations-action-type.md).
+ Pruebe este tutorial más avanzado, [Tutorial: Crear una canalización de cuatro etapas](tutorials-four-stage-pipeline.md). Crea una canalización de varias etapas que incluye un paso que compila código antes de implementarlo.

# Tutorial: Crear una canalización de cuatro etapas
<a name="tutorials-four-stage-pipeline"></a>

Ahora que ha creado su primera canalización en [Tutorial: Crear una canalización simple (bucket de S3)](tutorials-simple-s3.md) o [Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md), puede comenzar a crear canalizaciones más complejas. En este tutorial, se explica cómo crear una canalización de cuatro etapas que utiliza un GitHub repositorio para el código fuente, un servidor de compilación Jenkins para crear el proyecto y una CodeDeploy aplicación para implementar el código creado en un servidor provisional. En el siguiente diagrama se muestra la canalización inicial de tres etapas.

![\[Un diagrama que muestra la etapa de origen con la acción de origen, una etapa de compilación con la acción de Jenkins y una etapa de implementación con la acción de implementación.\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/flow-codepipeline-codecommit-jenkins.png)


Una vez creada la canalización, la editará para añadir una etapa con una acción de prueba para probar el código, utilizando Jenkins también. 

Para crear esta canalización, primero debe configurar los recursos necesarios. Por ejemplo, si quieres usar un GitHub repositorio para tu código fuente, debes crear el repositorio antes de poder añadirlo a una canalización. Este tutorial le ayudará a configurar Jenkins en una instancia EC2 con fines demostrativos. 

**importante**  
Muchas de las acciones que añadas a la canalización en este procedimiento implican AWS recursos que debes crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para las acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

Antes de empezar este tutorial, debe haber completado los requisitos previos generales indicados en [Empezar con CodePipeline](getting-started-codepipeline.md).

**Topics**
+ [

## Paso 1: completar los requisitos previos de
](#tutorials-four-stage-pipeline-prerequisites)
+ [

## Paso 2: Crea una canalización en CodePipeline
](#tutorials-four-stage-pipeline-pipeline-create)
+ [

## Paso 3: Agregar otra etapa a la canalización
](#tutorials-four-stage-pipeline-add-stage)
+ [

## Paso 4: limpie los recursos
](#tutorials-four-stage-pipeline-clean-up)

## Paso 1: completar los requisitos previos de
<a name="tutorials-four-stage-pipeline-prerequisites"></a>

Para integrarlo con Jenkins, es AWS CodePipeline necesario que instales el CodePipeline complemento para Jenkins en cualquier instancia de Jenkins con la que quieras usarlo. CodePipeline También debes configurar un usuario o rol de IAM dedicado para usarlos como permisos entre tu proyecto de Jenkins y. CodePipeline La forma más sencilla de integrar Jenkins CodePipeline es instalar Jenkins en una instancia de EC2 que utilice un rol de instancia de IAM que haya creado para la integración de Jenkins. Para que los enlaces de la canalización de acciones de Jenkins se conecten correctamente, debe configurar las opciones del proxy y del firewall del servidor o de la instancia EC2 de forma que permitan las conexiones entrantes en el puerto que el proyecto de Jenkins utiliza. Asegúrese de que ha configurado Jenkins para autenticar a los usuarios y aplicar el control de acceso antes de permitir conexiones en esos puertos (por ejemplo, 443 y 8443 si ha configurado Jenkins para que solo use conexiones HTTPS, o 80 y 8080 si permite conexiones HTTP). Para obtener más información, consulte [Securing Jenkins](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins).

**nota**  
En este tutorial se usa un ejemplo de código y se configuran los pasos de compilación necesarios para convertir el ejemplo de Haml a HTML. Puede descargar el código de muestra de código abierto del GitHub repositorio siguiendo los pasos que se indican en. [Copia o clona la muestra en un repositorio GitHub](#tutorials-four-stage-pipeline-prerequisites-github) Necesitarás toda la muestra en tu GitHub repositorio, no solo el archivo.zip.   
En este tutorial también se supone lo siguiente:  
Está familiarizado con la instalación y administración de Jenkins y con la creación de proyectos de Jenkins.
Ha instalado Rake y la gema Haml para Ruby en el mismo equipo o la misma instancia que aloja el proyecto de Jenkins.
Ha establecido las variables de entorno del sistema necesarias para poder ejecutar comandos de Rake desde la línea de comandos o el terminal (por ejemplo, en sistemas Windows, se modifica la variable PATH para incluir el directorio donde se instaló Rake).

**Topics**
+ [

### Copia o clona la muestra en un repositorio GitHub
](#tutorials-four-stage-pipeline-prerequisites-github)
+ [

### Creación de un rol de IAM para usar en la integración de Jenkins
](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [

### Instale y configure Jenkins y el CodePipeline complemento para Jenkins
](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)

### Copia o clona la muestra en un repositorio GitHub
<a name="tutorials-four-stage-pipeline-prerequisites-github"></a>

**Para clonar la muestra y enviarla a un GitHub repositorio**

1. Descargue el código de muestra del GitHub repositorio o clone los repositorios en su ordenador local. Existen dos muestras de paquetes: 
   + Si va a implementar la muestra en instancias de Amazon Linux, RHEL o Ubuntu Server, elija [codepipeline-jenkins-aws-codedeploy\$1linux.zip](https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux). 
   + Si va a implementar la muestra en instancias de Windows Server, elija [CodePipeline-Jenkins](https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows) - .zip. AWSCodeDeploy\$1Windows

1. Desde el repositorio, elija **Fork** para clonar el repositorio de muestra en su cuenta de Github. Para obtener más información, consulte la [Documentación de GitHub](https://help.github.com/articles/create-a-repo/).

### Creación de un rol de IAM para usar en la integración de Jenkins
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role"></a>

Como práctica recomendada, considere lanzar una instancia EC2 para alojar el servidor Jenkins y utilizar un rol de IAM para conceder a la instancia los permisos necesarios para interactuar con ella. CodePipeline

1. Inicie sesión en la consola de Consola de administración de AWS IAM y ábrala en. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. En la consola de IAM, en el panel de navegación, seleccione **Roles** y **Crear rol**.

1. En **Select type of trusted entity** (Seleccionar el tipo de entidad de confianza), elija **Servicio de AWS**. En **Choose the service that will use this role (Elegir el servicio que utilizará este rol)**, elija **EC2**. En **Select your use case (Seleccionar su caso de uso)**, elija **EC2**. 

1. Elija **Siguiente: permisos**. En la página **Attach permissions policies (Asociar políticas de permisos)**, seleccione la política administrada `AWSCodePipelineCustomActionAccess` y, a continuación, elija **Next: Tags (Siguiente: etiquetas)**. Elija **Siguiente: Revisar**.

1. En la página **Review (Revisar)**, **en Role name (Nombre del rol)**, especifique el nombre del rol que va a crear específicamente para la integración de Jenkins (por ejemplo, *JenkinsAccess*) y elija **Create role (Crear rol)**.

Cuando cree la instancia EC2 en la que va a instalar Jenkins, en **Step 3: Configure Instance Details (Paso 3: Configurar detalles de la instancia)**, asegúrese de que elige el rol de instancia (por ejemplo, *JenkinsAccess*).

Para obtener más información sobre los roles de instancia y Amazon EC2, consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), [Uso de un rol de IAM para conceder permisos a aplicaciones que se ejecutan en instancias de Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html) y [Creación de un rol para delegar permisos en un Servicio de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html).

### Instale y configure Jenkins y el CodePipeline complemento para Jenkins
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-configure"></a>

**Para instalar Jenkins y el CodePipeline complemento para Jenkins**

1. Cree la instancia EC2 en la que va a instalar Jenkins y en **Step 3: Configure Instance Details (Paso 3: Configurar detalles de instancia)**, asegúrese de elegir el rol de instancia que ha creado (por ejemplo, *JenkinsAccess*). Para obtener más información sobre la creación de instancias EC2, consulte [Lanzamiento de una instancia de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html) en la *Guía del usuario de Amazon EC2*. 
**nota**  
Si ya posee los recursos de Jenkins que desea usar, puede hacerlo, pero debe crear un usuario de IAM especial, aplicar la política administrada `AWSCodePipelineCustomActionAccess` a ese usuario y configurar y usar las credenciales de acceso de dicho usuario en su recurso de Jenkins. Si desea usar la interfaz de usuario de Jenkins para proporcionar las credenciales, configure Jenkins para que solo permita HTTPS. Para obtener más información, consulte [Solución de problemas CodePipeline](troubleshooting.md).

1. Instale Jenkins en la instancia EC2. Para obtener más información, consulte la documentación de Jenkins para [instalar Jenkins](https://www.jenkins.io/doc/book/installing/linux/) y [comenzar y obtener acceso a Jenkins](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html), además de [details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2) en [Integraciones de productos y servicios con CodePipeline](integrations.md).

1. Lance Jenkins y en la página de inicio, elija **Manage Jenkins**.

1. En la página **Manage Jenkins**, elija **Manage Plugins**.

1. Elija la pestaña **Available (Disponible)** y, en el cuadro de búsqueda **Filter (Filtrar)**, escriba **AWS CodePipeline**. Elija el **CodePipeline complemento para Jenkins** de la lista y elija **Descargar ahora e instalar** después de reiniciar.

1. En la página **Installing Plugins/Upgrades**, seleccione **Restart Jenkins when installation is complete and no jobs are running**.

1. Elija **Back to Dashboard**.

1. En la página de inicio, elija **New Item**.

1. En **Nombre del elemento**, introduce un nombre para el proyecto de Jenkins (por ejemplo,*MyDemoProject*). Elija **Freestyle project** y después haga clic en **OK**.
**nota**  
Asegúrese de que el nombre del proyecto cumple los requisitos de CodePipeline. Para obtener más información, consulte [Cuotas en AWS CodePipeline](limits.md).

1. En la página de configuración del proyecto, seleccione la casilla **Execute concurrent builds if necessary**. En **Source Code Management (Administración de código fuente)**, elija **AWS CodePipeline**. Si ha instalado Jenkins en una instancia de EC2 y la ha configurado AWS CLI con el perfil del usuario de IAM que creó para la integración entre Jenkins CodePipeline y Jenkins, deje todos los demás campos vacíos.

1. Elija **Avanzado** y, en **Proveedor**, introduzca un nombre para el proveedor de la acción tal y como aparecerá CodePipeline (por ejemplo,). *MyJenkinsProviderName* Asegúrese de que el nombre es único y fácil de recordar. Lo usará cuando añada una acción de compilación a la canalización más adelante en este tutorial y nuevamente cuando añada una acción de prueba.
**nota**  
Este nombre de acción debe cumplir los requisitos de denominación de acciones de CodePipeline. Para obtener más información, consulte [Cuotas en AWS CodePipeline](limits.md).

1. En **Build Triggers**, desmarque las casillas marcadas y seleccione **Poll SCM**. En **Schedule (Programación)**, escriba cinco asteriscos separados por espacios, de la siguiente manera:

   ```
   * * * * *
   ```

   Esto sondea CodePipeline cada minuto. 

1. En **Build**, elija **Add build step**. Elija **Ejecutar intérprete de comandos** (Amazon Linux, RHEL o Ubuntu Server) **Ejecutar el comando por lotes** (Windows Server) y, a continuación, introduzca lo siguiente:

   ```
   rake
   ```
**nota**  
Asegúrese de que el entorno está configurado con las variables y los valores obligatorios para ejecutar rake; de lo contrario, la compilación presentará errores.

1. Selecciona **Añadir acción posterior a la creación** y, a continuación, selecciona **AWS CodePipeline Publicador**. Elija **Añadir** y, en **Ubicaciones de salida de compilación**, deje la ubicación en blanco. Esta configuración es la predeterminada. Creará un archivo comprimido al final del proceso de compilación.

1. Elija **Save** para guardar su proyecto de Jenkins.

## Paso 2: Crea una canalización en CodePipeline
<a name="tutorials-four-stage-pipeline-pipeline-create"></a>

En esta parte del tutorial, va a crear una canalización utilizando el asistente **Create Pipeline (Crear canalización)**. 

**Para crear un proceso de publicación CodePipeline automatizado**

1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Si es necesario, use el selector de regiones para cambiar a la región en la que se encuentran los recursos de canalización. Por ejemplo, si ha creado recursos para el tutorial anterior en `us-east-2`, asegúrese de que el selector de regiones esté establecido en Este de EE. UU. (Ohio).

   Para obtener más información sobre las regiones y los puntos finales disponibles CodePipeline, consulte [AWS CodePipeline puntos finales y cuotas](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En la página **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba el nombre de la canalización.

1. CodePipeline proporciona canalizaciones de tipo V1 y V2, que difieren en sus características y precios. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: Añadir la fase de origen**, en **Proveedor de origen**, seleccione **GitHub**.

1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

1. En **Paso 4: agregar la etapa de compilación**, elija **Agregar Jenkins**. En **Nombre del proveedor**, introduce el nombre de la acción que proporcionaste en el CodePipeline complemento de Jenkins (por ejemplo*MyJenkinsProviderName*). Este nombre debe coincidir exactamente con el nombre del CodePipeline complemento de Jenkins. En **Server URL (URL del servidor)**, escriba la URL de la instancia EC2 en la que se ha instalado Jenkins. **En **Nombre del proyecto**, introduce el nombre del proyecto que creaste en Jenkins, por ejemplo*MyDemoProject*, y luego selecciona Siguiente.**

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la fase de despliegue**, reutilice la CodeDeploy aplicación y el grupo de despliegue en [Tutorial: Crear una canalización simple (bucket de S3)](tutorials-simple-s3.md) los que creó. En **Deploy provider (Proveedor de implementación)**, elija **CodeDeploy**. En **Nombre de la aplicación**, escriba **CodePipelineDemoApplication** o haga clic en el botón de actualización y elija el nombre de la aplicación en la lista. En **Deployment group (Grupo de implementación)**, escriba **CodePipelineDemoFleet** o elija un grupo de la lista. A continuación, elija **Next (Siguiente)**.
**nota**  
Puede utilizar sus propios CodeDeploy recursos o crear otros nuevos, pero puede incurrir en costes adicionales.

1. En el **paso 7: Revisar**, revisa la información y, a continuación, selecciona **Crear canalización**.

1. La canalización se inicia automáticamente y ejecuta la muestra en la canalización. Puede ver los mensajes de progreso y éxito y fracaso a medida que la canalización crea el ejemplo de Haml en HTML y lo despliega en una página web en cada una de las instancias de Amazon EC2 de la implementación. CodeDeploy

## Paso 3: Agregar otra etapa a la canalización
<a name="tutorials-four-stage-pipeline-add-stage"></a>

Ahora, agregará una etapa de prueba y, después, agregará a esa etapa una acción de prueba que use la prueba de Jenkins del ejemplo para determinar si la página web tiene contenido. Esta prueba solo tiene fines ilustrativos.

**nota**  
Si no quisiese añadir otra etapa a la canalización, podría añadir una acción de prueba a la etapa de ensayo de la canalización, antes o después de la acción de implementación.

### Agregar una etapa de prueba a la canalización
<a name="tutorials-four-stage-pipeline-add-stage-console"></a>

**Topics**
+ [

#### Buscar la dirección IP de una instancia
](#tutorials-four-stage-pipeline-instance-ip-lookup)
+ [

#### Crear un proyecto de Jenkins para probar la implementación
](#tutorials-four-stage-pipeline-create-jenkins-project)
+ [

#### Crear una cuarta etapa
](#tutorials-four-stage-pipeline-create-fourth-stage)

#### Buscar la dirección IP de una instancia
<a name="tutorials-four-stage-pipeline-instance-ip-lookup"></a>

**Para comprobar la dirección IP de una instancia en la que ha implementado el código**

1. Cuando el estado de canalización aparezca como **Succeeded** en el área de estado de la etapa Staging (Ensayo), elija **Details**. 

1. En la sección **Deployment Details**, en **Instance ID**, elija el ID de instancia de una de las instancias implementadas correctamente. 

1. Copie la dirección IP de la instancia (por ejemplo,). *192.168.0.4* Usará esta dirección IP en la prueba de Jenkins.

#### Crear un proyecto de Jenkins para probar la implementación
<a name="tutorials-four-stage-pipeline-create-jenkins-project"></a>

**Para crear el proyecto de Jenkins**

1. En la instancia en la que ha instalado Jenkins, abra Jenkins y en la página principal, elija **New Item**.

1.  En **Nombre del elemento**, introduzca un nombre para el proyecto de Jenkins (por ejemplo,*MyTestProject*). Elija **Freestyle project** y después haga clic en **OK**.
**nota**  
Asegúrese de que el nombre del proyecto cumpla con los CodePipeline requisitos. Para obtener más información, consulte [Cuotas en AWS CodePipeline](limits.md).

1. En la página de configuración del proyecto, seleccione la casilla **Execute concurrent builds if necessary**. En **Source Code Management (Administración de código fuente)**, elija **AWS CodePipeline**. Si ha instalado Jenkins en una instancia de EC2 y la ha configurado AWS CLI con el perfil del usuario de IAM que creó para la integración entre Jenkins CodePipeline y Jenkins, deje todos los demás campos vacíos. 
**importante**  
Si está configurando un proyecto de Jenkins y no está instalado en una instancia de Amazon EC2, o está instalado en una instancia EC2 que ejecuta un sistema operativo Windows, complete los campos requeridos por la configuración del puerto y el host del proxy, y proporcione las credenciales del usuario o rol de IAM que configuró para la integración entre Jenkins y. CodePipeline

1. Elija **Avanzado** y en **Categoría**, elija **Prueba**. 

1. En **Provider**, introduzca el mismo nombre que utilizó para el proyecto de compilación (por ejemplo,). *MyJenkinsProviderName* Usará este nombre cuando añada la acción de prueba a la canalización más adelante en este tutorial.
**nota**  
Este nombre debe cumplir los requisitos de CodePipeline denominación para las acciones. Para obtener más información, consulte [Cuotas en AWS CodePipeline](limits.md).

1. En **Build Triggers**, desmarque las casillas marcadas y seleccione **Poll SCM**. En **Schedule (Programación)**, escriba cinco asteriscos separados por espacios, de la siguiente manera:

   ```
   * * * * *
   ```

   Esto sondea CodePipeline cada minuto. 

1. En **Build**, elija **Add build step**. Si va a realizar la implementación en instancias de Amazon Linux, RHEL, o Ubuntu Server, elija **Ejecutar intérprete de comandos**. A continuación, escriba lo siguiente, donde la dirección IP será la dirección de la instancia EC2 que copió anteriormente:

   ```
   TEST_IP_ADDRESS=192.168.0.4 rake test
   ```

   Si va a realizar la implementación en instancias de Windows Server, elija **Ejecutar comando por lotes** y escriba la siguiente información, donde la dirección IP es la dirección de la instancia EC2 que copió anteriormente:

   ```
   set TEST_IP_ADDRESS=192.168.0.4 rake test
   ```
**nota**  
La prueba adopta el puerto 80 como puerto predeterminado. Si desea especificar un puerto diferente, añada una indicación de puerto de prueba, tal y como se indica a continuación:   

   ```
   TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test
   ```

1. Selecciona **Añadir acción posterior a la creación** y, a continuación, selecciona **AWS CodePipeline Publicador**. No elija **Add**.

1. Elija **Save** para guardar su proyecto de Jenkins.

#### Crear una cuarta etapa
<a name="tutorials-four-stage-pipeline-create-fourth-stage"></a>

**Para añadir una etapa a la canalización que incluya la acción de prueba de Jenkins**

1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En **Name (Nombre)**, elija el nombre de la canalización que ha creado, MySecondPipeline. 

1. En la página de detalles de la canalización, elija **Edit**. 

1. En la página **Edit (Editar)**, elija **\$1 Stage (\$1 Etapa)** para añadir una etapa inmediatamente después de la etapa de compilación. 

1. En el campo de nombre de la etapa nueva, escriba un nombre (por ejemplo, **Testing**) y elija **\$1 Add action group (Agregar grupo de acciones)**. 

1. En **Nombre de la acción**, introduzca*MyJenkinsTest-Action*. En **Proveedor de pruebas**, elija el nombre del proveedor que especificó en Jenkins (por ejemplo,*MyJenkinsProviderName*). En **Nombre del proyecto**, ingresa el nombre del proyecto que creaste en Jenkins (por ejemplo,*MyTestProject*). **En **Artefactos de entrada**, elige el artefacto de la versión de Jenkins cuyo nombre predeterminado es y*BuildArtifact*, a continuación, selecciona Listo.**
**nota**  
Dado que la acción de prueba de Jenkins opera en la aplicación integrada en el paso de compilación de Jenkins, utilice el artefacto de compilación para el artefacto de entrada de la acción de prueba.

   Para obtener más información acerca de los artefactos de entrada y salida y de la estructura de las canalizaciones, consulte [CodePipeline referencia de estructura de tubería](reference-pipeline-structure.md).

1. En la página **Edit**, elija **Save pipeline changes**. En el cuadro de diálogo **Save pipeline changes**, elija **Save and continue**.

1. Aunque se ha añadido la nueva etapa a la canalización, el estado **No executions yet** aparece en esa etapa porque no se han producido cambios que activen otra ejecución de la canalización. Para ejecutar la muestra en la canalización revisada, elija **Liberar cambio** en la página de detalles de la canalización. 

   La vista de canalización muestra las etapas y acciones de su canalización y el estado de la revisión que se ejecuta en esas cuatro etapas. El tiempo que tarde en ejecutarse la canalización en todas las etapas dependerá del tamaño de los artefactos, la complejidad de la compilación y las acciones de prueba y otros factores. 

## Paso 4: limpie los recursos
<a name="tutorials-four-stage-pipeline-clean-up"></a>

Una vez completado este tutorial, debe eliminar la canalización y los recursos que utiliza para que no se le cobre por el uso continuado de esos recursos. Si no tiene intención de seguir utilizándola CodePipeline, elimine la canalización, luego la CodeDeploy aplicación y sus instancias de Amazon EC2 asociadas y, por último, el bucket de Amazon S3 que se utiliza para almacenar artefactos. También debería considerar la posibilidad de eliminar otros recursos, como el GitHub repositorio, si no tiene intención de seguir utilizándolos.

**Para limpiar los recursos usados en este tutorial**

1. Abra una sesión de terminal en su máquina Linux, macOS o Unix local o en un símbolo del sistema en su máquina Windows local y ejecute el comando **delete-pipeline** para eliminar la canalización creada. En **MySecondPipeline**, debería escribir el siguiente comando: 

   ```
   aws codepipeline delete-pipeline --name "MySecondPipeline"
   ```

   Este comando no devuelve nada.

1. Para limpiar CodeDeploy los recursos, sigue las instrucciones de [Cleaning Up](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up).

1. Para limpiar los recursos de la instancia, elimine la instancia EC2 en la que instaló Jenkins. Para obtener más información, consulte [Eliminación de la instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html).

1. Si no tiene intención de crear más canalizaciones o CodePipeline volver a utilizarlas, elimine el bucket de Amazon S3 que se utiliza para almacenar los artefactos de su canalización. Para eliminar el bucket, siga las instrucciones que se indican en [Eliminar un bucket](https://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html).

1. Si no tiene intención de volver a usar los demás recursos de esta canalización, plantéese eliminarlos siguiendo las instrucciones de la guía de ese recurso específico. Por ejemplo, si desea eliminar el GitHub repositorio, siga las instrucciones de [Eliminar un repositorio](https://help.github.com/articles/deleting-a-repository/) en el sitio GitHub web.

# Tutorial: Configurar una regla de CloudWatch eventos para recibir notificaciones por correo electrónico sobre los cambios de estado de la canalización
<a name="tutorials-cloudwatch-sns-notifications"></a>

Después de configurar una canalización AWS CodePipeline, puede configurar una regla de CloudWatch eventos para enviar notificaciones siempre que se produzcan cambios en el estado de ejecución de las canalizaciones o en las etapas o acciones de las canalizaciones. Para obtener más información sobre el uso de CloudWatch Events para configurar las notificaciones de los cambios de estado de las canalizaciones, consulta. [Monitorización de CodePipeline eventos](detect-state-changes-cloudwatch-events.md)

En este tutorial, va a configurar una notificación para enviar un correo electrónico cuando el estado de una canalización cambie a FAILED. En este tutorial, se utiliza un método de transformación de entrada al crear la regla de CloudWatch eventos. Transforma los detalles del esquema del mensaje para entregarlo en un formato legible.

**nota**  
Al crear los recursos para este tutorial, como la notificación de Amazon SNS y la regla de CloudWatch eventos, asegúrate de que los recursos se creen en la misma AWS región que tu canalización.

**Topics**
+ [

## Paso 1: Configurar una notificación de correo electrónico mediante Amazon SNS
](#create-filter-for-target)
+ [

## Paso 2: Crear una regla y agregar el tema de SNS como destino
](#create-notification-rule)
+ [

## Paso 3: Limpiar recursos
](#notifications-clean-up-resources)

## Paso 1: Configurar una notificación de correo electrónico mediante Amazon SNS
<a name="create-filter-for-target"></a>

Amazon SNS coordina el uso de temas para entregar mensajes a clientes o puntos de conexión de suscripción. Utilice Amazon SNS para crear un tema de notificación y, a continuación, suscríbase al tema con su dirección de correo electrónico. El tema Amazon SNS se añadirá como objetivo a tu regla de CloudWatch eventos. Para obtener más información, consulte la [Guía para desarrolladores de Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).

Cree o identifique un tema en Amazon SNS. CodePipeline utilizará CloudWatch Events para enviar notificaciones sobre este tema a través de Amazon SNS. Para crear un tema:

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

1. Seleccione **Crear tema**. 

1. En el cuadro de diálogo **Create new topic (Crear un nuevo tema)**, en **Topic name (Nombre del tema)**, escriba un nombre para el tema (por ejemplo, **PipelineNotificationTopic**).   
![\[Cree el tema de notificación mediante Amazon SNS;.\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/tutorial-SNS-topic.png)

1. Seleccione **Crear tema**.

   Para obtener más información, consulte [Crear un tema](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) en la *Guía para desarrolladores de Amazon SNS*.

Suscriba a uno o varios destinatarios al tema para que reciban notificaciones por correo electrónico. Para suscribir a un destinatario a un tema:

1. En la consola de Amazon SNS, en la lista **Temas**, seleccione la casilla situada junto al tema nuevo. Elija **Acciones, Suscribirse a tema**.

1. En el cuadro de diálogo **Create subscription**, compruebe que aparece un ARN en **Topic ARN**.

1. En **Protocolo**, elige **Correo electrónico**.

1. En **Endpoint**, escriba la dirección de correo electrónico completa del destinatario.

1. Elija **Create Subscription**.

1. Amazon SNS envía un correo electrónico de confirmación de suscripción al destinatario. Para recibir notificaciones por correo electrónico, el destinatario debe utilizar el enlace **Confirm subscription** de este correo electrónico. Cuando el destinatario hace clic en el enlace, si se ha suscrito correctamente, Amazon SNS muestra un mensaje de confirmación en el navegador web.

   Para obtener más información, consulte [Suscribirse a un tema](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html) en la *Guía del desarrollador de Amazon SNS*.

## Paso 2: Crear una regla y agregar el tema de SNS como destino
<a name="create-notification-rule"></a>

Cree una regla de notificación de CloudWatch eventos CodePipeline como fuente de eventos.

1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, seleccione **Events (Eventos)**.

1. Seleccione **Creación de regla**. En **Event source (Origen de eventos)**, elija **AWS CodePipeline**. Como **Event Type**, elija **Pipeline Execution State Change**.

1. Seleccione **Specific state(s) (Estado[s] específico[s])** y, a continuación, elija **FAILED**.

1. Elija **Edit** para abrir el editor de JSON para el panel **Event Pattern Preview**. Añada el parámetro **pipeline** con el nombre de la canalización, tal y como se muestra en el siguiente ejemplo para una canalización denominada “myPipeline”.

   Puede copiar el patrón de eventos aquí y pegarlo en la consola:

   ```
   {
     "source": [
       "aws.codepipeline"
     ],
     "detail-type": [
       "CodePipeline Pipeline Execution State Change"
     ],
     "detail": {
       "state": [
         "FAILED"
       ],
       "pipeline": [
         "myPipeline"
       ]
     }
   }
   ```

1. En **Targets**, seleccione **Add target**. 

1. En la lista de destinos, elija **SNS topic**. En **Topic**, introduzca el tema que ha creado.

1. Expanda **Configure input**, a continuación, elija **Input Transformer**. 

1. En el cuadro **Input Path**, escriba los siguientes pares clave-valor.

   ```
   { "pipeline" : "$.detail.pipeline" }
   ```

   En el cuadro **Input Template**, escriba lo siguiente: 

   ```
   "The Pipeline <pipeline> has failed."
   ```

1. Seleccione **Configurar los detalles**.

1. En la página **Configure rule details**, escriba un nombre y una descripción opcional. Para **State**, deje seleccionado el cuadro **Enabled**.

1. Seleccione **Creación de regla**. 

1. Confirme que ahora CodePipeline está enviando notificaciones de compilación. Por ejemplo, compruebe si hay correos electrónicos de notificación de compilación en su bandeja de entrada.

1. Para cambiar el comportamiento de una regla, en la CloudWatch consola, elija la regla y, a continuación, elija **Acciones** y **Editar**. Edite la regla, elija **Configurar detalles** y, a continuación, elija **Actualizar regla**.

   Para dejar de usar una regla para enviar notificaciones de compilación, en la CloudWatch consola, elige la regla y, a continuación, selecciona **Acciones**, **deshabilitar**.

   Para eliminar una regla, en la CloudWatch consola, selecciónela y, a continuación, elija **Acciones** y **Eliminar**.

## Paso 3: Limpiar recursos
<a name="notifications-clean-up-resources"></a>

Una vez completado este tutorial, debe eliminar la canalización y los recursos que utiliza para que no se le cobre por el uso continuado de esos recursos. 

Para obtener información sobre cómo limpiar la notificación de SNS y eliminar la regla de Amazon CloudWatch Events, consulte [Limpiar (cancelar la suscripción a un tema de Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html)) y consulte la referencia en la `DeleteRule` referencia de la API de [ CloudWatch Amazon Events](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/).

# Tutorial: Crea una canalización que compile y pruebe tu aplicación para Android con AWS Device Farm
<a name="tutorials-codebuild-devicefarm"></a>

Puedes usarlo AWS CodePipeline para configurar un flujo de integración continuo en el que tu aplicación se compila y se prueba cada vez que se envía una confirmación. En este tutorial, se muestra cómo crear y configurar una canalización para compilar y probar tu aplicación de Android con el código fuente en un GitHub repositorio. La canalización detecta la llegada de una nueva GitHub confirmación y, a continuación, se utiliza [CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)para compilar la aplicación y [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) para probarla.

**importante**  
Como parte de la creación de una canalización en la consola, para los artefactos se utilizará un depósito de artefactos CodePipeline de S3. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**importante**  
Muchas de las acciones que añades a la canalización en este procedimiento implican AWS recursos que debes crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para las acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

Puede probarlo con su aplicación Android actual y las definiciones de prueba, o usar la [aplicación de muestra y las definiciones de prueba que proporciona Device Farm](https://github.com/aws-samples/aws-device-farm-sample-app-for-android).

**Antes de empezar**

1. Inicia sesión en la AWS Device Farm consola y selecciona **Crear un proyecto nuevo**.

1. Elija el proyecto. En el navegador, copie la URL de su nuevo proyecto. La dirección URL contiene el ID del proyecto. 

1. Copie y conserve este ID de proyecto. Lo usará al crear la canalización en CodePipeline.

   Aquí mostramos una URL de ejemplo para un proyecto. Para extraer el ID del proyecto, copie el valor detrás de `projects/`. En este ejemplo, el ID del proyecto es `eec4905f-98f8-40aa-9afc-4c1cfexample`.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Configure CodePipeline para usar sus pruebas de Device Farm
<a name="codepipeline-configure-tests"></a>

1. 

   Agrega y confirma un archivo llamado [https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)raíz del código de tu aplicación y envíalo a tu repositorio. CodeBuild usa este archivo para ejecutar los comandos y acceder a los artefactos necesarios para compilar tu aplicación.

   ```
   version: 0.2
   
   phases:
     build:
       commands:
         - chmod +x ./gradlew
         - ./gradlew assembleDebug
   artifacts:
     files:
        - './android/app/build/outputs/**/*.apk'
     discard-paths: yes
   ```

1. (Opcional) Si usa [Calabash o Appium para probar su aplicación](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html), añada el archivo de definición de prueba al repositorio. Después podrá configurar CodeBuild para usar las definiciones con el fin de llevar a cabo el conjunto de pruebas. 

   Si utiliza las pruebas de Device Farm incorporadas, puede omitir este paso.

1. Para crear la canalización y añadir una etapa de código fuente, haga lo siguiente:

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

   1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

   1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

   1. En la página **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba el nombre de la canalización.

   1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

   1. En **Service role (Rol de servicio)**, deje la opción **New service role (Nuevo rol de servicio)** seleccionada y no haga ningún cambio en **Role name (Nombre de rol)**. También puede usar un rol de servicio que haya creado anteriormente.
**nota**  
Si utilizas un rol de CodePipeline servicio que se creó antes de julio de 2018, tendrás que añadir permisos para Device Farm. Para ello, abra la consola de IAM, busque el rol y, a continuación, añada los siguientes permisos a la política del rol. Para obtener más información, consulte [Agrega permisos al rol de CodePipeline servicio](how-to-custom-role.md#how-to-update-role-new-services).  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

   1. En la página **Paso 3: Agregar la etapa de origen**, en **Proveedor de fuentes**, elija **GitHub (mediante GitHub la aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Repository (Repositorio)**, elija el repositorio de código fuente.

   1. En **Branch (Ramificación)**, elija la ramificación que desea utilizar.

   1. Deje los valores predeterminados restantes para la acción de origen. Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, agregue una etapa de compilación:

   1. En **Proveedor de compilación**, elija **Otros proveedores de compilación** y, a continuación, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **En **Imagen**, escoja: 5.0. aws/codebuild/standard**

      CodeBuild usa esta imagen del sistema operativo, que tiene instalado Android Studio, para compilar tu aplicación.

   1. En **Rol de servicio**, elige tu rol de CodeBuild servicio actual o crea uno nuevo.

   1. En **Build specifications (Especificaciones de compilación)**, elija **Use a buildspec file (Usar un archivo buildspec)**.

   1. Selecciona **Continuar a CodePipeline**. Esto vuelve a la CodePipeline consola y crea un CodeBuild proyecto que utiliza el contenido del `buildspec.yml` repositorio para la configuración. El proyecto de compilación utiliza un rol de servicio para administrar los permisos del Servicio de AWS . Es posible que este paso tarde un par de minutos.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**. Debe ver un diagrama que muestra las etapas de código fuente y de compilación.

1. Añada una acción de prueba de Device Farm a su canalización:

   1. En la parte superior derecha, elija **Edit (Editar)**.

   1. En la parte inferior del diagrama, seleccione **\$1 Add stage (Añadir etapa)**. En **Nombre de la etapa**, escriba un nombre; por ejemplo, **Test**.

   1. Elija **\$1 Add action group (Añadir grupo de acciones)**.

   1. En **Nombre de la acción**, escriba un nombre. 

   1. En **Proveedor de la acción**, elija **AWS Device Farm**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. En **Input artifacts (Artefactos de entrada)**, elija el artefacto de entrada que coincida con el artefacto de salida de la etapa anterior a la de prueba, como `BuildArtifact`. 

      En la AWS CodePipeline consola, puedes encontrar el nombre del artefacto de salida de cada etapa pasando el ratón sobre el icono de información del diagrama de canalización. Si tu proceso de procesamiento prueba tu aplicación directamente desde la etapa de **origen**, elige. **SourceArtifact** Si la canalización incluye una etapa de **compilación**, elige **BuildArtifact**.

   1. En **ProjectId**, introduce tu ID de proyecto de Device Farm. Siga los pasos que se indican al principio de este tutorial para recuperar el ID del proyecto.

   1. En **DevicePoolArn**, introduzca el ARN del grupo de dispositivos. Para obtener el conjunto de dispositivos disponible ARNs para el proyecto, incluido el ARN de los principales dispositivos, utilice la AWS CLI para introducir el siguiente comando: 

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. En **AppType**, ingresa **Android**.

      A continuación, se muestra una lista de valores válidos para **AppType**:
      + **iOS**
      + **Android**
      + **Web**

   1. En **App (Aplicación)**, escriba la ruta del paquete de la aplicación compilado. La ruta es relativa a la raíz del artefacto de entrada de la etapa de prueba. Típicamente, esta ruta es similar a `app-release.apk`.

   1. En **TestType**, introduce tu tipo de prueba y, a continuación, en **Prueba**, introduce la ruta del archivo de definición de la prueba. La ruta es relativa a la raíz del artefacto de entrada de la prueba.

      A continuación, se muestra una lista de valores válidos para **TestType**:
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**nota**  
No se admiten los nodos de entorno personalizados.

   1. En los campos restantes, proporcione la configuración que sea adecuada para su prueba y tipo de aplicación.

   1. (Opcional) En **Advanced (Avanzado)**, proporcione información acerca de la configuración en la ejecución de prueba.

   1. Seleccione **Save**.

   1. En la etapa que está editando, elija **Done (Listo)**. En el panel de AWS CodePipeline , elija **Save (Guardar)** y, a continuación, elija **Save (Guardar)** cuando aparezca el mensaje de advertencia.

   1. Para enviar los cambios y comenzar una compilación de canalización, seleccione **Publicar modificación** y, a continuación, **Publicar**.

# Tutorial: Crea una canalización que pruebe tu aplicación para iOS con AWS Device Farm
<a name="tutorials-codebuild-devicefarm-S3"></a>

 Puede usarlo AWS CodePipeline para configurar fácilmente un flujo de integración continuo en el que su aplicación se pruebe cada vez que cambie el bucket de origen. En este tutorial se muestra cómo crear y configurar una canalización para probar su aplicación iOS compilada desde un bucket de S3. La canalización detecta la llegada de un cambio guardado a través de Amazon CloudWatch Events y, a continuación, utiliza [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) para probar la aplicación creada. 

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**importante**  
Muchas de las acciones que añades a la canalización en este procedimiento implican AWS recursos que debes crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

Puede probarlo con la [aplicación iOS de muestra](samples/s3-ios-test-1.zip) o usar la suya.

**Antes de empezar**

1. Inicia sesión en la AWS Device Farm consola y selecciona **Crear un proyecto nuevo**.

1. Elija el proyecto. En el navegador, copie la URL de su nuevo proyecto. La dirección URL contiene el ID del proyecto.

1. Copie y conserve este ID de proyecto. Lo usará al crear la canalización en CodePipeline.

   Aquí mostramos una URL de ejemplo para un proyecto. Para extraer el ID del proyecto, copie el valor detrás de `projects/`. En este ejemplo, el ID del proyecto es `eec4905f-98f8-40aa-9afc-4c1cfexample`.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Configure CodePipeline para usar sus pruebas de Device Farm (ejemplo de Amazon S3)
<a name="codepipeline-configure-tests-S3"></a>

1. Cree o utilice un bucket de S3 con el control de versiones habilitado. Puede seguir las instrucciones de [Paso 1: creación de un bucket de origen de S3 para la aplicación](tutorials-simple-s3.md#s3-create-s3-bucket) para crear un bucket de S3.

1. En la consola de Amazon S3 para su bucket, elija **Cargar** y siga las instrucciones para cargar el archivo .zip.

   La aplicación compilada de muestra debe estar empaquetada en un archivo .zip.

1. Para crear la canalización y añadir una etapa de código fuente, haga lo siguiente:

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

   1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

   1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

   1. En la página **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba el nombre de la canalización.

   1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

   1. En **Service role (Rol de servicio)**, deje la opción **New service role (Nuevo rol de servicio)** seleccionada y no haga ningún cambio en **Role name (Nombre de rol)**. También puede usar un rol de servicio que haya creado anteriormente.
**nota**  
Si usa un rol de CodePipeline servicio que se creó antes de julio de 2018, debe añadir permisos para Device Farm. Para ello, abra la consola de IAM, busque el rol y, a continuación, añada los siguientes permisos a la política del rol. Para obtener más información, consulte [Agrega permisos al rol de CodePipeline servicio](how-to-custom-role.md#how-to-update-role-new-services).  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

   1. En la página **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **Amazon S3**.

   1. En **Ubicación de Amazon S3**, escriba el bucket, como `my-storage-bucket` y la clave de objeto, como `s3-ios-test-1.zip` para su archivo .zip.

   1. Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, cree una etapa de compilación de marcador de posición para su canalización. De este modo puede crear la canalización en el asistente. Después de usar el asistente para crear su canalización de dos etapas, no se necesita más esta etapa de compilación de marcador de posición. Una vez completada la canalización, se elimina esta segunda etapa y se añade la nueva etapa de prueba en el paso 5.

   

   1. En **Build provider (Proveedor de compilación)**, elija **Add Jenkins (Añadir Jenkins)**. Esta selección de compilación es un marcador de posición. No se utiliza.

   1. En **Provider name (Nombre del proveedor)**, escriba un nombre. El nombre es un marcador de posición. No se utiliza.

   1. En **Server URL (URL del servidor)**, escriba el texto. El texto es un marcador de posición. No se utiliza.

   1. En **Project name (Nombre del proyecto)**, escriba un nombre. El nombre es un marcador de posición. No se utiliza.

   1. Elija **Siguiente**.

   1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

      Elija **Siguiente**.

   1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo.

   1. En el **paso 7: Revisar**, selecciona **Crear canalización**. Debe ver un diagrama que muestra las etapas de código fuente y de compilación.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/codepipeline-view-pipeline-S3.png)

1. Añada una acción de prueba de Device Farm a su canalización del siguiente modo:

   1. En la parte superior derecha, elija **Edit (Editar)**. 

   1. Elija **Edit stage (Editar etapa)**. Elija **Eliminar**. Esto elimina la etapa de marcador de posición ahora que ya no la necesita para la creación de canalizaciones.

   1. En la parte inferior del diagrama, seleccione **\$1 Add stage (Añadir etapa)**.

   1. En Stage name (Nombre de la etapa), escriba un nombre para esta, por ejemplo, Test, y, a continuación, elija **Add stage (Añadir etapa)**.

   1. Elija **\$1 Add action group (Añadir grupo de acciones)**.

   1. En **Nombre de acción**, introduce un nombre, como DeviceFarmTest.

   1. En **Proveedor de la acción**, elija **AWS Device Farm**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. En **Input artifacts (Artefactos de entrada)**, elija el artefacto de entrada que coincida con el artefacto de salida de la etapa anterior a la de prueba, como `SourceArtifact`. 

      En la AWS CodePipeline consola, para encontrar el nombre del artefacto de salida de cada etapa, coloca el cursor sobre el icono de información del diagrama de canalización. Si tu proceso de procesamiento prueba tu aplicación directamente desde la etapa de **origen**, elige. **SourceArtifact** Si la canalización incluye una etapa de **compilación**, elige **BuildArtifact**.

   1. En **ProjectId**, elige tu ID de proyecto de Device Farm. Siga los pasos que se indican al principio de este tutorial para recuperar el ID del proyecto.

   1. En **DevicePoolArn**, introduzca el ARN del grupo de dispositivos. Para obtener el conjunto de dispositivos disponible ARNs para el proyecto, incluido el ARN de los principales dispositivos, utilice la AWS CLI para introducir el siguiente comando: 

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. En **AppType**, ingresa **iOS**.

      A continuación, se muestra una lista de valores válidos para **AppType**:
      + **iOS**
      + **Android**
      + **Web**

   1. En **App (Aplicación)**, escriba la ruta del paquete de la aplicación compilado. La ruta es relativa a la raíz del artefacto de entrada de la etapa de prueba. Típicamente, esta ruta es similar a `ios-test.ipa`.

   1. En **TestType**, introduzca el tipo de prueba y, a continuación, en **Prueba**, introduzca la ruta del archivo de definición de la prueba. La ruta es relativa a la raíz del artefacto de entrada de la prueba.

      Si utiliza una de las pruebas de Device Farm integradas, escriba el tipo de prueba que ha configurado en el proyecto de Device Farm, por ejemplo BUILTIN\$1FUZZ. En **FuzzEventCount**, introduzca un tiempo en milisegundos, como 6000. En **FuzzEventThrottle**, introduzca un tiempo en milisegundos, como 50.

      Si no utiliza una de las pruebas de Device Farm integradas, escriba el tipo de prueba y, en **Prueba**, escriba la ruta del archivo de definición de prueba. La ruta es relativa a la raíz del artefacto de entrada de la prueba. 

      A continuación, se muestra una lista de valores válidos para **TestType**:
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**nota**  
No se admiten los nodos de entorno personalizados.

   1. En los campos restantes, proporcione la configuración que sea adecuada para su prueba y tipo de aplicación.

   1. (Opcional) En **Advanced (Avanzado)**, proporcione información acerca de la configuración en la ejecución de prueba.

   1. Seleccione **Save**.

   1. En la etapa que está editando, elija **Done (Listo)**. En el panel de AWS CodePipeline , elija **Save (Guardar)** y, a continuación, elija **Save (Guardar)** cuando aparezca el mensaje de advertencia.

   1. Para enviar los cambios y comenzar una ejecución de la canalización, elija **Release change (Publicar modificación)** y, a continuación, **Release (Publicar)**.

# Tutorial: Crear una canalización que se implemente en Service Catalog
<a name="tutorials-S3-servicecatalog"></a>

Service Catalog le permite crear y aprovisionar productos a partir de AWS CloudFormation plantillas. 

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

En este tutorial, se muestra cómo crear y configurar una canalización para implementar la plantilla de producto en Service Catalog y entregar los cambios que haya realizado en su repositorio de origen (ya creado en GitHub Amazon S3 o Amazon S3). CodeCommit

**nota**  
Cuando Amazon S3 es el proveedor de origen de la canalización, debe cargar en el bucket todos los archivos de origen empaquetados como un solo archivo .zip. De lo contrario, la acción de origen dará error.

En primer lugar, debe crear un producto en Service Catalog y, a continuación, crear una canalización en AWS CodePipeline. Este tutorial proporciona dos opciones para la configuración de la implementación:
+ Crear un producto en Service Catalog y cargar un archivo de plantilla en el repositorio de origen. Proporcione la versión del producto y la configuración de implementación en la CodePipeline consola (sin un archivo de configuración independiente). Consulte [Opción 1: Realizar la implementación en Service Catalog sin un archivo de configuración](#tutorials-S3-servicecatalog-ex1-configure).
**nota**  
El archivo de plantilla se puede crear en formato YAML o JSON.
+ Crear un producto en Service Catalog y cargar un archivo de plantilla en el repositorio de origen. Proporcione la versión del producto y la configuración de implementación en un archivo de configuración distinto. Consulte [Opción 2: Realizar la implementación en Service Catalog con un archivo de configuración](#tutorials-S3-servicecatalog-ex2-configure).

## Opción 1: Realizar la implementación en Service Catalog sin un archivo de configuración
<a name="tutorials-S3-servicecatalog-ex1-configure"></a>

En este ejemplo, carga el archivo de AWS CloudFormation plantilla de muestra para un bucket de S3 y, a continuación, crea el producto en Service Catalog. A continuación, crea la canalización y especifica la configuración de despliegue en la CodePipeline consola.

### Paso 1: Cargar un archivo de plantilla de ejemplo en un repositorio de código fuente
<a name="tutorials-S3-servicecatalog-configure"></a>

1. Abra un editor de texto. Cree una plantilla de ejemplo pegando lo siguiente en el archivo. Guarde el archivo como `S3_template.json`.

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   Esta plantilla permite AWS CloudFormation crear un bucket de S3 que Service Catalog puede utilizar.

1. Cargue el archivo `S3_template.json` en el repositorio de AWS CodeCommit .

### Paso 2: Crear un producto en Service Catalog
<a name="tutorials-S3-servicecatalog-product"></a>

1. Como administrador de TI, inicie sesión en la consola de Service Catalog., visite la página **Productos** y, a continuación, elija **Cargar nuevo producto**.

1. En la página **Upload new product (Cargar nuevo producto)**, complete lo siguiente:

   1. En **Product name (Nombre del producto)**, introduzca el nombre que desea usar para el nuevo producto.

   1. En **Description (Descripción)**, escriba la descripción del catálogo de productos. Esta descripción se muestra en el listado de productos para ayudar al usuario a elegir el producto correcto. 

   1. En **Provided by (Proporcionado por)**, escriba el nombre del departamento de TI o del administrador.

   1. Elija **Siguiente**.

1. (Opcional) En **Enter support details (Introducir detalles de soporte)**, escriba la información de contacto de soporte del producto y elija **Next (Siguiente)**.

1. En **Version details (Detalles de la versión)**, realice lo siguiente:

   1. Elija **Upload a template file (Cargar un archivo de plantilla)**. Busque su archivo `S3_template.json` y cárguelo.

   1. En **Version title (Título de versión)**, escriba el nombre de la versión del producto (por ejemplo, **devops S3 v2**).

   1. En **Description (Descripción)**, escriba detalles que distingan esta versión de otras versiones.

   1. Elija **Siguiente**.

1. En la página **Review (Revisar)**, compruebe que la información es correcta y, a continuación, elija **Create (Crear)**. 

1. En la página **Products (Productos)**, en el navegador, copie la URL de su nuevo producto. Contiene el ID del producto. Copie y conserve este ID de producto. Lo usará al crear la canalización en CodePipeline.

   A continuación se muestra la dirección URL de un producto llamado `my-product`. Para extraer el ID del producto, copie el valor entre el signo igual (`=`) y el signo ampersand (`&`). En este ejemplo, el ID del producto es `prod-example123456`.

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**nota**  
Copie la dirección URL de su producto antes de salir de la página. Una vez que salga de esta página, debe utilizar la CLI para obtener el ID del producto.

   Transcurridos unos segundos, el producto aparecerá en la página **Products (Productos)**. Puede que necesite actualizar el navegador para ver el producto en la lista.

### Paso 3: Crear la canalización
<a name="tutorials-S3-servicecatalog-pipeline"></a>

1. Para asignar un nombre a la canalización y seleccionar los parámetros para la canalización, haga lo siguiente:

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

   1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

   1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

   1. En el **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba un nombre para su canalización.

   1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

   1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

   1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. Para agregar una etapa de origen en la página **Paso 3: agregación de la etapa de origen**, realice lo siguiente:

   1. En **Source provider (Proveedor de código fuente)**, elija **AWS CodeCommit**.

   1. En **Repository name (Nombre de repositorio)** y **Branch name (Nombre de ramificación)**, escriba el repositorio y la ramificación que desea utilizar para su acción de código fuente.

   1. Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En **Paso 6: agregación de la etapa de implementación**, lleve a cabo lo siguiente:

   1. En **Deploy provider (Proveedor de implementación)**, elija **AWS Service Catalog**.

   1. Para la configuración de implementación, elija **Enter deployment configuration (Especificar configuración de implementación)**.

   1. En **ID de producto**, pegue el ID de producto copiado de la consola de Service Catalog.

   1. En **Template file, path (Ruta de archivo de plantilla)**, escriba la ruta relativa donde se almacena el archivo de plantilla.

   1. En **Tipo de producto**, elija la **plantilla de CloudFormation **.

   1. En **Nombre de versión de producto**, escriba el nombre de la versión del producto que ha especificado en Service Catalog. Si desea implementar el cambio de plantilla en una nueva versión de producto, escriba un nombre de versión del producto que no se haya utilizado en cualquier versión de producto anterior en el mismo producto.

   1. Para **Input artifact (Artefacto de entrada)**, elija el artefacto de entrada de código fuente.

   1. Elija **Siguiente**.

1. En **Paso 7: revisión**, revise la configuración de la canalización y después elija **Crear**.

1. Después de que la canalización se ejecute correctamente, en la etapa de implementación, elija **Details (Detalles)**. Esto abre el producto en Service Catalog.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. En su información del producto, seleccione el nombre de la versión para abrir la plantilla del producto. Vea la implementación de la plantilla.

### Paso 4: Enviar un cambio y verificar el producto en Service Catalog
<a name="tutorials-S3-servicecatalog-change"></a>

1. Consulta tu canalización en la CodePipeline consola y, en la fase de origen, selecciona **Detalles**. El AWS CodeCommit repositorio de código fuente se abre en la consola. Elija **Edit (Editar)** y haga un cambio en el archivo (por ejemplo, en la descripción). 

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. Confirme y envíe el cambio. La canalización comienza después de enviar el cambio. Cuando la ejecución de la canalización se haya completado, en la etapa de implementación, elija **Detalles** para abrir su producto en Service Catalog.

1. En su información del producto, seleccione el nuevo nombre de la versión para abrir la plantilla del producto. Vea el cambio de plantilla implementado.

## Opción 2: Realizar la implementación en Service Catalog con un archivo de configuración
<a name="tutorials-S3-servicecatalog-ex2-configure"></a>

En este ejemplo, carga el archivo de AWS CloudFormation plantilla de muestra para un bucket de S3 y, a continuación, crea el producto en Service Catalog. También puede cargar un archivo de configuración distinto que especifique la configuración de implementación. A continuación, cree la canalización y especifique la ubicación del archivo de configuración.

### Paso 1: Cargar un archivo de plantilla de ejemplo en un repositorio de código fuente
<a name="tutorials-S3-servicecatalog-upload2"></a>

1. Abra un editor de texto. Cree una plantilla de ejemplo pegando lo siguiente en el archivo. Guarde el archivo como `S3_template.json`.

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   Esta plantilla permite AWS CloudFormation crear un bucket de S3 que Service Catalog puede utilizar.

1. Cargue el archivo `S3_template.json` en el repositorio de AWS CodeCommit .

### Paso 2: Crear el archivo de configuración de implementación del producto
<a name="tutorials-S3-servicecatalog-configure2"></a>

1. Abra un editor de texto. Cree el archivo de configuración para su producto. El archivo de configuración se utiliza para definir los parámetros/preferencias de implementación de Service Catalog. Utilice este archivo al crear la canalización.

   Este ejemplo proporciona un `ProductVersionName` de "devops S3 v2" y un `ProductVersionDescription` de `MyProductVersionDescription`. Si desea implementar el cambio de plantilla en una nueva versión de producto, escriba un nombre de versión del producto que no se haya utilizado en ninguna versión de producto anterior en el mismo producto.

    Guarde el archivo como `sample_config.json`.

   ```
   {
       "SchemaVersion": "1.0",
       "ProductVersionName": "devops S3 v2",
       "ProductVersionDescription": "MyProductVersionDescription",
       "ProductType": "CLOUD_FORMATION_TEMPLATE",
       "Properties": {
           "TemplateFilePath": "/S3_template.json"
       }
   }
   ```

   Este archivo crea la información de versión del producto cada vez que se ejecute la canalización.

1. Cargue el archivo `sample_config.json` en el repositorio de AWS CodeCommit . Asegúrese de cargar este archivo en el repositorio de código fuente.

### Paso 3: Crear un producto en Service Catalog
<a name="tutorials-S3-servicecatalog-product2"></a>

1. Como administrador de TI, inicie sesión en la consola de Service Catalog., visite la página **Productos** y, a continuación, elija **Cargar nuevo producto**.

1. En la página **Upload new product (Cargar nuevo producto)**, complete lo siguiente:

   1. En **Product name (Nombre del producto)**, introduzca el nombre que desea usar para el nuevo producto.

   1. En **Description (Descripción)**, escriba la descripción del catálogo de productos. Esta descripción aparece en el listado de productos para ayudar al usuario a elegir el producto correcto. 

   1. En **Provided by (Proporcionado por)**, escriba el nombre del departamento de TI o del administrador.

   1. Elija **Siguiente**.

1. (Opcional) En **Enter support details (Introducir detalles de soporte)**, escriba la información de contacto de soporte del producto y elija **Next (Siguiente)**.

1. En **Version details (Detalles de la versión)**, realice lo siguiente:

   1. Elija **Upload a template file (Cargar un archivo de plantilla)**. Busque su archivo `S3_template.json` y cárguelo.

   1. En **Version title (Título de versión)**, escriba el nombre de la versión del producto (por ejemplo, "devops S3 v2").

   1. En **Description (Descripción)**, escriba detalles que distingan esta versión de otras versiones.

   1. Elija **Siguiente**.

1. En la página **Review (Revisar)**, compruebe que la información es correcta y, a continuación, elija **Confirm and upload (Confirmar y cargar)**. 

1. En la página **Products (Productos)**, en el navegador, copie la URL de su nuevo producto. Contiene el ID del producto. Copie y conserve este ID de producto. Lo usará al crear la canalización en CodePipeline.

   A continuación se muestra la dirección URL de un producto llamado `my-product`. Para extraer el ID del producto, copie el valor entre el signo igual (`=`) y el signo ampersand (`&`). En este ejemplo, el ID del producto es `prod-example123456`. 

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**nota**  
Copie la dirección URL de su producto antes de salir de la página. Una vez que salga de esta página, debe utilizar la CLI para obtener el ID del producto.

   Transcurridos unos segundos, el producto aparecerá en la página **Products (Productos)**. Puede que necesite actualizar el navegador para ver el producto en la lista.

### Paso 4: Crear la canalización
<a name="tutorials-S3-servicecatalog-pipeline2"></a>

1. Para asignar un nombre a la canalización y seleccionar los parámetros para la canalización, haga lo siguiente:

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

   1. Elija **Empezar**. Elija **Crear canalización** y, a continuación, escriba un nombre para su canalización.

   1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

   1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. Para añadir una etapa de código fuente, haga lo siguiente:

   1. En **Source provider (Proveedor de código fuente)**, elija **AWS CodeCommit**.

   1. En **Repository name (Nombre de repositorio)** y **Branch name (Nombre de ramificación)**, escriba el repositorio y la ramificación que desea utilizar para su acción de código fuente.

   1. Elija **Siguiente**.

1. En **Add build stage (Añadir etapa de compilación)**, elija **Skip build stage (Omitir etapa de compilación)** y, a continuación, acepte el mensaje de advertencia eligiendo **Skip (Omitir)** una vez más.

1. En **Add deploy stage (Añadir etapa de implementación)**, lleve a cabo lo siguiente:

   1. En **Deploy provider (Proveedor de implementación)**, elija **AWS Service Catalog**.

   1. Elija **Use configuration file (Usar un archivo de configuración)**.

   1. En **ID de producto**, pegue el ID de producto copiado de la consola de Service Catalog.

   1. En **Configuration file path (Ruta de archivo de configuración)**, escriba la ruta del archivo de configuración en el repositorio.

   1. Elija **Siguiente**.

1. En **Review (Revisar)**, revise la configuración de la canalización y después elija **Create (Crear)**.

1. Después de que la canalización se ejecute correctamente, en su etapa de implementación, elija **Detalles** para abrir el producto en Service Catalog.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. En su información del producto, seleccione el nombre de la versión para abrir la plantilla del producto. Vea la implementación de la plantilla.

### Paso 5: Enviar un cambio y verificar el producto en Service Catalog
<a name="tutorials-S3-servicecatalog-change2"></a>

1. Consulta tu canalización en la CodePipeline consola y, en la fase de origen, selecciona **Detalles**. El AWS CodeCommit repositorio de código fuente se abre en la consola. Elija **Edit (Editar)** y, a continuación, haga un cambio en el archivo (por ejemplo, en la descripción).

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. Confirme y envíe el cambio. La canalización comienza después de enviar el cambio. Cuando la ejecución de la canalización se haya completado, en la etapa de implementación, elija **Detalles** para abrir su producto en Service Catalog.

1. En su información del producto, seleccione el nuevo nombre de la versión para abrir la plantilla del producto. Vea el cambio de plantilla implementado.

# Tutorial: Cree una canalización con AWS CloudFormation
<a name="tutorials-cloudformation"></a>

En los ejemplos se proporcionan plantillas de muestra que puede utilizar AWS CloudFormation para crear una canalización que despliegue la aplicación en las instancias cada vez que se modifique el código fuente. La plantilla de ejemplo crea una canalización que se puede visualizar en AWS CodePipeline. La canalización detecta la llegada de un cambio guardado a través de Amazon CloudWatch Events.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**Topics**
+ [

# Ejemplo 1: crear una AWS CodeCommit canalización con AWS CloudFormation
](tutorials-cloudformation-codecommit.md)
+ [

# Ejemplo 2: Crear una canalización de Amazon S3 con AWS CloudFormation
](tutorials-cloudformation-s3.md)

# Ejemplo 1: crear una AWS CodeCommit canalización con AWS CloudFormation
<a name="tutorials-cloudformation-codecommit"></a>

En este tutorial, se muestra cómo usar la AWS CloudFormation consola para crear una infraestructura que incluya una canalización conectada a un repositorio de CodeCommit origen. En este tutorial, utilizarás el archivo de plantilla de ejemplo proporcionado para crear tu pila de recursos, que incluye el almacén de artefactos, la canalización y los recursos de detección de cambios, como la regla de Amazon CloudWatch Events. Una vez que hayas creado tu pila de recursos AWS CloudFormation, podrás ver tu canalización en la consola. AWS CodePipeline La canalización es una canalización de dos etapas: una etapa CodeCommit de origen y una etapa de CodeDeploy implementación.

**Requisitos previos**:

Debe haber creado los siguientes recursos para utilizarlos con la plantilla de AWS CloudFormation ejemplo:
+ Debe haber creado un repositorio de origen. Puede usar el AWS CodeCommit repositorio en el que creó[Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ Debe haber creado un grupo de CodeDeploy aplicaciones y despliegues. Puede utilizar los recursos de CodeDeploy creados en [Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ [Elige uno de estos enlaces para descargar el archivo de AWS CloudFormation plantilla de ejemplo para crear una canalización: [YAML \$1 JSON](samples/codepipeline-codecommit-events-yaml.zip)](samples/codepipeline-codecommit-events-json.zip)

  Descomprima el archivo y colóquelo en su equipo local.
+ Descarga el archivo de aplicación de ejemplo [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip).



**Crea tu canalización en AWS CloudFormation**

1. Descomprime los archivos de [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) y súbelos a tu AWS CodeCommit repositorio. Debe cargar los archivos descomprimidos en el directorio raíz del repositorio. Puede seguir las instrucciones en [Paso 2: Agrega un código de muestra a tu CodeCommit repositorio](tutorials-simple-codecommit.md#codecommit-add-code) para enviar los archivos a su repositorio.

1. Abre la AWS CloudFormation consola y selecciona **Create Stack**. Elija **Con nuevos recursos (estándar)**.

1. En **Especificar plantilla**, elija **Cargar una plantilla**. Seleccione **Elegir un archivo** y luego seleccione el archivo de plantilla desde el equipo local. Elija **Siguiente**.

1. En **Stack Name (Nombre de pila)**, escriba el nombre de la canalización. Se muestran los parámetros especificados en la plantilla de muestra. Introduzca los siguientes parámetros: 

   1. En **ApplicationName**, introduce el nombre de tu CodeDeploy aplicación.

   1. En **BetaFleet**, introduzca el nombre de su grupo de CodeDeploy implementación.

   1. En **BranchName**, introduzca la rama del repositorio que desee usar.

   1. En **RepositoryName**, introduce el nombre del repositorio de CodeCommit origen.

1. Elija **Siguiente**. Acepte los valores predeterminados en la siguiente página y, a continuación, elija **Next (Siguiente)**.

1. En **Capacidades**, seleccione **Acepto que AWS CloudFormation podría crear recursos de IAM** y, a continuación, elija **Crear pila**.

1. Una vez creada la pila, consulte la lista de eventos para comprobar si hay errores.

   **Solución de problemas**

   Es posible que el usuario de IAM que está creando la canalización AWS CloudFormation necesite permisos adicionales para crear recursos para la canalización. La política requiere los siguientes permisos para poder AWS CloudFormation crear los recursos de Amazon CloudWatch Events necesarios para la CodeCommit canalización:

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

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

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.
**nota**  
Para ver la canalización que se creó, busque la columna **ID lógico** en la pestaña **Recursos** para su pila en CloudFormation. Anote el nombre de la canalización en la columna **ID físico**. En CodePipeline ella, podrás ver la canalización con el mismo ID físico (nombre de la canalización) de la región en la que creaste la pila.

1. En el repositorio de origen, confirme y envíe un cambio. Sus recursos de detección de cambios recogen el cambio y se inicia la canalización.

# Ejemplo 2: Crear una canalización de Amazon S3 con AWS CloudFormation
<a name="tutorials-cloudformation-s3"></a>

En este tutorial, se muestra cómo utilizar la AWS CloudFormation consola para crear una infraestructura que incluya una canalización conectada a un bucket de origen de Amazon S3. En este tutorial, utilizarás el archivo de plantilla de ejemplo proporcionado para crear tu pila de recursos, que incluye el depósito de origen, el almacén de artefactos, la canalización y los recursos de detección de cambios, como la regla y el seguimiento de Amazon CloudWatch Events. CloudTrail Una vez que haya creado su pila de recursos AWS CloudFormation, podrá ver su canalización en la consola. AWS CodePipeline La canalización es una canalización de dos etapas con una etapa de origen de Amazon S3 y una etapa de CodeDeploy implementación.

**Requisitos previos**:

Debe disponer de los siguientes recursos para utilizarlos con la plantilla de AWS CloudFormation ejemplo:
+ Debe haber creado las instancias de Amazon EC2, donde instaló el CodeDeploy agente en las instancias. Debe haber creado un grupo de CodeDeploy aplicaciones y despliegues. Utilice Amazon EC2 y CodeDeploy los recursos en los que creó. [Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md)
+ Seleccione los siguientes enlaces para descargar los archivos de AWS CloudFormation plantilla de ejemplo para crear una canalización con una fuente de Amazon S3: 
  + Descargue la plantilla de ejemplo para su canalización: [YAML](samples/codepipeline-s3-events-yaml.zip) \$1 [JSON](samples/codepipeline-s3-events-json.zip)
  + [Descarga la plantilla de muestra para tu CloudTrail bucket y ruta: [YAML \$1 JSON](samples/codepipeline-s3-cloudtrail-yaml.zip)](samples/codepipeline-s3-cloudtrail-json.zip)
  + Descomprima los archivos y colóquelos en su equipo local.
+ Descarga la aplicación de muestra desde [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip).

  Guarde el archivo .zip en su equipo local. Debe cargar el archivo .zip una vez que se haya creado la pila.

**Crea tu canalización en AWS CloudFormation**

1. Abre la AWS CloudFormation consola y selecciona **Create Stack**. Elija **Con nuevos recursos (estándar)**.

1. En **Elegir una plantilla**, elija **Cargar una plantilla**. Seleccione **Elegir un archivo** y luego seleccione el archivo de plantilla desde el equipo local. Elija **Siguiente**.

1. En **Stack Name (Nombre de pila)**, escriba el nombre de la canalización. Se muestran los parámetros especificados en la plantilla de muestra. Introduzca los siguientes parámetros: 

   1. En **ApplicationName**, introduce el nombre de tu CodeDeploy aplicación. Puede reemplazar el nombre predeterminado `DemoApplication`.

   1. En **BetaFleet**, introduzca el nombre de su grupo de CodeDeploy implementación. Puede reemplazar el nombre predeterminado `DemoFleet`.

   1. En **SourceObjectKey**, introduzca`SampleApp_Linux.zip`. Puede cargar este archivo en el bucket después de que la plantilla cree el bucket y la canalización.

1. Elija **Siguiente**. Acepte los valores predeterminados en la siguiente página y, a continuación, elija **Next (Siguiente)**.

1. En **Capacidades**, seleccione **Acepto que AWS CloudFormation podría crear recursos de IAM** y, a continuación, elija **Crear pila**.

1. Una vez creada la pila, consulte la lista de eventos para comprobar si hay errores.

   **Solución de problemas**

   Es posible que el usuario de IAM que está creando la canalización AWS CloudFormation necesite permisos adicionales para crear recursos para la canalización. La política requiere los siguientes permisos para poder crear los recursos de Amazon CloudWatch Events necesarios para la canalización de Amazon S3: AWS CloudFormation 

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. En CloudFormation la pestaña **Recursos** de su pila, consulte los recursos que se crearon para su pila. 
**nota**  
Para ver la canalización que se creó, busque la columna **ID lógico** en la pestaña **Recursos** para su pila en CloudFormation. Anote el nombre de la canalización en la columna **ID físico**. En CodePipeline, puedes ver la canalización con el mismo ID físico (nombre de la canalización) de la región en la que creaste la pila.

   Elija el bucket de S3 con una etiqueta `sourcebucket` en el nombre, como `s3-cfn-codepipeline-sourcebucket-y04EXAMPLE.`. No elija el bucket del artefacto de la canalización.

   El bucket de origen está vacío porque CloudFormation ha creado recientemente el recurso. Abra la consola de Amazon S3 y localice su bucket de `sourcebucket`. Elija **Upload (Cargar)** y siga las instrucciones para cargar el archivo .zip `SampleApp_Linux.zip`.
**nota**  
Cuando Amazon S3 es el proveedor de origen de la canalización, debe cargar en el bucket todos los archivos de origen empaquetados como un solo archivo .zip. De lo contrario, la acción de origen dará error.

1. Inicia sesión en Consola de administración de AWS y abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Complete los pasos del siguiente procedimiento para crear sus recursos de AWS CloudTrail .

**Crea tus AWS CloudTrail recursos en AWS CloudFormation**

1. Abre la AWS CloudFormation consola y selecciona **Create Stack**.

1. En **Elegir una plantilla**, elija **Subir una plantilla en Amazon S3**. Elija **Examinar** y, a continuación, seleccione el archivo de plantilla para los AWS CloudTrail recursos de su ordenador local. Elija **Siguiente**.

1. En **Stack name (Nombre de pila)**, escriba un nombre para la pila de recursos. Se muestran los parámetros especificados en la plantilla de muestra. Introduzca los siguientes parámetros: 

   1. En **SourceObjectKey**, acepte el valor predeterminado del archivo zip de la aplicación de ejemplo.

1. Elija **Siguiente**. Acepte los valores predeterminados en la siguiente página y, a continuación, elija **Next (Siguiente)**.

1. En **Capacidades**, seleccione **Acepto que AWS CloudFormation podría crear recursos de IAM** y, a continuación, elija **Crear**.

1. Una vez creada la pila, consulte la lista de eventos para comprobar si hay errores.

   La política requiere los siguientes permisos para poder crear AWS CloudFormation los CloudTrail recursos necesarios para la canalización de Amazon S3:

   ```
   {
        "Effect": "Allow",
        "Action": [
           "cloudtrail:CreateTrail",
           "cloudtrail:DeleteTrail",
           "cloudtrail:StartLogging",
           "cloudtrail:StopLogging",
           "cloudtrail:PutEventSelectors"
        ],
        "Resource": "resource_ARN"
   }
   ```

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

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. En el bucket de origen, confirme y envíe un cambio. Sus recursos de detección de cambios recogen el cambio y se inicia la canalización.

# Tutorial: Crear una canalización que utilice variables de las acciones de AWS CloudFormation despliegue
<a name="tutorials-cloudformation-action"></a>

En este tutorial, utilizarás la AWS CodePipeline consola para crear una canalización con una acción de despliegue. Cuando se ejecuta la canalización, la plantilla crea una pila y también crea un archivo `outputs`. Los resultados generados por la plantilla de pila son las variables generadas por la AWS CloudFormation acción en CodePipeline.

En la acción en la que se crea la pila a partir de la plantilla, se designa un espacio de nombres variable. Acciones posteriores pueden consumir las variables producidas por el archivo `outputs`. En este ejemplo, se crea un conjunto de cambios basado en la `StackName` variable producida por la AWS CloudFormation acción. Después de una aprobación manual, ejecute el conjunto de cambios y, a continuación, cree una acción de eliminación de pila que elimine la pila en función de la variable `StackName`.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para los artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**Topics**
+ [

## Requisitos previos: crear un rol de AWS CloudFormation servicio y un repositorio CodeCommit
](#tutorials-cloudformation-action-prereq)
+ [

## Paso 1: Descargue, edite y cargue la plantilla de muestra AWS CloudFormation
](#tutorials-cloudformation-action-upload)
+ [

## Paso 2: Crear la canalización
](#tutorials-cloudformation-action-pipeline)
+ [

## Paso 3: Añade una acción CloudFormation de despliegue para crear el conjunto de cambios
](#tutorials-cloudformation-action-changeset)
+ [

## Paso 4: Agregar una acción de aprobación manual
](#tutorials-cloudformation-action-approval)
+ [

## Paso 5: Agrega una acción de CloudFormation despliegue para ejecutar el conjunto de cambios
](#tutorials-cloudformation-action-deployment)
+ [

## Paso 6: Añade una acción CloudFormation de despliegue para eliminar la pila
](#tutorials-cloudformation-action-delete)

## Requisitos previos: crear un rol de AWS CloudFormation servicio y un repositorio CodeCommit
<a name="tutorials-cloudformation-action-prereq"></a>

Debe disponer de lo siguiente:
+ Un CodeCommit repositorio. Puede usar el AWS CodeCommit repositorio en el que creó[Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ En este ejemplo se crea una pila de Amazon DocumentDB a partir de una plantilla. Debe usar AWS Identity and Access Management (IAM) para crear un rol de AWS CloudFormation servicio con los siguientes permisos para Amazon DocumentDB.

  ```
  "rds:DescribeDBClusters",
  "rds:CreateDBCluster",
  "rds:DeleteDBCluster",
  "rds:CreateDBInstance"
  ```

## Paso 1: Descargue, edite y cargue la plantilla de muestra AWS CloudFormation
<a name="tutorials-cloudformation-action-upload"></a>

Descarga el archivo de AWS CloudFormation plantilla de muestra y súbelo a tu CodeCommit repositorio.

1. Desplácese hasta la plantilla de ejemplo de su región. Por ejemplo, utilice la tabla de [https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack](https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack) para elegir la región y descargar la plantilla. Descargue la plantilla para un clúster de Amazon DocumentDB. El nombre de archivo es `documentdb_full_stack.yaml`.

1. Descomprima el archivo `documentdb_full_stack.yaml` y ábralo en un editor de texto. Realice los siguientes cambios.

   1. Para este ejemplo, agregue el siguiente parámetro `Purpose:` a la sección `Parameters` de la plantilla.

      ```
        Purpose:
          Type: String
          Default: testing
          AllowedValues:
            - testing
            - production
          Description: The purpose of this instance.
      ```

   1. Para este ejemplo, agregue el siguiente resultado `StackName` a la sección `Outputs:` de la plantilla.

      ```
        StackName:
          Value: !Ref AWS::StackName
      ```

1. Sube el archivo de plantilla a tu AWS CodeCommit repositorio. Debe cargar el archivo de plantilla descomprimido y editado en el directorio raíz de su repositorio. 

   Para usar la CodeCommit consola para cargar tus archivos: 

   1. Abre la CodeCommit consola y elige tu repositorio en la lista de **repositorios**.

   1. Elija **Add file (Añadir archivo)** y, a continuación, **Upload file (Cargar archivo)**. 

   1. Seleccione **Choose file (Elegir archivo)** y, a continuación, busque el archivo. Para confirmar el cambio, introduzca su nombre de usuario y la dirección de correo electrónico. Seleccione **Confirmar cambios**.

   Su archivo debe tener un aspecto similar a este en el nivel raíz de su repositorio:

   ```
   documentdb_full_stack.yaml
   ```

## Paso 2: Crear la canalización
<a name="tutorials-cloudformation-action-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una CodeCommit acción en la que el artefacto fuente es tu archivo de plantilla.
+ Una etapa de despliegue con una acción CloudFormation de despliegue.

A cada acción de las fases de origen e implementación creadas por el asistente se le asigna un espacio de nombres variable, `SourceVariables` y `DeployVariables`, respectivamente. Debido a que las acciones tienen asignado un espacio de nombres, las variables configuradas en este ejemplo están disponibles para las acciones posteriores. Para obtener más información, consulte [Referencia de variables](reference-variables.md).

**Para crear una canalización con el asistente**

1. Inicie sesión Consola de administración de AWS y abra la CodePipeline consola en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyCFNDeployPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Service role (Rol de servicio)**, realice una de las operaciones siguientes:
   + Elija **Nueva función de servicio** para CodePipeline permitir la creación de una función de servicio en IAM.
   + Elija **Existing service role (Rol de servicio existente)** En **Role name (Nombre del rol)**, elija el nombre del rol de servicio en la lista.

1. En **Artifact store (Almacén de artefactos)**: 

   1. Seleccione **Ubicación predeterminada** para utilizar con la canalización el almacén de artefactos predeterminado (por ejemplo, el bucket de Amazon S3 que se estableció como predeterminado) que esté en la región que seleccionó para la canalización.

   1. Elija **Ubicación personalizada** si ya dispone de un almacén de artefactos (por ejemplo, un bucket de artefactos de Amazon S3) en la misma región que la canalización.
**nota**  
Este no es el bucket de origen para su código fuente. Este es el almacén de artefactos de la canalización. Cada canalización debe tener su propio almacén de artefactos independiente, como un bucket de S3. Al crear o editar una canalización, debes tener un depósito de artefactos en la región de la canalización y un depósito de artefactos por AWS región en la que ejecutes una acción.  
Para obtener más información, consulte [Artefactos de entrada y salida](welcome-introducing-artifacts.md) y [CodePipeline referencia de estructura de tubería](reference-pipeline-structure.md).

   Elija **Siguiente**.

1. En **Paso 3: agregar la etapa de origen**: 

   1. En **Source provider (Proveedor de código fuente)**, elija **AWS CodeCommit**.

   1. En **Nombre del repositorio**, elige el nombre del CodeCommit repositorio en el que lo creaste. [Paso 1: Crea un CodeCommit repositorio](tutorials-simple-codecommit.md#codecommit-create-repository)

   1. En **Nombre de ramificación**, elija el nombre de la ramificación que incluye la última actualización del código.

   Tras seleccionar el nombre y la sucursal del repositorio, se muestra la regla de Amazon CloudWatch Events que se va a crear para esta canalización. 

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la etapa de despliegue**:

   1. En **Nombre de acción**, elija **Implementar**. En **Deploy provider (Proveedor de implementación)**, elija **CloudFormation**.

   1. En **Modo acción**, elija **Crear o actualizar una pila**.

   1. En **Nombre de la pila**, escriba un nombre para la pila. Este es el nombre de la pila que creará la plantilla.

   1. En **Nombre del archivo de salida**, escriba un nombre para el archivo de salida, como **outputs**. Este es el nombre del archivo que la acción creará después de que se cree la pila.

   1. Expanda **Advanced (Avanzadas)**. En **Sobrescritura de parámetros**, especifique las invalidaciones de la plantilla como pares de clave-valor. Por ejemplo, esta plantilla requiere las siguientes invalidaciones.

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "testing"}
      ```

      Si no especifica las invalidaciones, la plantilla crea una pila con valores predeterminados.

   1. Elija **Siguiente**.

   1. En el **paso 7: Revisar**, selecciona **Crear canalización**. Debería ver un diagrama con las etapas de la canalización. Permita que su canalización se ejecute. Su canalización de dos etapas está completa y lista para agregar las etapas adicionales.

## Paso 3: Añade una acción CloudFormation de despliegue para crear el conjunto de cambios
<a name="tutorials-cloudformation-action-changeset"></a>

Cree una siguiente acción en su proceso que permita CloudFormation crear el conjunto de cambios antes de la acción de aprobación manual.



1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Elija editar la canalización o continuar mostrando la canalización en el modo **Editar**.

1. Elija editar la etapa **Implementación**.

1. Agregue una acción de implementación que creará un conjunto de cambios para la pila que se creó en la acción anterior. Esta acción se añade después de la acción existente en la etapa.

   1. En **Nombre de la acción**, escriba **Change\$1Set**. En **Proveedor de acción**, seleccione **AWS CloudFormation **.

   1. En **Artefacto de entrada**, elija **SourceArtifact**.

   1. En **Action mode (Modo acción)**, elija **Create or replace a change set (Crear o reemplazar un conjunto de cambios)**.

   1. En **Nombre de la pila**, escriba la sintaxis de la variable como se muestra. Este es el nombre de la pila para la que se crea el conjunto de cambios, donde se asigna el espacio de nombres predeterminado `DeployVariables` a la acción.

      ```
      #{DeployVariables.StackName}
      ```

   1. En **Nombre del conjunto de cambios**, escriba el nombre del conjunto de cambios.

      ```
      my-changeset
      ```

   1. En **Sobrescritura de parámetros**, cambie el parámetro `Purpose` de `testing` a `production`.

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "production"}
      ```

   1. Elija **Listo** para guardar la acción.

## Paso 4: Agregar una acción de aprobación manual
<a name="tutorials-cloudformation-action-approval"></a>

Cree una acción de aprobación manual en la canalización.



1. Elija editar la canalización o continuar mostrando la canalización en el modo **Editar**.

1. Elija editar la etapa **Implementación**.

1. Agregue una acción de aprobación manual después de la acción de implementación que crea el conjunto de cambios. Esta acción le permite verificar el conjunto de cambios de recursos creado CloudFormation antes de que la canalización ejecute el conjunto de cambios.

## Paso 5: Agrega una acción de CloudFormation despliegue para ejecutar el conjunto de cambios
<a name="tutorials-cloudformation-action-deployment"></a>

Cree una acción siguiente en su proceso que CloudFormation permita ejecutar el conjunto de cambios después de la acción de aprobación manual.



1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Elija editar la canalización o continuar mostrando la canalización en el modo **Editar**.

1. Elija editar la etapa **Implementación**.

1. Agregue una acción de implementación que ejecutará el conjunto de cambios aprobado en la acción manual anterior:

   1. En **Nombre de la acción**, escriba **Execute\$1Change\$1Set**. En **Proveedor de acción**, seleccione **AWS CloudFormation**.

   1. En **Artefacto de entrada**, elija **SourceArtifact**.

   1. En **Action mode (Modo de acción)**, elija **Execute a change set (Ejecutar un conjunto de cambios)**.

   1. En **Nombre de la pila**, escriba la sintaxis de la variable como se muestra. Este es el nombre de la pila para la que se crea el conjunto de cambios.

      ```
      #{DeployVariables.StackName}
      ```

   1. En **Nombre del conjunto de cambios**, escriba el nombre del conjunto de cambios que creó en la acción anterior.

      ```
      my-changeset
      ```

   1. Elija **Listo** para guardar la acción.

   1. Continúe la ejecución de la canalización.

## Paso 6: Añade una acción CloudFormation de despliegue para eliminar la pila
<a name="tutorials-cloudformation-action-delete"></a>

Crea una acción final en tu canalización que permita CloudFormation obtener el nombre de la pila a partir de la variable del archivo de resultados y eliminar la pila.



1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Elija esta opción para editar la canalización.

1. Elija editar la etapa **Implementación**.

1. Agregue una acción de implementación que eliminará la pila:

   1. En **Nombre de la acción**, elija **DeleteStack**. En **Deploy provider (Proveedor de implementación)**, elija **CloudFormation**.

   1. En **Modo acción**, elija **Eliminar una pila**.

   1. En **Nombre de la pila**, escriba la sintaxis de la variable como se muestra. Este es el nombre de la pila que la acción eliminará.

   1. Elija **Listo** para guardar la acción.

   1. Elija **Guardar** para guardar la canalización.

   La canalización se ejecuta cuando se guarda.

# Tutorial: Implementación estándar de Amazon ECS con CodePipeline
<a name="ecs-cd-pipeline"></a>

Este tutorial le ayuda a crear una canalización de despliegue end-to-end continuo (CD) completa con Amazon ECS con CodePipeline.

**importante**  
Como parte de la creación de una canalización en la consola, para los artefactos se utilizará un depósito de artefactos CodePipeline de S3. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
Este tutorial es para la acción de implementación estándar de Amazon ECS para CodePipeline. Para ver un tutorial que utiliza Amazon ECS para realizar una acción de implementación CodeDeploy azul/verde CodePipeline, consulte. [Tutorial: Creación de una canalización con una fuente y ECS-to-CodeDeploy una implementación de Amazon ECR](tutorials-ecs-ecr-codedeploy.md)

**nota**  
Este tutorial es para la acción de implementación estándar de Amazon ECS CodePipeline con una acción de origen. Para ver un tutorial en el que se utiliza la acción de ECSstandard despliegue de Amazon junto con la acción de ECRBuild AndPublish creación CodePipeline para insertar la imagen, consulte[Tutorial: Cree e inserte una imagen de Docker en Amazon ECR con CodePipeline (tipo V2)](tutorials-ecr-build-publish.md).

## Requisitos previos
<a name="ecs-cd-prereqs"></a>

Para poder usar este tutorial para crear su propia canalización de implementación continua debe tener instalados algunos recursos. Esto es lo que necesita para empezar: 

**nota**  
Todos estos recursos deben crearse en la misma AWS región.
+ Un repositorio de control de código fuente (se utiliza en este tutorial CodeCommit) con el Dockerfile y el código fuente de la aplicación. Para obtener más información, consulte [Crear un CodeCommit repositorio](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html) en la Guía del *AWS CodeCommit usuario*.
+ Un repositorio de imágenes de Docker (este tutorial utiliza Amazon ECR) que contenga una imagen que haya creado desde el origen de Dockerfile y de la aplicación. Para obtener más información, consulte [Creación de un repositorio](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) e [Inserción de una imagen](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) en la *Guía del usuario de Amazon Elastic Container Registry*.
+ Una definición de tarea de Amazon ECS que haga referencia a la imagen de Docker alojada en su repositorio de imágenes. Para obtener más información, consulte [Creación de una definición de tarea](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*.
**importante**  
La acción de despliegue estándar de Amazon ECS CodePipeline crea su propia revisión de la definición de la tarea en función de la revisión utilizada por el servicio Amazon ECS. Si crea nuevas revisiones para la definición de la tarea sin actualizar el servicio Amazon ECS, la acción de implementación ignorará esas revisiones.

  A continuación, se muestra un ejemplo de definición de tarea utilizada en este tutorial. El valor que utiliza para `name` y `family` se utilizará en el siguiente paso del archivo de especificaciones de compilación.

  ```
  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }
  ```
+ Un clúster de Amazon ECS que ejecute un servicio que utilice la definición de tarea mencionada anteriormente. Para obtener más información, consulte [Creación de un clúster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) y [Creación de un servicio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) en la *Guía para desarrolladores de Amazon Elastic Container Service*.

Una vez satisfechos estos requisitos previos, puede continuar con el tutorial y crear su canalización de implementación continua.

## Paso 1: Añadir un archivo de especificación de compilación a su repositorio de código fuente
<a name="cd-buildspec"></a>

Este tutorial se utiliza CodeBuild para crear su imagen de Docker y enviarla a Amazon ECR. Añada un archivo `buildspec.yml` al repositorio del código fuente que indique a CodeBuild cómo hacerlo. La siguiente especificación de compilación de ejemplo hace lo siguiente:
+ Etapa previa a la compilación:
  + Inicie sesión en Amazon ECR.
  + Establece el URI del repositorio en la imagen de ECR y añade una etiqueta de imagen con los siete primeros caracteres del ID de confirmación de Git del código fuente.
+ Etapa de compilación:
  + Crea la imagen de Docker y etiqueta la imagen como `latest` y con el ID de confirmación de Git.
+ Etapa posterior a la compilación:
  + Inserta la imagen en el repositorio de ECR con ambas etiquetas.
  + Escribe un archivo denominado `imagedefinitions.json` en la raíz de la compilación con el nombre del contenedor del servicio de Amazon ECS y la imagen y la etiqueta. La etapa de implementación de la canalización de implementación continua utiliza esta información para crear una nueva revisión de la definición de tarea del servicio y, a continuación, actualiza el servicio para usar la nueva definición de tarea. El archivo `imagedefinitions.json` es necesario para el proceso de trabajo de ECS.

Pegue este texto de ejemplo para crear el archivo `buildspec.yml` y sustituya los valores de la imagen y la definición de la tarea. En este texto, se utiliza el ID de cuenta de ejemplo 111122223333.

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json
```

La especificación de compilación se ha creado para el siguiente ejemplo de definición de tarea proporcionada en [Requisitos previos](#ecs-cd-prereqs), usada por el servicio de Amazon ECS para este tutorial. El valor de `REPOSITORY_URI` se corresponde con el repositorio `image` (sin etiquetas de imagen) y el valor `hello-world` situado cerca del final del archivo se corresponde con el nombre de contenedor de la definición de tarea. 

**Para añadir un archivo `buildspec.yml` a su repositorio de código fuente**

1. Abra un editor de texto y copie y pegue la especificación de compilación anterior en un nuevo archivo.

1. Sustituya el valor de `REPOSITORY_URI` (`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`) por el URI de su repositorio de Amazon ECR (sin etiquetas de imagen) para la imagen de Docker. Sustituya `hello-world` por el nombre de contenedor de la definición de tarea del servicio que hace referencia a la imagen de Docker.

1. Confirme la operación e inserte el archivo `buildspec.yml` en el repositorio de código fuente.

   1. Añada el archivo.

      ```
      git add .
      ```

   1. Valide el cambio con.

      ```
      git commit -m "Adding build specification."
      ```

   1. Envíe la confirmación.

      ```
      git push
      ```

## Paso 2: Crear la canalización de implementación continua
<a name="pipeline-wizard"></a>

Utilice el CodePipeline asistente para crear las etapas de la canalización y conectar el repositorio de origen a su servicio de ECS.

**Para crear la canalización**

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Welcome**, elija **Create pipeline**. 

   Si es la primera vez que la utiliza CodePipeline, aparecerá una página de introducción en lugar de **Bienvenida**. Seleccione **Get Started Now**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En el **paso 2: elección de la configuración de la canalización**, en **Nombre de la canalización**, escriba un nombre para su canalización. En este tutorial, el nombre de la canalización es **hello-world**.

1. En **Tipo de canalización**, mantenga la selección predeterminada en **V2**. Los tipos de canalización difieren en características y precio. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md). Elija **Siguiente**.

1. En la página **Paso 3: Añadir la fase de origen**, seleccione **Proveedor de código fuente ** AWS CodeCommit****.

   1. En **Repository name (Nombre del repositorio)**, elija el nombre del repositorio de CodeCommit que desea utilizar como ubicación de origen para la canalización.

   1. En **Branch name (Nombre de ramificación)**, elija la ramificación que desea usar y seleccione **Next (Siguiente)**.

1. En la página **Paso 4: Agregar la etapa de compilación**, en **Proveedor de compilación **AWS CodeBuild****, elija y, a continuación, elija **Crear proyecto**.

   1. En **Project name**, elija un nombre exclusivo para su proyecto de compilación. En este tutorial, el nombre del proyecto es **hello-world**.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**.

   1. En **Operating system (Sistema operativo)**, elija **Amazon Linux 2**.

   1. En **Runtime(s) (Tiempo de ejecución)**, elija **Standard (Estándar)**.

   1. Para **Imagen**, elija **`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**.

   1. En **Image version (Versión de imagen)** y **Environment type (Tipo de entorno)**, utilice los valores predeterminados.

   1. Seleccione **Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Habilite este indicador si desea compilar imágenes de Docker o que sus compilaciones tengan privilegios elevados)**.

   1. Deseleccione los **CloudWatch registros**. Puede que tengas que expandir **Avanzado**.

   1. Selecciona **Continuar a. CodePipeline**

   1. Elija **Siguiente**.
**nota**  
El asistente crea un rol de CodeBuild servicio para tu proyecto de compilación, denominado **codebuild- *build-project-name* -service-role**. Anote este nombre de rol, ya que le añadirá los permisos de Amazon ECR más adelante.

1. En la página **Paso 5: Añadir fase de despliegue**, para **Proveedor de despliegue**, elija **Amazon ECS**.

   1. En **Nombre del clúster**, elija el clúster de en el que se ejecuta el servicio. En este tutorial, el clúster es **default**.

   1. En **Service name (Nombre de servicio)**, elija el servicio que desea actualizar y seleccione **Next (Siguiente)**. En este tutorial, el nombre del servicio es **hello-world**.

1. En la página **Step 6: Review**, revise la configuración de la canalización y elija **Create pipeline** para crear la canalización.
**nota**  
Ahora que se ha creado la canalización, intenta ejecutarse a través de las diferentes etapas de canalización. Sin embargo, el CodeBuild rol predeterminado creado por el asistente no tiene permisos para ejecutar todos los comandos contenidos en el `buildspec.yml` archivo, por lo que se produce un error en la etapa de compilación. En la siguiente sección se añaden los permisos para la etapa de compilación.

## Paso 3: Añadir permisos de Amazon ECR al rol CodeBuild
<a name="code-build-perms"></a>

El CodePipeline asistente creó un rol de IAM para el proyecto de compilación, denominado CodeBuild **codebuild** - -service-role. *build-project-name* **En este tutorial, el nombre es -role. codebuild-hello-world-service** Dado que el archivo `buildspec.yml` realiza llamadas a operaciones de la API de Amazon ECR, el rol debe tener una política que conceda permisos para realizar estas llamadas a Amazon ECR. El siguiente procedimiento le ayuda a asociar los permisos adecuados al rol.

**Para añadir permisos de Amazon ECR al rol CodeBuild**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación izquierdo, elija **Roles**.

1. En el cuadro de búsqueda, escriba **codebuild-** y elija el rol que creó el CodePipeline asistente. En este tutorial, el nombre del rol es **codebuild-hello-world-service-role**.

1. En la página **Summary (Resumen)**, elija **Attach policies (Asociar políticas)**.

1. Selecciona la casilla situada a la izquierda de la EC2 ContainerRegistryPowerUser política de **Amazon** y selecciona **Adjuntar política**.

## Paso 4: Probar la canalización
<a name="commit-change"></a>

Su proceso debe tener todo lo necesario para ejecutar un despliegue AWS continuo end-to-end nativo. Ahora, pruebe su funcionalidad enviando un cambio de código al repositorio de código fuente.

**Para probar la canalización**

1. Realice una modificación del código en el repositorio de código fuente configurado, valide y envíe el cambio.

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleccione su canalización de la lista.

1. Vea el progreso en la canalización a través de sus etapas. Su canalización debería completarse y el servicio de Amazon ECS debería ejecutar la imagen de Docker que se creó a partir de la modificación del código.

# Tutorial: Creación de una canalización con una fuente y ECS-to-CodeDeploy una implementación de Amazon ECR
<a name="tutorials-ecs-ecr-codedeploy"></a>

En este tutorial, configurará una canalización AWS CodePipeline que despliegue aplicaciones de contenedores mediante una blue/green implementación que admita imágenes de Docker. En una implementación blue/green, puede lanzar la versión nueva de la aplicación junto con la versión antigua y probar la versión nueva antes de redirigir el tráfico. También puede monitorizar el proceso de implementación y revertirlo rápidamente si hay algún problema.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente para crear artefactos. CodePipeline (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
Este tutorial es para la acción de implementación de Amazon ECS a CodeDeploy azul/verde. CodePipeline Para ver un tutorial que utiliza la acción de despliegue estándar de Amazon ECS en CodePipeline, consulte[Tutorial: Implementación estándar de Amazon ECS con CodePipeline](ecs-cd-pipeline.md).

La canalización completada detecta los cambios en la imagen, que se almacena en un repositorio de imágenes como Amazon ECR y se utiliza CodeDeploy para enrutar e implementar el tráfico a un clúster y un balanceador de carga de Amazon ECS. CodeDeploy utiliza un detector para redirigir el tráfico al puerto del contenedor actualizado especificado en el archivo. AppSpec Para obtener información sobre cómo se utilizan el balanceador de carga, el agente de escucha de producción, los grupos objetivo y la aplicación de Amazon ECS en una blue/green implementación, consulte el [Tutorial: Implementación de un servicio de Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html).

La canalización también está configurada para usar una ubicación de origen, por ejemplo CodeCommit, donde se almacena la definición de tareas de Amazon ECS. En este tutorial, configurará cada uno de estos AWS recursos y, a continuación, creará su canalización con etapas que contengan acciones para cada recurso.

La canalización de entrega continua compilará e implementará automáticamente las imágenes de contenedor cada vez que cambie el código fuente o se cargue una nueva imagen base en Amazon ECR.

Este flujo utiliza los siguientes artefactos:
+ Un archivo de imagen de Docker que especifica el nombre del contenedor y el URI de su repositorio de imágenes de Amazon ECR.
+ Una definición de tareas de Amazon ECS que muestra el nombre de la imagen de Docker, el nombre del contenedor, el nombre del servicio de Amazon ECS y la configuración del equilibrador de carga.
+  CodeDeploy AppSpec Archivo que especifica el nombre del archivo de definición de tareas de Amazon ECS, el nombre del contenedor de la aplicación actualizada y el puerto del contenedor donde se CodeDeploy redirige el tráfico de producción. También puede especificar la configuración de red opcional y funciones de Lambda que puede ejecutar durante enlaces de eventos del ciclo de vida de implementación.

**nota**  
Cuando se confirma un cambio en el repositorio de imágenes de Amazon ECR, la acción de origen de la canalización crea un archivo `imageDetail.json` para dicha confirmación. Para obtener más información sobre el archivo `imageDetail.json`, consulte [Archivo ImageDetail.json para las acciones de implementación de Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).

Al crear o editar la canalización y actualizar o especificar artefactos de código fuente para la etapa de implementación, asegúrese de que apunte a los artefactos de código fuente con el nombre y la versión más recientes que desee utilizar. Después de configurar la canalización, a medida que realiza cambios en su imagen o definición de tareas, es posible que tenga que actualizar los archivos de artefactos de código fuente en sus repositorios y, a continuación, editar la etapa de implementación en la canalización.

**Topics**
+ [

## Requisitos previos
](#tutorials-ecs-ecr-codedeploy-prereq)
+ [

## Paso 1: Crear una imagen y enviarla al repositorio de Amazon ECR
](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [

## Paso 2: Cree los archivos AppSpec fuente y de definición de tareas y envíelos a un repositorio CodeCommit
](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [

## Paso 3: Crear el equilibrador de carga de aplicaciones y los grupos de destino
](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [

## Paso 4: Crear un clúster y un servicio de Amazon ECS
](#tutorials-ecs-ecr-codedeploy-cluster)
+ [

## Paso 5: Cree su grupo de CodeDeploy aplicaciones y despliegues (plataforma informática ECS)
](#tutorials-ecs-ecr-codedeploy-deployment)
+ [

## Paso 6: Crear la canalización
](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [

## Paso 7: Realizar un cambio en la canalización y verificar la implementación
](#tutorials-ecs-ecr-codedeploy-update)

## Requisitos previos
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

Debe de haber creado los siguientes recursos:
+ Un CodeCommit repositorio. Puedes usar el AWS CodeCommit repositorio en el que lo creaste[Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ Lance una instancia de Linux de Amazon EC2 e instale Docker para crear una imagen, tal y como se muestra en este tutorial. Puede omitir este requisito previo si ya dispone de una imagen que desea utilizar.

## Paso 1: Crear una imagen y enviarla al repositorio de Amazon ECR
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

En esta sección, se utiliza Docker para crear una imagen y, a continuación, se utiliza AWS CLI para crear un repositorio de Amazon ECR y enviar la imagen al repositorio.

**nota**  
Puede omitir este paso si ya dispone de una imagen que desea utilizar.

**Para crear una imagen**

1. Inicie sesión en la instancia de Linux en la que se ha instalado Docker.

   Despliegue una imagen de `nginx`. Este comando proporciona la imagen de `nginx:latest`:

   ```
   docker pull nginx
   ```

1. Ejecute **docker images**. Debería ver la imagen en la lista.

   ```
   docker images
   ```

**Para crear un repositorio de Amazon ECR y enviar la imagen**

1. Cree un repositorio de Amazon ECR para almacenar la imagen . Anote el `repositoryUri` en la salida.

   ```
   aws ecr create-repository --repository-name nginx
   ```

   Salida:

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. Etiquete la imagen con el valor de `repositoryUri` del paso anterior.

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. Ejecute el comando **aws ecr get-login-password**, tal como se muestra en este ejemplo de la región de `us-west-2` y el ID de cuenta 111122223333.

   ```
   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx
   ```

1. Envíe la imagen a Amazon ECR utilizando el `repositoryUri` del paso anterior.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## Paso 2: Cree los archivos AppSpec fuente y de definición de tareas y envíelos a un repositorio CodeCommit
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

En esta sección, debe crear un archivo JSON de definición de tareas y registrarlo en Amazon ECS. A continuación, crea un AppSpec archivo CodeDeploy y utiliza su cliente Git para enviar los archivos a su CodeCommit repositorio.

**Para crear una definición de tareas para la imagen**

1. Cree un archivo denominado `taskdef.json` con el siguiente contenido. En `image`, introduzca el nombre de su imagen, por ejemplo nginx. Este valor se actualiza cuando se ejecuta la canalización.
**nota**  
Asegúrese de que el rol de ejecución especificado en la definición de la tarea contiene `AmazonECSTaskExecutionRolePolicy`. Para obtener más información, consulte [Rol de IAM de ejecución de tareas de Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) en la *Guía para desarrolladores de Amazon ECS*.

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

1. Registre la definición de tareas con el archivo `taskdef.json`.

   ```
   aws ecs register-task-definition --cli-input-json file://taskdef.json
   ```

1. Después de registrar la definición de tareas, edite el archivo para eliminar el nombre de la imagen e incluya el texto del marcador de posición `<IMAGE1_NAME>` en el campo de la imagen.

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

**Para crear un AppSpec archivo**
+ El AppSpec archivo se utiliza para CodeDeploy las implementaciones. El archivo, que incluye campos opcionales, utiliza este formato:

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"
  ```

  Para obtener más información sobre el AppSpec archivo, incluidos ejemplos, consulte la [referencia CodeDeploy AppSpec del archivo](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html).

  Cree un archivo denominado `appspec.yaml` con el siguiente contenido. Para `TaskDefinition`, no cambie el texto del marcador de posición `<TASK_DEFINITION>`. Este valor se actualiza cuando se ejecuta la canalización.

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**Para enviar archivos a tu CodeCommit repositorio**

1. Envía o sube los archivos a tu CodeCommit repositorio. Estos archivos son el artefacto de código fuente creado por el asistente **Create Pipeline (Crear canalización)** para la acción de implementación en CodePipeline. Sus archivos deberían ser parecidos a estos en su directorio local:

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. Elija el método que desea usar para cargar los archivos:

   1. Para utilizar la línea de comandos de Git desde un repositorio clonado en el equipo local:

      1. Cambie los directorios a su repositorio local:

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. Ejecute el siguiente comando para preparar todos los archivos de una vez:

         ```
         git add -A
         ```

      1. Ejecute el siguiente comando para confirmar los archivos con un mensaje de confirmación:

         ```
         git commit -m "Added task definition files"
         ```

      1. Ejecuta el siguiente comando para enviar los archivos de tu repositorio local a tu CodeCommit repositorio:

         ```
         git push
         ```

   1. Para usar la CodeCommit consola para cargar tus archivos:

      1. Abre la CodeCommit consola y elige tu repositorio en la lista de **repositorios**.

      1. Elija **Add file (Añadir archivo)** y, a continuación, **Upload file (Cargar archivo)**.

      1. Elija **Choose file (Elegir archivo)** y luego busque el archivo. Para confirmar el cambio, introduzca su nombre de usuario y la dirección de correo electrónico. Seleccione **Confirmar cambios**.

      1. Repita este paso para cada archivo que desee cargar.

## Paso 3: Crear el equilibrador de carga de aplicaciones y los grupos de destino
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

En esta sección, va a crear un Equilibrador de carga de aplicación de Amazon EC2. Más tarde, utilizará los nombres de subred y los valores del grupo de destino que se crean con el equilibrador de carga al crear el servicio de Amazon ECS. Puede crear un equilibrador de carga de aplicación o un equilibrador de carga de red. El equilibrador de carga debe utilizar una VPC con dos subredes públicas en diferentes zonas de disponibilidad. En estos pasos, confirmará la VPC predeterminada, creará un equilibrador de carga y, a continuación, creará dos grupos de destino para el equilibrador de carga. Para obtener más información, consulte [Grupos de destino de los Network Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html).

**Para verificar la VPC predeterminada y las subredes públicas**

1. Inicie sesión en la consola de Amazon VPC Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)

1. Compruebe la VPC predeterminada que se va a utilizar. En el panel de navegación, elija **Su. VPCs** Fíjese en qué VPC muestra **Yes (Sí)** en la columna **Default VPC (VPC predeterminada)**. Esta es la VPC predeterminada. Contiene subredes predeterminadas para que pueda seleccionarlas.

1. Elija **Subnets (Subredes)**. Elija dos subredes que muestren **Yes (Sí)** en la columna **Default subnet (Subred predeterminada)**.
**nota**  
Anote su subred IDs. Los necesitará más adelante en este tutorial.

1. Elija las subredes y, a continuación, elija la pestaña **Description (Descripción)**. Compruebe que las subredes que desea utilizar se encuentran en diferentes zonas de disponibilidad.

1. Elija las subredes y, a continuación, elija la pestaña **Route Table (Tabla de ruteo)**. Para verificar que cada subred que desea utilizar es una subred pública, confirme que se haya incluido una fila con el gateway en la tabla de ruteo.

**Para crear un Equilibrador de carga de aplicación de Amazon EC2**

1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

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

1. Elija **Crear equilibrador de carga**.

1. Elija **Equilibrador de carga de aplicación** y a continuación, **Crear**.

1. En **Nombre**, especifique el nombre del equilibrador de carga.

1. En **Scheme (Esquema)**, elija **Internet-facing (Expuesto a Internet)**.

1. En **IP address type (Tipo de dirección IP)**, elija **ipv4**.

1. Configure dos puertos de agentes de escucha para su equilibrador de carga:

   1. En **Protocolo de equilibrador de carga**, elija **HTTP**. En **Puerto del equilibrador de carga**, escriba **80**.

   1. Elija **Agregar oyente**.

   1. En **Protocolo de equilibrador de carga** del segundo agente de escucha, elija **HTTP**. En **Puerto del equilibrador de carga**, escriba **8080**.

1. En **Availability Zones (Zonas de disponibilidad)**, en **VPC**, elija la VPC predeterminada. A continuación, seleccione las dos subredes predeterminadas que desea utilizar.

1. Elija **Next: Configure Security Settings** (Siguiente: Establecer la configuración de seguridad).

1. Elija **Next: Configure Security Groups (Siguiente: configurar grupos de seguridad)**.

1. Elija **Select an existing security group (Seleccionar un grupo de seguridad existente)** y tome nota del ID del grupo de seguridad.

1. Elija **Next: Configure Routing (Siguiente: Configuración del enrutamiento)**.

1. En **Target group (Grupo de destino)**, elija **New target group (Nuevo grupo de destino)** y configure su primer grupo de destino:

   1. En **Name (Nombre)**, introduzca un nombre de grupo de destino (por ejemplo, **target-group-1**).

   1. En **Target type (Tipo de destino)**, elija **IP**.

   1. En **Protocol (Protocolo)**, elija **HTTP**. En **Port (Puerto)**, introduzca **80**.

   1. Elija **Next: Register Targets (Siguiente: Registrar destinos)**.

1. Elija **Next: Review (Siguiente: análisis)** y, a continuación, seleccione **Create (Crear)**.

**Para crear un segundo grupo de destino para el equilibrador de carga**

1. Después de aprovisionar el equilibrador de carga, abra la consola de Amazon EC2. En el panel de navegación, elija **Target Groups**.

1. Elija **Crear grupo de destino**.

1. En **Name (Nombre)**, introduzca un nombre de grupo de destino (por ejemplo, **target-group-2**).

1. En **Target type (Tipo de destino)**, elija **IP**.

1. En **Protocol (Protocolo)**, elija **HTTP**. En **Port (Puerto)**, introduzca **8080**.

1. En **VPC**, elija la VPC predeterminada.

1. Seleccione **Crear**.
**nota**  
Para que la implementación se ejecute, debe tener dos grupos de destino creados para el equilibrador de carga. Solo tiene que tomar nota del ARN de su primer grupo de destino. Este ARN se utiliza en el archivo JSON de `create-service` en el siguiente paso.

**Para actualizar el equilibrador de carga para incluir el segundo grupo de destino**

1. Abra la consola de Amazon EC2. En el panel de navegación, seleccione **Equilibradores de carga**.

1. Elija el equilibrador de carga y, a continuación, elija la pestaña **Agentes de escucha**. Elija el agente de escucha con el puerto 8080 y, a continuación, elija **Edit (Editar)**.

1. Elija el icono del lápiz que aparece junto a **Forward to (Reenviar a)**. Elija su segundo grupo de destino y, a continuación, elija la marca de verificación. Elija **Update (Actualizar)** para guardar las actualizaciones.

## Paso 4: Crear un clúster y un servicio de Amazon ECS
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

En esta sección, creará un clúster y un servicio de Amazon ECS que CodeDeploy enrute el tráfico durante la implementación (a un clúster de Amazon ECS en lugar de a instancias de EC2). Para crear el servicio de Amazon ECS, debe utilizar los nombres de las subredes, el grupo de seguridad y el valor del grupo de destino que creó con el equilibrador de carga para crear el servicio.

**nota**  
Cuando sigue estos pasos para crear su clúster de Amazon ECS, utiliza la plantilla de clúster **solo para redes**, que aprovisiona los AWS contenedores Fargate. AWS Fargate es una tecnología que administra su infraestructura de instancias de contenedores por usted. No necesita seleccionar o crear de forma manual instancias de Amazon EC2 para su clúster de Amazon ECS.

**Creación de un clúster de Amazon ECS**

1. Abra la consola clásica de Amazon ECS en [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. En el panel de navegación, seleccione **Clusters (Clústeres)**.

1. Elija **Create cluster**.

1. Elija la plantilla de clúster **Solo redes** que utiliza AWS Fargate y, a continuación, elija **Paso siguiente**.

1. Escriba un nombre de clúster en la página **Configure cluster (Configurar el clúster)**, Puede añadir una etiqueta opcional al recurso. Seleccione **Crear**.

**Para crear un servicio de Amazon ECS**

Úselo AWS CLI para crear su servicio en Amazon ECS.

1. Cree un archivo JSON y asígnele el nombre `create-service.json`. Pegue lo siguiente en el archivo JSON.

   En el campo `taskDefinition`, cuando se registra una definición de tarea en Amazon ECS, se le asigna una familia. Esto es similar a un nombre para las distintas versiones de la definición de tarea, que se especifican con un número de revisión. En este ejemplo, utilice `ecs-demo:1` con la familia y el número de revisión del archivo. Utilice los nombres de subred, el grupo de seguridad y el valor del grupo de destino que creó con el equilibrador de carga en el [Paso 3: Crear el equilibrador de carga de aplicaciones y los grupos de destino](#tutorials-ecs-ecr-codedeploy-loadbal).
**nota**  
Debe incluir el ARN del grupo de destino en este archivo. Abra la consola de Amazon EC2 y, desde el panel de navegación, en **LOAD BALANCING (equilibrador de carga)**, elija **Grupos de destino**. Elija su primer grupo de destino. Copie el ARN desde la pestaña **Description (Descripción)**.

   ```
   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }
   ```

1. Ejecute el comando **create-service** y especifique el archivo JSON:
**importante**  
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.

   En este ejemplo, se crea un servicio denominado `my-service`.
**nota**  
Este comando de ejemplo crea un servicio denominado my-service. Si ya tiene un servicio con este nombre, el comando devuelve un error.

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   La salida devuelve los campos de descripción de su servicio.

1. Ejecute el comando **describe-services** para comprobar que se ha creado el servicio.

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## Paso 5: Cree su grupo de CodeDeploy aplicaciones y despliegues (plataforma informática ECS)
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

Al crear una CodeDeploy aplicación y un grupo de implementaciones para la plataforma informática Amazon ECS, la aplicación se utiliza durante una implementación para hacer referencia al grupo de implementación, los grupos de destino, los oyentes y el comportamiento de redireccionamiento del tráfico correctos.

**Para crear una aplicación CodeDeploy**

1. Abra la CodeDeploy consola y elija **Crear aplicación**.

1. En **Application name (Nombre de aplicación)**, escriba el nombre que desea utilizar.

1. En **Compute platform (Plataforma de computación)**, elija **Amazon ECS**.

1. Elija **Creación de aplicación**.

**Para crear un grupo CodeDeploy de despliegue**

1. En la página de la aplicación, en la pestaña **Deployment groups (Grupos de implementaciones)**, elija **Create deployment group (Crear grupo de implementaciones)**.

1. En **Nombre de grupo de implementación**, introduzca un nombre que describa el grupo de implementación.

1. En **Función de servicio**, elija una función de servicio que conceda CodeDeploy acceso a Amazon ECS. Para crear un nuevo rol de servicio, siga estos pasos:

   1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

   1. En el panel de la consola, elija **Roles**.

   1. Elija **Crear rol**.

   1. En **Seleccionar el tipo de entidad de confianza**, seleccione **Servicio de AWS**. En **Elija un caso de uso**, seleccione **CodeDeploy**. En **Selecciona tu caso de uso**, selecciona **CodeDeploy - ECS**. Elija **Siguiente: permisos**. La política administrada `AWSCodeDeployRoleForECS` ya está asociada al rol.

   1. Elija **Next: Tags (Siguiente: Etiquetas)** y **Next: Review (Siguiente: Revisar)**.

   1. Especifique un nombre para el rol (por ejemplo, **CodeDeployECSRole**) y elija **Create role (Crear rol)**.

1. En **Configuración de entorno**, elija el nombre del clúster y el nombre del servicio de Amazon ECS.

1. En **Equilibradores de carga)**, seleccione el nombre del equilibrador de carga que sirve el tráfico a su servicio de Amazon ECS.

1. En **Production listener port (Puerto del agente de escucha de producción)**, elija el puerto y el protocolo del agente de escucha que sirve el tráfico de producción a su servicio ECS de Amazon. En **Test listener port (Puerto de agente de escucha de prueba)**, elija y el puerto y el protocolo del agente de escucha de prueba.

1. En **Target group 1 name (Nombre de grupo de destino 1)** y **Target group 2 name (Nombre de grupo de destino 2)**, elija los grupos de destino utilizados para dirigir el tráfico durante su implementación. Asegúrese de que se trata de los grupos de destino que ha creado para el equilibrador de carga.

1. Elija **Redirigir el tráfico inmediatamente** para determinar cuánto tiempo debe transcurrir después de una implementación correcta antes de redirigir el tráfico hacia la tarea de Amazon ECS actualizada.

1. Elija **Crear grupo de implementación**.

## Paso 6: Crear la canalización
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una CodeCommit acción en la que los artefactos de origen son la definición de la tarea y el AppSpec archivo.
+ Una etapa de origen con una acción de origen de Amazon ECR donde el artefacto de código de fuente es el archivo de imagen.
+ Etapa de despliegue con una acción de despliegue de Amazon ECS en la que el despliegue se ejecuta con una CodeDeploy aplicación y un grupo de despliegues.

**Para crear una canalización de dos etapas con el asistente**

1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyImagePipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **AWS CodeCommit**. En **Repository name (Nombre de repositorio)**, elija el nombre del repositorio de CodeCommit que ha creado en [Paso 1: Crea un CodeCommit repositorio](tutorials-simple-codecommit.md#codecommit-create-repository). En **Nombre de ramificación**, elija el nombre de la ramificación que incluye la última actualización del código.

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la etapa de despliegue**:

   1. En **Deploy provider (Proveedor de implementación)**, elija **Amazon ECS (Blue/Green) (Amazon ECS (azul/verde))**. En **Application name (Nombre de aplicación)**, elija el nombre de la aplicación en la lista como, por ejemplo, `codedeployapp`. En **Deployment group (Grupo de implementación)**, escriba o elija el nombre de un grupo de implementaciones en la lista como, por ejemplo, `codedeploydeplgroup`.

       
**nota**  
El nombre "Deploy" es el nombre predeterminado de la etapa creada en el paso **Step 4: Deploy (Paso 4: Implementar)** y "Source" es el nombre que recibe la primera etapa de la canalización.

   1. En la **definición de tareas de Amazon ECS**, elija **SourceArtifact**. En el campo, introduzca **taskdef.json**.

   1. En **AWS CodeDeploy AppSpec Archivo**, elija **SourceArtifact**. En el campo, introduzca **appspec.yaml**.
**nota**  
En este momento, no rellene ninguna información en **Dynamically update task definition image (Actualizar dinámicamente imagen de definición de tareas)**.

   1. Elija **Siguiente**.

1. En el **paso 7: Revisar**, revise la información y, a continuación, elija **Crear canalización**.

**Para añadir una acción de origen de Amazon ECR a la canalización**

Vea la canalización y añada una acción de origen de Amazon ECR a la canalización.

1. Elija la canalización. En la parte superior izquierda, elija **Editar**.

1. En la etapa de código fuente, elija **Edit stage (Editar etapa)**.

1. Para añadir una acción paralela, selecciona **\$1 Añadir acción** junto a la acción CodeCommit de origen.

1. En **Nombre de la acción**, escriba un nombre (por ejemplo, **Image**).

1. En **Action provider (Proveedor de acción)**, elija **Amazon ECR**.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/ECR-source-action.png)

1. En **Nombre de repositorio**, elija el nombre de su repositorio de Amazon ECR.

1. En **Image tag (Etiqueta de imagen)**, especifique el nombre de la imagen y la versión, si es diferente de la última.

1. En **Output artifacts (Artefactos de salida)**, elija el valor predeterminado del artefacto de salida (por ejemplo, `MyImage`), que contiene el nombre de la imagen y la información del URI del repositorio que desea que utilice la siguiente etapa.

1. Elija **Save (Guardar)** en la pantalla de acciones. Elija **Done (Listo)** en la pantalla de etapas. Elija **Save (Guardar)** en la canalización. Un mensaje muestra la regla de Amazon CloudWatch Events que se va a crear para la acción fuente de Amazon ECR.

**Para conectar los artefactos de código fuente con la acción de implementación**

1. Elija **Editar** en la etapa de implementación y elija el icono para editar la acción de **Amazon ECS (azul/verde**).

1. Desplácese hasta el final del panel. En **Input artifacts (Artefactos de entrada)**, elija **Add (Añadir)**. Añada el artefacto de origen desde su nuevo repositorio de Amazon ECR (por ejemplo, `MyImage`).

1. En **Definición de tarea**, elija y **SourceArtifact**, a continuación, verifique que **taskdef.json** se haya introducido.

1. En **AWS CodeDeploy AppSpec Archivo**, elija y **SourceArtifact**, a continuación, compruebe que **appspec.yaml** se ha introducido.

1. En **Actualizar dinámicamente la imagen de definición de tarea**, en **Artefacto de entrada con URI de imagen**, elija y **MyImage**, a continuación, introduzca el texto del marcador de posición que se utiliza en el `taskdef.json` archivo:. ** IMAGE1\$1NAME** Seleccione **Save**.

1. En el AWS CodePipeline panel, selecciona **Guardar cambio de canalización** y, a continuación, selecciona **Guardar** cambio. Consulte la canalización actualizada.

   Después de crear esta canalización de ejemplo, la configuración de la acción de las entradas de la consola aparece en la estructura de la canalización tal y como se indica a continuación:

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. Para enviar los cambios y comenzar una compilación de canalización, seleccione **Publicar modificación** y, a continuación, **Publicar**.

1. Elija la acción de despliegue para verla CodeDeploy y ver el progreso del cambio de tráfico.
**nota**  
Es posible que vea un paso de implementación que muestre un tiempo de espera opcional. De forma predeterminada, CodeDeploy espera una hora después de una implementación exitosa antes de finalizar el conjunto de tareas original. Puede utilizar este tiempo para revertir o terminar la tarea, pero la implementación se completa cuando finaliza el conjunto de tareas.

## Paso 7: Realizar un cambio en la canalización y verificar la implementación
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

Realice un cambio en la imagen y luego envíe ese cambio al repositorio de Amazon ECR. Esto desencadena la ejecución de la canalización. Compruebe que el cambio del código fuente de la imagen se ha implementado.

# Tutorial: Crear una canalización que implemente una habilidad de Amazon Alexa
<a name="tutorials-alexa-skills-kit"></a>

En este tutorial, puede configurar una canalización que enviará constantemente la habilidad de Alexa mediante Alexa Skills Kit como proveedor de implementación en la etapa de implementación. La canalización completa detecta cambios en la habilidad cuando se realiza un cambio en los archivos de código fuente en el repositorio de código fuente. Esto hace que la canalización utilice Alexa Skills Kit para realizar la implementación en la etapa de desarrollo de la habilidad de Alexa.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para los artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
Esta característica no está disponible en las regiones de Asia Pacífico (Hong Kong) ni Europa (Milán). Para utilizar otras acciones de implementación disponibles en esa región, consulte [Integraciones de acciones de implementación](integrations-action-type.md#integrations-deploy).

Para crear una habilidad personalizada como una función Lambda, consulte [Hospedar una habilidad personalizada como una función Lambda AWS](https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html). También puede crear una canalización que utilice archivos fuente de Lambda y un CodeBuild proyecto para implementar cambios en Lambda que se ajusten a sus habilidades.

## Requisitos previos
<a name="tutorials-alexa-skills-kit-prereq"></a>

Debe disponer de lo siguiente:
+ Un CodeCommit repositorio. Puedes usar el AWS CodeCommit repositorio en el que lo creaste[Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ Una cuenta de desarrollador de Amazon. Esta cuenta es la propietaria de las habilidades de Alexa. Puede crear una cuenta de forma gratuita en [Alexa Skills Kit](https://developer.amazon.com/alexa-skills-kit). 
+ Una habilidad de Alexa. Puede crear una habilidad de ejemplo mediante el tutorial que describe [cómo obtener código de muestra de habilidades personalizadas](https://developer.amazon.com/docs/custom-skills/use-the-alexa-skills-kit-samples.html).
+ Instale la CLI de ASK y configúrela utilizando `ask init` con sus credenciales de AWS . Consulte [Install and initialize ASK CLI](https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize).

## Paso 1: Crear un perfil de seguridad de LWA para los servicios de desarrolladores de Alexa
<a name="tutorials-alexa-skills-kit-profile"></a>

En esta sección, debe crear un perfil de seguridad para utilizarlo con Login with Amazon (LWA). Si ya tiene un perfil, puede omitir este paso.
+ Utilice los pasos que se indican en [generate-lwa-tokens](https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens) para crear un perfil de seguridad.
+ Después de crear el perfil, anote el **Client ID (ID de cliente)** y el **Client Secret (Secreto de cliente)**.
+ Asegúrese de introducir la **devolución permitida** tal y URLs como se indica en las instrucciones. El comando URLs allow the ASK CLI redirija las solicitudes de token de actualización.

## Paso 2: Crea los archivos fuente de habilidades de Alexa y envíalos a tu CodeCommit repositorio
<a name="tutorials-alexa-skills-kit-push"></a>

En esta sección, debe crear y enviar los archivos de código fuente de la habilidad de Alexa al repositorio que utiliza la canalización para la etapa de código fuente. Para la habilidad que ha creado en la consola para desarrolladores de Amazon, debe crear y enviar lo siguiente: 
+ Un archivo `skill.json`.
+ Una carpeta `interactionModel/custom`
**nota**  
Esta estructura de directorios cumple con los requisitos de formato del paquete de habilidades de Alexa Skills Kit, tal y como se describe en [Skill package format](https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format). Si la estructura de directorios no utiliza el formato de paquete de habilidades correcto, los cambios no se implementan correctamente en la consola de Alexa Skills Kit.

**Para crear los archivos de código fuente de la habilidad**

1. Recupere el ID de habilidad de la consola para desarrolladores de Alexa Skills Kit. Utilice este comando:

   ```
   ask api list-skills
   ```

   Localice la habilidad por su nombre y a continuación, copie el ID asociado en el campo `skillId`.

1. Genere un archivo `skill.json` que contenga los detalles de la habilidad. Utilice este comando:

   ```
   ask api get-skill -s skill-ID > skill.json
   ```

1. (Opcional) Cree una carpeta `interactionModel/custom`.

   Utilice este comando para generar el archivo del modelo de interacción en la carpeta. Para la configuración regional, este tutorial utiliza en-US como configuración regional del nombre de archivo.

   ```
   ask api get-model --skill-id skill-ID --locale locale >
       ./interactionModel/custom/locale.json
   ```

**Para enviar archivos a tu CodeCommit repositorio**

1. Envía o sube los archivos a tu CodeCommit repositorio. Estos archivos son el artefacto de código fuente creado por el asistente **Create Pipeline (Crear canalización)** para la acción de implementación en AWS CodePipeline. Sus archivos deberían ser parecidos a estos en su directorio local:

   ```
   skill.json
   /interactionModel
     /custom
       |en-US.json
   ```

1. Elija el método que desea usar para cargar los archivos:

   1. Para utilizar la línea de comandos de Git desde un repositorio clonado en el equipo local:

      1. Ejecute el siguiente comando para preparar todos los archivos de una vez:

         ```
         git add -A
         ```

      1. Ejecute el siguiente comando para confirmar los archivos con un mensaje de confirmación:

         ```
         git commit -m "Added Alexa skill files"
         ```

      1. Ejecuta el siguiente comando para enviar los archivos de tu repositorio local a tu CodeCommit repositorio:

         ```
         git push
         ```

   1. Para usar la CodeCommit consola para cargar tus archivos: 

      1. Abre la CodeCommit consola y elige tu repositorio en la lista de **repositorios**.

      1. Elija **Add file (Añadir archivo)** y, a continuación, **Upload file (Cargar archivo)**. 

      1. Elija **Choose file (Elegir archivo)** y luego busque el archivo. Para confirmar el cambio, introduzca su nombre de usuario y la dirección de correo electrónico. Seleccione **Confirmar cambios**.

      1. Repita este paso para cada archivo que desee cargar.

## Paso 3: Utilizar los comandos de la CLI de ASK para crear un token de actualización
<a name="tutorials-alexa-skills-kit-token"></a>

CodePipeline utiliza un token de actualización basado en el ID de cliente y el secreto de tu cuenta de desarrollador de Amazon para autorizar las acciones que realiza en tu nombre. En esta sección, se utiliza la CLI de ASK para crear el token. Estas credenciales se utilizan al usar el asistente **Create Pipeline (Crear canalización)**.

**Para crear un token de actualización con las credenciales de una cuenta de desarrollador de Amazon**

1. Utilice el siguiente comando : 

   ```
   ask util generate-lwa-tokens
   ```

1. Cuando se le solicite, introduzca el ID y el secreto del cliente, tal y como se muestra en este ejemplo: 

   ```
   ? Please type in the client ID: 
   amzn1.application-client.example112233445566
   ? Please type in the client secret:
   example112233445566
   ```

1. El navegador muestra la página de inicio de sesión. Inicie sesión con las credenciales de su cuenta de desarrollador de Amazon.

1. Vuelva a la pantalla de la línea de comandos. El token de acceso y el token de actualización se generan en la salida. Copie el token de actualización que se devuelven en la salida.

## Paso 4: Crear la canalización
<a name="tutorials-alexa-skills-kit-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una fase de origen con una CodeCommit acción en la que los artefactos de origen son los archivos de habilidades de Alexa que respaldan tu habilidad.
+ Una etapa de implementación con una acción de implementación de Alexa Skills Kit.

**Para crear una canalización con el asistente**

1. Inicia sesión en la CodePipeline consola Consola de administración de AWS y ábrela en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Elija la AWS región en la que desea crear el proyecto y sus recursos. El tiempo de ejecución de la habilidad de Alexa está disponible solo en las siguientes regiones:
   + Asia-Pacífico (Tokio)
   + Europa (Irlanda)
   + Este de EE. UU. (Norte de Virginia)
   + Oeste de EE. UU. (Oregón)

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyAlexaPipeline**.

1. CodePipeline proporciona canalizaciones de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **AWS CodeCommit**. En **Nombre del repositorio**, elija el nombre del CodeCommit repositorio en [Paso 1: Crea un CodeCommit repositorio](tutorials-simple-codecommit.md#codecommit-create-repository) el que lo creó. En **Nombre de ramificación**, elija el nombre de la ramificación que incluye la última actualización del código.

   Tras seleccionar el nombre y la sucursal del repositorio, aparecerá un mensaje con la regla de Amazon CloudWatch Events que se va a crear para esta canalización. 

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más.

   Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la etapa de despliegue**:

   1. En **Deploy provider (Proveedor de implementación)**, elija **Alexa Skills Kit**. 

   1. En **Alexa skill ID (ID de habilidad de Alexa)**, especifique el ID de habilidad asignado a la habilidad en la consola para desarrolladores de Alexa Skills Kit.

   1. En **Client ID (ID de cliente)**, especifique el ID de la aplicación que ha registrado.

   1. En **Client secret (Secreto de cliente)**, especifique el secreto de cliente que eligió cuando se registró.

   1. En **Refresh token (Token de actualización)**, especifique el token que ha generado en el paso 3.  
![\[Paso 6: Página de implementación para una acción del Alexa Skills Kit\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/alexa-deploy.png)

   1. Elija **Siguiente**.

1. En el **paso 7: Revisa**, revisa la información y, a continuación, selecciona **Crear canalización**.

## Paso 5: Realizar un cambio en cualquier archivo de origen y verificar la implementación
<a name="tutorials-alexa-skills-kit-update"></a>

Realice un cambio en la habilidad y, a continuación, envíe ese cambio al repositorio. Esto desencadena la ejecución de la canalización. Compruebe que la habilidad se actualiza en la [consola para desarrolladores de Alexa Skills Kit](https://developer.amazon.com/alexa/console/ask).

# Tutorial: Crear una canalización que utilice Amazon S3 como proveedor de implementación
<a name="tutorials-s3deploy"></a>

En este tutorial, va a configurar una canalización que enviará constantemente archivos utilizando Amazon S3 como proveedor de acciones de implementación en la etapa de implementación. La canalización completa detecta cambios cuando se realiza un cambio en los archivos de código fuente en el repositorio de código fuente. Esto hace que la canalización utilice Amazon S3 para implementar los archivos en el bucket. Cada vez que modifique o añada los archivos del sitio web en su ubicación de origen, la implementación creará el sitio web con los archivos más recientes. 

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para los artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
Incluso si elimina archivos del repositorio de origen, la acción de implementación de S3 no elimina los objetos de S3 correspondientes a los archivos eliminados.

En este tutorial, encontrará dos opciones:
+ Puede crear una canalización que implemente un sitio web estático en un bucket público de S3. En este ejemplo, se crea una canalización con una acción de AWS CodeCommit origen y una acción de despliegue de Amazon S3. Consulte [Opción 1: Implementar los archivos de un sitio web estático en Amazon S3](#tutorials-s3deploy-acc).
+ Cree una canalización que compile el TypeScript código de muestra JavaScript y despliegue el artefacto de CodeBuild salida en su bucket de S3 para archivarlo. En este ejemplo, se crea una canalización con una acción de origen de Amazon S3, una acción de CodeBuild compilación y una acción de despliegue de Amazon S3. Consulte [Opción 2: Implementar archivos compilados archivados en Amazon S3 desde un bucket de origen de S3](#tutorials-s3deploy-s3source).

**importante**  
Muchas de las acciones que añada a la canalización en este procedimiento implican AWS recursos que debe crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para las acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

## Opción 1: Implementar los archivos de un sitio web estático en Amazon S3
<a name="tutorials-s3deploy-acc"></a>

En este ejemplo, descarga el archivo de plantilla de sitio web estático de ejemplo, carga los archivos en su AWS CodeCommit repositorio, crea su depósito y lo configura para el alojamiento. A continuación, utilice la AWS CodePipeline consola para crear su canalización y especificar una configuración de despliegue de Amazon S3.

### Requisitos previos
<a name="tutorials-s3deploy-acc-prereq"></a>

Debe disponer de lo siguiente:
+ Un CodeCommit repositorio. Puedes usar el AWS CodeCommit repositorio en el que lo creaste[Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ Archivos de código fuente del sitio web estático. Utilice este enlace para descargar un [ejemplo de sitio web estático](samples/sample-website.zip). La descarga de sample-website.zip produce los siguientes archivos: 
  + Un archivo `index.html`
  + Un archivo `main.css`
  + Un archivo `graphic.jpg`
+ Un bucket de S3 configurado para alojar sitios web. Consulte [Alojamiento de un sitio web estático en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html). No olvide que el bucket debe crearse en la misma región que la canalización.
**nota**  
Para alojar un sitio web, el bucket debe tener acceso de lectura público, lo que concede acceso a todo el mundo. Salvo en el caso del alojamiento de sitios web, debe dejar la configuración de acceso predeterminada que bloquea el acceso público a los buckets de S3.

### Paso 1: Envía los archivos fuente a tu CodeCommit repositorio
<a name="tutorials-s3deploy-acc-push"></a>

En esta sección, debe enviar los archivos de código fuente al repositorio que utiliza la canalización para la etapa de código fuente.

**Para enviar archivos a tu CodeCommit repositorio**

1. Extraiga los archivos de ejemplo que ha descargado. No cargue el archivo ZIP en el repositorio.

1. Envía o sube los archivos a tu CodeCommit repositorio. Estos archivos son el artefacto de código fuente creado por el asistente **Create Pipeline (Crear canalización)** para la acción de implementación en CodePipeline. Sus archivos deberían ser parecidos a estos en su directorio local:

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. Puedes usar Git o la CodeCommit consola para cargar tus archivos:

   1. Para utilizar la línea de comandos de Git desde un repositorio clonado en el equipo local:

      1. Ejecute el siguiente comando para preparar todos los archivos de una vez:

         ```
         git add -A
         ```

      1. Ejecute el siguiente comando para confirmar los archivos con un mensaje de confirmación:

         ```
         git commit -m "Added static website files"
         ```

      1. Ejecuta el siguiente comando para enviar los archivos de tu repositorio local a tu CodeCommit repositorio:

         ```
         git push
         ```

   1. Para usar la CodeCommit consola para cargar tus archivos: 

      1. Abre la CodeCommit consola y elige tu repositorio en la lista de **repositorios**.

      1. Elija **Add file (Añadir archivo)** y, a continuación, **Upload file (Cargar archivo)**. 

      1. Seleccione **Choose file (Elegir archivo)** y, a continuación, busque el archivo. Para confirmar el cambio, introduzca su nombre de usuario y la dirección de correo electrónico. Seleccione **Confirmar cambios**.

      1. Repita este paso para cada archivo que desee cargar.

### Paso 2: Crear la canalización
<a name="tutorials-s3deploy-acc-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una CodeCommit acción en la que los artefactos de origen son los archivos de tu sitio web.
+ Una etapa de implementación con una acción de implementación de Amazon S3.

**Para crear una canalización con el asistente**

1. Inicie sesión Consola de administración de AWS y abra la CodePipeline consola en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyS3DeployPipeline**.

1. En **Tipo de canalización**, seleccione **V2**. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md). Elija **Siguiente**.

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **AWS CodeCommit**. En **Repository name (Nombre de repositorio)**, elija el nombre del repositorio de CodeCommit que ha creado en [Paso 1: Crea un CodeCommit repositorio](tutorials-simple-codecommit.md#codecommit-create-repository). En **Nombre de ramificación**, elija el nombre de la ramificación que incluye la última actualización del código. A menos que haya creado otra ramificación, solo estará disponible `main`. 

   Tras seleccionar el nombre y la sucursal del repositorio, se muestra la regla de Amazon CloudWatch Events que se va a crear para esta canalización. 

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la etapa de despliegue**:

   1. En **Deploy provider (Proveedor de implementación)**, elija **Amazon S3**. 

   1. En **Bucket**, especifique el nombre del bucket público.

   1. Seleccione **Extract file before deploy (Extraer el archivo antes de la implementación)**.
**nota**  
Si no selecciona **Extraer el archivo antes de la implementación**, se produce un error en la implementación. Esto se debe a que la AWS CodeCommit acción de la canalización comprime los artefactos de origen y el archivo es un archivo ZIP.

      Cuando se selecciona **Extract file before deploy (Extraer el archivo antes de la implementación)**, se muestra **Deployment path (Ruta de implementación)**. Especifique el nombre de la ruta que desea utilizar. Esto crea una estructura de carpetas en Amazon S3 en la que se extraen los archivos. Para este tutorial, deje en blanco este campo.  
![\[La página Paso 6: Añadir una fase de despliegue para una acción de despliegue de S3 con una fuente AWS CodeCommit\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-codecommit.png)

   1. (Opcional) En **Canned ACL** puede aplicar un conjunto de garantías predefinidas, conocido como una [ACL predefinida](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) a los artefactos cargados. 

   1. (Opcional) En **Cache control (Control del caché)** introduzca los parámetros de caché. Puede establecerlo para controlar el comportamiento del caché para las solicitudes/respuestas. Para valores válidos, consulte el [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9)campo del encabezado para las operaciones HTTP

   1. Elija **Siguiente**.

1. En el **paso 7: Revisar**, revise la información y, a continuación, seleccione **Crear canalización**.

1. Después de la canalización se ejecute correctamente, abra la consola de Amazon S3 y compruebe que los archivos aparecen en el bucket público, tal como se muestra a continuación:

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. Obtenga acceso al punto de enlace para probar el sitio web. El punto de enlace tiene este formato: `http://bucket-name.s3-website-region.amazonaws.com/`.

   Ejemplo de punto de enlace: `http://my-bucket.s3-website-us-west-2.amazonaws.com/`. 

   Aparece la siguiente página web de muestra.

### Paso 3: Realizar un cambio en cualquier archivo de código fuente y verificar la implementación
<a name="tutorials-s3deploy-acc-update"></a>

Realice un cambio en los archivos código fuente y, a continuación, envíe ese cambio al repositorio. Esto desencadena la ejecución de la canalización. Compruebe que el sitio web se actualiza.

## Opción 2: Implementar archivos compilados archivados en Amazon S3 desde un bucket de origen de S3
<a name="tutorials-s3deploy-s3source"></a>

En esta opción, los comandos de compilación de la fase de compilación compilan el TypeScript código en JavaScript código y despliegan el resultado en el bucket de destino de S3 en una carpeta independiente con fecha y hora. Primero, crea el TypeScript código y un archivo buildspec.yml. Tras combinar los archivos fuente en un archivo ZIP, se carga el archivo ZIP de origen en el bucket de origen de S3 y se utiliza un CodeBuild escenario para implementar un archivo ZIP de aplicación creado en el bucket de destino de S3. El código compilado se conserva en formato comprimido en el bucket de destino.

### Requisitos previos
<a name="tutorials-s3deploy-s3source-prereq"></a>

Debe disponer de lo siguiente:
+ Un bucket de origen de S3. Puede utilizar el bucket que creó en [Tutorial: Crear una canalización simple (bucket de S3)](tutorials-simple-s3.md).
+ Un bucket de destino de S3. Consulte [Alojamiento de un sitio web estático en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html). Asegúrese de crear su bucket de la Región de AWS misma manera que la canalización que desea crear.
**nota**  
En este ejemplo, se muestra la implementación de archivos en un bucket privado. No habilite el bucket de destino para el alojamiento de sitios web ni le asocie políticas que lo conviertan en un bucket público.

### Paso 1: Crear y cargar los archivos de código fuente en un bucket de código fuente de S3
<a name="tutorials-s3deploy-s3source-upload"></a>

En esta sección, debe crear y cargar los archivos de código fuente en el bucket que utiliza la canalización para la etapa de código fuente. En esta sección, se proporcionan instrucciones para la creación de los siguientes archivos de código fuente:
+ Un `buildspec.yml` archivo que se utiliza para proyectos de CodeBuild construcción.
+ Un archivo `index.ts`. 

**Para crear un archivo buildspec.yml**
+ Cree un archivo denominado `buildspec.yml` con el siguiente contenido. Estos comandos de compilación instalan TypeScript y utilizan el TypeScript compilador para reescribir el código en `index.ts` código. JavaScript

  ```
  version: 0.2
  
  phases:
    install:
      commands:
        - npm install -g typescript
    build:
      commands:
        - tsc index.ts
  artifacts:
    files:
      - index.js
  ```

**Para crear un archivo index.ts**
+ Cree un archivo denominado `index.ts` con el siguiente contenido.

  ```
  interface Greeting {
      message: string;
  }
  
  class HelloGreeting implements Greeting {
      message = "Hello!";
  }
  
  function greet(greeting: Greeting) {
      console.log(greeting.message);
  }
  
  let greeting = new HelloGreeting();
  
  greet(greeting);
  ```

**Para cargar los archivos en un bucket de código fuente de S3**

1. Sus archivos deberían ser parecidos a estos en su directorio local:

   ```
   buildspec.yml
   index.ts
   ```

   Comprima los archivos y asigne al archivo el nombre `source.zip`.

1. En la consola de Amazon S3, para el bucket de origen, elija **Cargar**. Elija **Add files (Añadir archivos)**, a continuación, busque el archivo ZIP que ha creado.

1.  Seleccione **Cargar**. Estos archivos son el artefacto de código fuente creado por el asistente **Create Pipeline (Crear canalización)** para la acción de implementación en CodePipeline. El archivo debería aparecer así en el bucket:

   ```
   source.zip
   ```

### Paso 2: Crear la canalización
<a name="tutorials-s3deploy-s3source-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una acción de Amazon S3 en la que los artefactos de origen son los archivos de la aplicación descargable.
+ Una etapa de implementación con una acción de implementación de Amazon S3.

**Para crear una canalización con el asistente**

1. [Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyS3DeployPipeline**.

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **Amazon S3**. En **Bucket**, elija el nombre del bucket de código fuente. En **S3 object key (Clave de objeto de S3)**, escriba el nombre del archivo ZIP de código fuente. Asegúrese de incluir la extensión de archivo .zip.

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**:

   1. En **Build provider (Proveedor de compilación)**, elija **CodeBuild**.

   1. Elija **Crear el proyecto de compilación**. En la página **Create project (Crear proyecto)**:

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment (Entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **Para la **versión Runtime**, elijaaws/codebuild/standard: 1.0.**

   1. En **Image version (Version de la imagen)**, elija **Always use the latest image for this runtime version (Utilizar siempre la imagen más reciente para esta versión del tiempo de ejecución)**.

   1. En **Rol de servicio**, elija su rol CodeBuild de servicio o cree uno.

   1. En **Build specifications (Especificaciones de compilación)**, elija **Use a buildspec file (Usar un archivo buildspec)**.

   1. Selecciona **Continuar a CodePipeline**. Se muestra un mensaje si el proyecto se ha creado correctamente.

   1. Elija **Siguiente**.

1. En **Paso 5: agregar la etapa de implementación**:

   1. En **Deploy provider (Proveedor de implementación)**, elija **Amazon S3**. 

   1. En **Bucket**, especifique el nombre del bucket de destino de S3.

   1. Asegúrese de que no está seleccionada la opción **Extract file before deploy (Extraer el archivo antes de la implementación)**.

      Cuando no está seleccionada la opción **Extract file before deploy (Extraer el archivo antes de la implementación)**, se muestra **S3 object key (Clave de objeto de S3)**. Especifique el nombre de la ruta que desea utilizar: `js-application/{datetime}.zip`.

      Esto crea una carpeta `js-application` en Amazon S3 en la que se extraen los archivos. En esta carpeta, la variable `{datetime}` crea una marca de tiempo en cada archivo de salida cuando se ejecuta la canalización.  
![\[La página Paso 5: implementación para una acción de implementación de Amazon S3 con origen de Amazon S3\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-s3source.png)

   1. (Opcional) En **Canned ACL** puede aplicar un conjunto de garantías predefinidas, conocido como una [ACL predefinida](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) a los artefactos cargados. 

   1. (Opcional) En **Cache control (Control del caché)** introduzca los parámetros de caché. Puede establecerlo para controlar el comportamiento del caché para las solicitudes/respuestas. Para valores válidos, consulte el [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9)campo del encabezado para las operaciones HTTP

   1. Elija **Siguiente**.

1. En **Step 6: Review**, revise la información y después elija **Create pipeline**.

1. Después de que la canalización se ejecute correctamente, visualice el bucket en la consola de Amazon S3. Compruebe que el archivo ZIP implementado se muestre en el bucket de destino en la carpeta `js-application`. El JavaScript archivo contenido en el archivo ZIP debe ser`index.js`. El archivo `index.js` contiene la salida siguiente:

   ```
   var HelloGreeting = /** @class */ (function () {
       function HelloGreeting() {
           this.message = "Hello!";
       }
       return HelloGreeting;
   }());
   function greet(greeting) {
       console.log(greeting.message);
   }
   var greeting = new HelloGreeting();
   greet(greeting);
   ```

### Paso 3: Realizar un cambio en cualquier archivo de código fuente y verificar la implementación
<a name="tutorials-s3deploy-s3source-update"></a>

Realice un cambio en los archivos de código fuente y, a continuación, cárguelos en el bucket de código fuente. Esto desencadena la ejecución de la canalización. Visualice el bucket de destino y verifique que los archivos de salida implementados estén disponibles en la carpeta `js-application`, tal y como se muestra a continuación:

![\[Ejemplo de descarga de archivo ZIP\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/tutorial-s3deploy-pipeline-appzip.png)


# Tutorial: Cree una canalización que publique su aplicación sin servidor en el AWS Serverless Application Repository
<a name="tutorials-serverlessrepo-auto-publish"></a>

Puede utilizarla AWS CodePipeline para entregar continuamente su aplicación AWS SAM sin servidor al. AWS Serverless Application Repository

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para almacenar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

En este tutorial se muestra cómo crear y configurar una canalización para crear una aplicación sin servidor alojada en ella GitHub y publicarla en ella automáticamente. AWS Serverless Application Repository La canalización GitHub se utiliza como proveedor de código fuente y CodeBuild como proveedor de compilación. Para publicar su aplicación sin servidor en AWS Serverless Application Repository, debe implementar una [aplicación](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish ) (desde AWS Serverless Application Repository) y asociar la función Lambda creada por esa aplicación como un proveedor de acciones de invocación en su canalización. De este modo, podrá enviar actualizaciones de la aplicación de forma continua a AWS Serverless Application Repository, sin necesidad de escribir ningún código.

**importante**  
Muchas de las acciones que añada a la canalización en este procedimiento implican AWS recursos que debe crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para las acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

## Antes de empezar
<a name="tutorials-serverlessrepo-auto-publish-prereq"></a>

En este tutorial, se presupone lo siguiente. 
+ Está familiarizado con [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/) y con el [AWS Serverless Application Repository](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/).
+ Tiene alojada una aplicación sin servidor GitHub que ha publicado en ella AWS Serverless Application Repository mediante la AWS SAM CLI. Para publicar una aplicación de ejemplo en la AWS Serverless Application Repository, consulte [Inicio rápido: publicación de aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html) en la *Guía para AWS Serverless Application Repository desarrolladores*. Para publicar su propia aplicación en AWS Serverless Application Repository, consulte [Publicar aplicaciones mediante la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html) en la *Guía para AWS Serverless Application Model desarrolladores*.

## Paso 1: Crear un archivo buildspec.yml
<a name="serverlessrepo-auto-publish-create-buildspec"></a>

Cree un `buildspec.yml` archivo con el siguiente contenido y agréguelo al GitHub repositorio de su aplicación sin servidor. *template.yml*Sustitúyalo por la AWS SAM plantilla de la aplicación y *bucketname* por el depósito de S3 en el que se almacena la aplicación empaquetada.

```
version: 0.2
phases:
  install:
    runtime-versions:
        python: 3.8
  build:
    commands:
      - sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.yml
artifacts:
  files:
    - packaged-template.yml
```

## Paso 2: Crear y configurar la canalización
<a name="serverlessrepo-auto-publish-create-pipeline"></a>

Siga estos pasos para crear su canalización en el Región de AWS lugar donde desee publicar la aplicación sin servidor.

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

1. Si es necesario, cambie al Región de AWS lugar en el que desee publicar la aplicación sin servidor.

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. Seleccione **Create pipeline**. En la página **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba el nombre de la canalización.

1. En **Tipo de canalización**, seleccione **V2**. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md). Elija **Siguiente**.

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para permitir la creación de una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: Añadir la fase de origen**, en **Proveedor de origen**, seleccione **GitHub**.

1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

1. En **Repositorio**, elige tu repositorio GitHub de origen.

1. En **Branch**, elige tu GitHub sucursal.

1. Deje los valores predeterminados restantes para la acción de origen. Elija **Siguiente**.

1. En la página **Paso 4: agregación de la etapa de compilación**, agregue una etapa de compilación:

   1. En **Build provider (Proveedor de compilación)**, elija **AWS CodeBuild**. En **Region (Región)**, utilice la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime (Tiempo de ejecución)** y **Runtime version (Versión de tiempo de ejecución)**, elija el tiempo de ejecución y la versión necesarios para la aplicación sin servidor.

   1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.

   1. En **Build specifications (Especificaciones de compilación)**, elija **Use a buildspec file (Usar un archivo buildspec)**.

   1. Selecciona **Continuar a CodePipeline**. De este modo, se abre la CodePipeline consola y se crea un CodeBuild proyecto que lo utiliza `buildspec.yml` en su repositorio para la configuración. El proyecto de compilación utiliza un rol de servicio para administrar los permisos del Servicio de AWS . Es posible que este paso tarde un par de minutos.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**. Debería ver un diagrama con las etapas.

1. Conceda permiso al rol de CodeBuild servicio para acceder al bucket de S3 donde está almacenada la aplicación empaquetada.

   1. En la etapa **Build (Compilación)** de la canalización nueva, elija **CodeBuild**.

   1. Elija la pestaña **Build details (Detalles de compilación)**.

   1. En **Entorno**, elija el rol CodeBuild de servicio para abrir la consola de IAM.

   1. Amplíe la selección para `CodeBuildBasePolicy` y elija **Edit policy (Editar política)**.

   1. Elija **JSON**.

   1. Añada una instrucción de política nueva con el siguiente contenido. La declaración permite CodeBuild colocar objetos en el depósito de S3 donde se almacena la aplicación empaquetada. *bucketname*Sustitúyalo por el nombre del depósito de S3.

      ```
              {
                  "Effect": "Allow",
                  "Resource": [
                      "arn:aws:s3:::bucketname/*"
                  ],
                  "Action": [
                      "s3:PutObject"
                  ]
              }
      ```

   1. Elija **Revisar política**.

   1. Seleccione **Save changes (Guardar cambios)**.

## Paso 3: Implementar la aplicación de publicación
<a name="serverlessrepo-auto-publish-deploy-app"></a>

Siga estos pasos para implementar la aplicación que contiene la función de Lambda que lleva a cabo la publicación en el AWS Serverless Application Repository. Esta aplicación es **aws-serverless-codepipeline-serverlessrepo-publish**.

**nota**  
Debes implementar la aplicación en el mismo lugar Región de AWS que tu canalización.

1. Vaya a la página de la [aplicación](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish ) y elija **Deploy (Implementar)**.

1. Seleccione **I acknowledge that this app creates custom IAM roles (Confirmo que esta aplicación puede crear roles de IAM personalizados)**. 

1. Elija **Implementar**.

1. Selecciona **View CloudFormation Stack** para abrir la CloudFormation consola.

1. Amplíe la sección **Resources (Recursos)**. Verás **ServerlessRepoPublish**, que es de ese tipo **AWS::Lambda::Function**. Anote el ID físico de este recurso para el siguiente paso. Lo utilizará al crear la acción de publicación nueva en CodePipeline.

## Paso 4: Crear la acción de publicación
<a name="serverlessrepo-auto-publish-create-action"></a>

Siga estos pasos para crear la acción de publicación en la canalización.

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la sección de navegación izquierda, elija la canalización que desea editar.

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

1. Después de la última etapa de la canalización actual, elija **\$1 Add stage (Añadir etapa)**. En **Stage name (Nombre de etapa)**, escriba un nombre, por ejemplo **Publish**, y elija **Add stage (Añadir etapa)**.

1. En la nueva etapa, elija **\$1Add action group (\$1Añadir grupo de acciones)**.

1. Introduzca un nombre para la acción. En **Action provider (Proveedor de acción)**, en **Invoke (Invocar)**, elija **AWS Lambda**.

1. En **Artefactos de entrada**, elija **BuildArtifact**.

1. En **Nombre de función**, elija el ID físico de la función de Lambda que ha anotado en el paso anterior.

1. Elija **Save (Guardar)** para la acción.

1. Elija **Done (Listo)** para la etapa.

1. En la parte superior derecha, elija **Save (Guardar)**.

1. Para verificar tu canalización, realiza un cambio en tu aplicación en GitHub. Por ejemplo, cambia la descripción de la aplicación en la `Metadata` sección del archivo de AWS SAM plantilla. Confirma el cambio y envíalo a tu GitHub sucursal. Esto desencadena la ejecución de la canalización. Cuando la canalización esté completa, compruebe que la aplicación se ha actualizado con el cambio en el [AWS Serverless Application Repository](https://console.aws.amazon.com/serverlessrepo/home).

# Tutorial: Implementaciones de funciones Lambda con CodePipeline
<a name="tutorials-lambda-deploy"></a>

Este tutorial le ayuda a crear una acción de despliegue CodePipeline que despliegue el código en la función que haya configurado en Lambda. Creará una función de Lambda de ejemplo en la que se crean un alias y una versión, se agrega la función de Lambda comprimida a la ubicación de origen y se ejecuta la acción de Lambda en la canalización.

**nota**  
Como parte de la creación de una canalización en la consola, para los artefactos se utilizará un depósito de artefactos de CodePipeline S3. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**nota**  
La acción de implementación de `Lambda` solo está disponible para canalizaciones de tipo V2.

## Requisitos previos
<a name="tutorials-lambda-deploy-prereqs"></a>

Para poder usar este tutorial para crear su propia canalización de implementación continua debe tener instalados algunos recursos. Esto es lo que necesita para empezar:

**nota**  
Todos estos recursos deben crearse en la misma región. AWS 
+ Un repositorio de control de código fuente, por ejemplo GitHub, o un depósito de S3 de origen (en este tutorial se utiliza S3), donde almacenará un `.zip` archivo que cree para la función Lambda.
+ Debe usar un rol de CodePipeline servicio existente que se haya actualizado con los permisos para esta acción. Para actualizar su rol de servicio, consulte [Permisos de la política de rol de servicio para la acción de implementación de Lambda](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action).

Una vez satisfechos estos requisitos previos, puede continuar con el tutorial y crear su canalización de implementación continua.

## Paso 1: creación de la función de Lambda de ejemplo
<a name="tutorials-lambda-deploy-instances"></a>

En este paso, se crea la función de Lambda en la que se realizará la implementación.

**Para crear una función de Lambda**

1. Acceda a la consola de Lambda y realice los pasos del siguiente tutorial para crear una función de Lambda de ejemplo: enlace.

1. En la barra de navegación superior, elija **Crear** y, en la parte superior de la página, seleccione **Comenzar desde cero**.

1. En **Name (Nombre)**, escriba **MyLambdaFunction**. 

1. Publique una nueva versión. Esta será la versión a la que apuntará el alias.

   1. Seleccione su función.

   1. Elija el menú desplegable **Acciones**.

   1. Elija **Publicar nueva versión**.

   1. (Opcional) Agregue una descripción en **Descripción**.

   1. Elija **Publicar**.

1. Cree un alias para su función, por ejemplo, `aliasV1`.

1. Asegúrese de que el alias apunte a la versión que acaba de crear (por ejemplo, 1).
**nota**  
Si elige \$1LATEST, no puede usar las características de transferencia de tráfico porque Lambda no admite \$1LATEST para un alias que apunte a más de una versión.

## Paso 2: carga del archivo de la función en el repositorio
<a name="tutorials-lambda-deploy-file"></a>

Descargue la función y guárdela como un archivo .zip. Cargue el archivo comprimido en el bucket de S3 siguiendo los pasos que se indican a continuación.

**Para añadir un archivo `.zip` a su repositorio de código fuente**

1. Abra su bucket de S3.

1. Seleccione **Cargar**.

1. Suba el archivo .zip que contiene su archivo `sample_lambda_source.zip` al bucket de origen.

   Tome nota de la ruta.

   ```
   object key
   ```

## Paso 3: creación de una canalización
<a name="tutorials-lambda-deploy-pipeline"></a>

Usa el CodePipeline asistente para crear las etapas de la canalización y conectar el repositorio de origen.

**Para crear la canalización**

1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Usar la función de servicio existente** y, a continuación, elija la función de CodePipeline servicio que se ha actualizado con los permisos necesarios para esta acción. Para configurar el rol CodePipeline de servicio para esta acción, consulte[Permisos de la política de rol de servicio para la acción de implementación de Lambda](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action).

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Source provider (Proveedor de código fuente)**, elija **Amazon S3**.

   1. En **Clave de objeto**, agregue el nombre del archivo .zip, incluida la extensión del archivo, por ejemplo, `sample_lambda_source.zip`.

      

   Elija **Siguiente**.

1. En la página **Paso 4: agregación de la etapa de compilación**, seleccione **Omitir**.

1. En la página **Paso 5: agregación de la etapa de prueba**, seleccione **Omitir**.

1. En la página **Paso 6: agregación de la etapa de implementación**, elija **Lambda**.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)

   1. Agregue el nombre de la función y el alias. 

   1. Elija su estrategia de implementación.

   1. Elija **Siguiente**.

1. En la página **Paso 7: Revisar**, revisa la configuración de la canalización y selecciona **Crear canalización** para crear la canalización.  
![\[\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/lambdadeploy-pipeline-screen.png)

## Paso 4: Probar la canalización
<a name="tutorials-lambda-deploy-test"></a>

Tu canalización debe tener todo lo necesario para ejecutar una implementación AWS continua end-to-end nativa. Ahora, pruebe su funcionalidad enviando un cambio de código al repositorio de código fuente.

**Para probar la canalización**

1. Realice una modificación del código en el repositorio de código fuente configurado, valide y envíe el cambio.

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Seleccione su canalización de la lista.

1. Vea el progreso en la canalización a través de sus etapas. La canalización debería completarse y la acción implementarse en la función de Lambda.

## Más información
<a name="tutorials-lambda-deploy-learn"></a>

La acción de implementación de Lambda permite dos métodos de implementación. Un método es el cambio de tráfico por sí solo sin un artefacto de entrada de la acción de origen. El otro método consiste en actualizar el código de la función mediante un artefacto de entrada de la acción de origen y, a continuación, publicar una nueva versión basada en el código actualizado. Para el segundo método, si se proporciona el alias, también CodePipeline se realizará el cambio de tráfico. En este tutorial sobre la acción de implementación de Lambda, se muestra cómo actualizar la función mediante un artefacto de origen.

Para obtener más información sobre la acción, consulte la página de referencia de la acción en [Referencia de la acción de implementación de AWS Lambda](action-reference-LambdaDeploy.md).

# Tutorial: Uso de variables con acciones de invocación de Lambda
<a name="tutorials-lambda-variables"></a>

Una acción de invocación de Lambda puede usar variables de otra acción como parte de su entrada y devolver nuevas variables junto con su salida. Para obtener información sobre las variables de las acciones en CodePipeline, consulte[Referencia de variables](reference-variables.md).

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

Al final de este tutorial, tendrá:
+ Una acción de invocación de Lambda que:
  + Consume la `CommitId` variable de una acción fuente CodeCommit 
  + Da como resultado tres nuevas variables: `dateTime`, `testRunId` y `region`
+ Una acción de aprobación manual que consume las nuevas variables de la acción de invocación de Lambda para proporcionar una URL de prueba y un ID de ejecución de prueba
+ Una canalización actualizada con las nuevas acciones

**Topics**
+ [

## Requisitos previos
](#lambda-variables-prereqs)
+ [

## Paso 1: Crear una función de Lambda
](#lambda-variables-function)
+ [

## Paso 2: Añadir una acción de invocación de Lambda y una acción de aprobación manual a la canalización
](#lambda-variables-pipeline)

## Requisitos previos
<a name="lambda-variables-prereqs"></a>

Antes de comenzar, debe disponer de lo siguiente: 
+ Puede crear o utilizar la canalización con la CodeCommit fuente incorporada[Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).
+ Edita tu canalización existente para que la acción CodeCommit de origen tenga un espacio de nombres. Asigne el espacio de nombres `SourceVariables` a la acción.

## Paso 1: Crear una función de Lambda
<a name="lambda-variables-function"></a>

Realice los pasos siguientes para crear una función de Lambda y un rol de ejecución de Lambda. Agregue la acción de Lambda a la canalización después de crear la función de Lambda.

**Crear una función de Lambda y rol de ejecución**

1. Inicia sesión en Consola de administración de AWS y abre la AWS Lambda consola en. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1. Seleccione **Creación de función**. Deje seleccionado **Author from scratch (Crear desde cero)**.

1. En **Function name (Nombre de la función)**, escriba el nombre de la función, como **myInvokeFunction**. En **Runtime (Motor de ejecución)**, deje seleccionada la opción predeterminada.

1. Expanda **Choose or create an execution role (Elegir o crear un rol de ejecución)**. Elija **Create a new role with basic Lambda permissions (Crear un nuevo rol con permisos básicos de Lambda)**.

1. Seleccione **Creación de función**.

1. Para usar una variable de otra acción, tendrá que pasar `UserParameters` a la configuración de acción de invocación de Lambda. Va a configurar la acción en nuestra canalización más adelante en el tutorial, pero agregará el código asumiendo que la variable se pasará.

   Para producir nuevas variables, establezca una propiedad llamada `outputVariables` en la entrada a `putJobSuccessResult`. Tenga en cuenta que no puede producir variables como parte de `putJobFailureResult`.

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   En la nueva función, en la pestaña **Código**, pegue el siguiente código de ejemplo en `index.mjs`.

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. Permita que la función se guarde automáticamente.

1. Copie el nombre de recurso de Amazon (ARN) en el campo **Función ARN** situado en la parte superior de la pantalla.

1. Como último paso, abra la consola AWS Identity and Access Management (IAM) en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Modifique la función de ejecución de Lambda para agregar la siguiente política:. [AWSCodePipelineCustomActionAccess](https://console.aws.amazon.com/iam/home?region=us-west-2#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCodePipelineCustomActionAccess) Para consultar los pasos necesarios para crear un rol de ejecución de Lambda o modificar la política de rol, consulte [Paso 2: Crear la función de Lambda](actions-invoke-lambda-function.md#actions-invoke-lambda-function-create-function). 

## Paso 2: Añadir una acción de invocación de Lambda y una acción de aprobación manual a la canalización
<a name="lambda-variables-pipeline"></a>

En este paso, agregue una acción de invocación de Lambda a la canalización. Agregue la acción como parte de una etapa denominada **Test (Prueba)**. El tipo de acción es una acción de invocación. A continuación, agregue una acción de aprobación manual después de la acción de invocación.

**Para agregar una acción de Lambda y una acción de aprobación manual a la canalización**

1. Abra la CodePipeline consola en. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

   Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta. Elija la canalización en la que desea agregar la acción.

1. Agregue la acción de prueba de Lambda a su canalización.

   1. Para editar la canalización, elija **Editar**. Agregue una etapa después de la acción de origen en la canalización existente. Escriba un nombre para la etapa, por ejemplo **Test**.

   1. En la nueva etapa, elija **\$1Agregar el grupo de acción** para agregar una acción. En **Action name (Nombre de la acción)**, escriba el nombre de la acción de invocación, como **Test\$1Commit**.

   1. En **Proveedor de acción**, seleccione **AWS Lambda**.

   1. En **Input artifacts (Artefactos de entrada)**, elija el nombre del artefacto de salida de la acción de origen, como `SourceArtifact`.

   1. En **FunctionName**, añada el ARN de la función Lambda que creó.

   1. En el **Variable namespace (Espacio de nombres de la variable)**, agregue el nombre del espacio de nombres, como **TestVariables**.

   1. En **Artefactos de salida**, añada el nombre del artefacto de salida, como **LambdaArtifact**.

   1. Seleccione **Listo**.

1. Agregue la acción de aprobación manual a la canalización.

   1. Con la canalización todavía en modo de edición, agregue una etapa después de la acción de invocación. Escriba un nombre para la etapa, por ejemplo **Approval**.

   1. En la nueva etapa, elija el icono para agregar una acción. En **Action name (Nombre de la acción)**, escriba el nombre de la acción de aprobación, como **Change\$1Approval**.

   1. En **Action provider (Proveedor de acciones)**, elija **Manual approval (Aprobación manual)**.

   1. En **URL for review (URL para revisión)**, cree la URL agregando la sintaxis de variable para la variable `region` y la variable `CommitId`. Asegúrese de utilizar los espacios de nombres asignados a las acciones que proporcionan las variables de salida. 

      En este ejemplo, la URL con la sintaxis variable de una CodeCommit acción tiene el espacio de nombres predeterminado. `SourceVariables` La variable de salida de región de Lambda tiene el espacio de nombres `TestVariables`. La URL tiene el siguiente aspecto.

      ```
      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}
      ```

      En **Comments (Comentarios)**, cree el texto del mensaje de aprobación agregando la sintaxis de la variable para la variable `testRunId`. Para este ejemplo, la dirección URL con la sintaxis de variable para la variable de salida de Lambda `testRunId` tiene el espacio de nombres `TestVariables`. Escriba el siguiente mensaje.

      ```
      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}
      ```

1. Elija **Done (Listo)** para cerrar la pantalla de edición de la acción y, a continuación, elija **Done (Listo)** para cerrar la pantalla de edición de la etapa. Para guardar la canalización, elija **Done (Listo)**. La canalización completada ahora contiene una estructura con etapas de origen, prueba, aprobación e implementación.

   Elija **Release change (Publicar modificación)** para ejecutar el último cambio a través de la estructura de la canalización.

1. Cuando la canalización llegue a la etapa de aprobación manual, elija **Review (Revisar)**. Las variables resueltas aparecen como la URL del ID de confirmación. El aprobador puede elegir la URL para consultar la confirmación.

1. Después de que la canalización se ejecute de forma satisfactoria, también puede consultar los valores de las variables en la página del historial de ejecución de acciones.

# Tutorial: Usa una acción de AWS Step Functions invocación en una canalización
<a name="tutorials-step-functions"></a>

Se puede utilizar AWS Step Functions para crear y configurar máquinas de estado. En este tutorial, se muestra cómo se agrega una acción de invocación a una canalización que activa las ejecuciones de máquinas de estados desde la canalización. 

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

En este tutorial, va a realizar las siguientes tareas:
+ Crea un estado estándar en el que esté la máquina. AWS Step Functions
+ Escribir directamente la entrada JSON de la máquina de estados. También puede cargar el archivo de entrada de la máquina de estados en un bucket de Amazon Simple Storage Service (Amazon S3).
+ Actualizar la canalización agregando la acción de la máquina de estados.

**Topics**
+ [

## Requisito previo: cree o elija una canalización sencilla
](#tutorials-step-functions-prereq)
+ [

## Paso 1: Crear la máquina de estados de ejemplo
](#tutorials-step-functions-sample)
+ [

## Paso 2: Agregar una acción de invocación de Step Functions a la canalización
](#tutorials-step-functions-pipeline)

## Requisito previo: cree o elija una canalización sencilla
<a name="tutorials-step-functions-prereq"></a>

En este tutorial, va a agregar una acción de invocación a una canalización existente. Puede utilizar la canalización que creó en [Tutorial: Crear una canalización simple (bucket de S3)](tutorials-simple-s3.md) o [Tutorial: Crear una canalización sencilla (CodeCommit repositorio)](tutorials-simple-codecommit.md).

Va a utilizar una canalización existente con una acción de origen y al menos una estructura de dos etapas, pero no se utilizan artefactos de origen en este ejemplo.

**nota**  
Es posible que tenga que actualizar el rol de servicio que se utiliza en la canalización con otros permisos necesarios para ejecutar esta acción. Para ello, abra la consola AWS Identity and Access Management (IAM), busque el rol y, a continuación, añada los permisos a la política del rol. Para obtener más información, consulte [Agrega permisos al rol de CodePipeline servicio](how-to-custom-role.md#how-to-update-role-new-services).

## Paso 1: Crear la máquina de estados de ejemplo
<a name="tutorials-step-functions-sample"></a>

En la consola de Step Functions, cree una máquina de estados utilizando la plantilla de ejemplo `HelloWorld`. Para obtener instrucciones, consulte [Crea una máquina de estados](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started.html#create-state-machine)en la *Guía para desarrolladores de AWS Step Functions *.

## Paso 2: Agregar una acción de invocación de Step Functions a la canalización
<a name="tutorials-step-functions-pipeline"></a>

Agregue una acción de invocación de Step Functions a la canalización del siguiente modo:

1. Inicie sesión en la CodePipeline consola Consola de administración de AWS y ábrala en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

   Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta.

1. En **Nombre**, elija el nombre de la canalización que desea editar. Esto abre una vista detallada de la canalización, que incluye el estado de cada una de las acciones en cada etapa de la canalización.

1. En la página de detalles de la canalización, elija **Edit**.

1. En la segunda etapa de la canalización sencilla, elija **Editar la etapa**. Elija **Eliminar**. De este modo, eliminará la segunda etapa, ahora que ya no la necesita.

1. En la parte inferior del diagrama, seleccione **\$1 Add stage (Añadir etapa)**.

1. En **Nombre de la etapa**, escriba un nombre, por ejemplo, **Invoke**, y elija **Agregar la etapa**.

1. Elija **\$1 Add action group (Añadir grupo de acciones)**.

1. En **Nombre de la acción**, escriba un nombre; por ejemplo, **Invoke**.

1. En **Proveedor de acción**, elija **AWS Step Functions**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

1. En **Artefactos de entrada**, elija `SourceArtifact`.

1. En **ARN de máquina de estado**, elija el nombre de recurso de Amazon (ARN) de la máquina de estados que creó anteriormente.

1. (Opcional) En **Prefijo de nombre de ejecución**, escriba un prefijo para agregarlo al ID de ejecución de la máquina de estados.

1. En **Tipo de entrada**, elija **Literal**.

1. En **Entrada**, especifique el JSON de entrada que la máquina de estados del ejemplo `HelloWorld` espera usar.
**nota**  
La entrada a la ejecución de la máquina de estados es diferente del término utilizado CodePipeline para describir los artefactos de entrada para las acciones.

   En este ejemplo, especifique el siguiente JSON:

   ```
   {"IsHelloWorldExample": true}
   ```

1. Seleccione **Listo**.

1. En la etapa que está editando, elija **Listo**. En el panel de AWS CodePipeline , elija **Save (Guardar)** y, a continuación, elija **Save (Guardar)** cuando aparezca el mensaje de advertencia.

1. Para enviar los cambios y comenzar una ejecución de la canalización, elija **Release change (Publicar modificación)** y, a continuación, **Release (Publicar)**.

1. En la canalización completada, elija **AWS Step Functions** en la acción de invocación. En la AWS Step Functions consola, consulta el identificador de ejecución de la máquina de estado. El ID indica el nombre de la máquina de estados `HelloWorld` y el ID de ejecución con el prefijo `my-prefix`.

   ```
   arn:aws:states:us-west-2:account-ID:execution:HelloWorld:my-prefix-0d9a0900-3609-4ebc-925e-83d9618fcca1
   ```

# Tutorial: Crear una canalización que se utilice AWS AppConfig como proveedor de despliegue
<a name="tutorials-AppConfig"></a>

En este tutorial, configurará una canalización que entregue archivos de configuración de forma continua AWS AppConfig utilizándolos como proveedor de acciones de despliegue en la fase de despliegue.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para crear artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**Topics**
+ [

## Requisitos previos
](#tutorials-AppConfig-prereq)
+ [

## Paso 1: Crea tus recursos AWS AppConfig
](#tutorials-AppConfig-application)
+ [

## Paso 2: Cargar los archivos en un bucket de origen de S3
](#tutorials-AppConfig-bucket)
+ [

## Paso 3: Crear la canalización
](#tutorials-AppConfig-pipeline)
+ [

## Paso 4: Realizar un cambio en cualquier archivo de origen y verificar la implementación
](#tutorials-AppConfig-verify)

## Requisitos previos
<a name="tutorials-AppConfig-prereq"></a>

Debe seguir los siguientes pasos antes de comenzar:
+ En este ejemplo, se utiliza un origen de S3 para la canalización. Cree o utilice un bucket de Amazon S3 con el control de versiones habilitado. Puede seguir las instrucciones de [Paso 1: creación de un bucket de origen de S3 para la aplicación](tutorials-simple-s3.md#s3-create-s3-bucket) para crear un bucket de S3.

## Paso 1: Crea tus recursos AWS AppConfig
<a name="tutorials-AppConfig-application"></a>

En esta sección, se crean los recursos siguientes.
+ Una *aplicación* AWS AppConfig es una unidad lógica de código que proporciona funciones a sus clientes.
+ Un *entorno* AWS AppConfig es un grupo de AppConfig objetivos de despliegue lógico, como aplicaciones en un entorno beta o de producción.
+ Un *perfil de configuración* es un conjunto de opciones que influyen en el comportamiento de la aplicación. El perfil de configuración permite acceder AWS AppConfig a la configuración en su ubicación almacenada.
+ (Opcional) Una *estrategia de implementación* AWS AppConfig define el comportamiento de una implementación de configuración, por ejemplo, qué porcentaje de clientes deben recibir la nueva configuración implementada en un momento dado durante una implementación.

**Para crear una aplicación, un entorno, un perfil de configuración y una estrategia de implementación**

1. Inicie sesión en Consola de administración de AWS.

1. Siga los pasos de los siguientes temas para crear sus recursos en AWS AppConfig.
   + [Crear una aplicación](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-application.html).
   + [Crear un entorno](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-environment.html).
   + [Cree un perfil AWS CodePipeline de configuración](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html).
   + (Opcional) [Elegir una estrategia de implementación predefinida o crear una propia.](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-deployment-strategy.html)

## Paso 2: Cargar los archivos en un bucket de origen de S3
<a name="tutorials-AppConfig-bucket"></a>

En esta sección, cree su archivo o archivos de configuración. A continuación, comprima y coloque los archivos fuente en el bucket que la canalización utiliza para la etapa de origen.

**Para crear archivos de configuración**

1. Cree un archivo `configuration.json` para cada configuración de cada región. Incluya los siguientes contenidos:

   ```
   Hello World!
   ```

1. Siga estos pasos para comprimir y cargar los archivos de configuración.

**Para comprimir y cargar los archivos fuente**

1. Cree un archivo .zip con los archivos y asigne un nombre al archivo .zip `configuration-files.zip`. Por ejemplo, el archivo.zip puede usar la siguiente estructura:

   ```
   .
   └── appconfig-configurations
       └── MyConfigurations
           ├── us-east-1
           │   └── configuration.json
           └── us-west-2
               └── configuration.json
   ```

1. En la consola de Amazon S3 para su bucket, elija **Cargar** y siga las instrucciones para cargar el archivo .zip.

## Paso 3: Crear la canalización
<a name="tutorials-AppConfig-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una acción de Amazon S3 en la que los artefactos de origen son los archivos para su configuración.
+ Una etapa de despliegue con una acción AppConfig de despliegue.

**Para crear una canalización con el asistente**

1. Inicie sesión Consola de administración de AWS y abra la CodePipeline consola en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyAppConfigPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Advanced settings (Configuración avanzada)**, deje los valores predeterminados y elija **Next (Siguiente)**.

1. En **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **Amazon S3**. En **Bucket**, elija el nombre del bucket de origen de S3. 

   En **Clave de objeto de S3**, escriba el nombre del archivo .zip: `configuration-files.zip`.

   Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: Añadir la etapa de despliegue**:

   1. En **Deploy provider**, elija **AWS AppConfig**. 

   1. En **Aplicación**, elija el nombre de la aplicación en la que creó AWS AppConfig. El campo muestra el ID de la aplicación.

   1. En **Entorno**, elija el nombre del entorno en el que creó AWS AppConfig. El campo muestra el ID de su entorno.

   1. En **Perfil de configuración**, elija el nombre del perfil de configuración en el que creó AWS AppConfig. El campo muestra el ID de su perfil de configuración.

   1. En **Estrategia de implementación**, elija el nombre de su estrategia de implementación. Puede ser una estrategia de despliegue que haya creado AppConfig o una que haya elegido entre las estrategias de despliegue predefinidas AppConfig. El campo muestra el ID de su estrategia de implementación.

   1. En **Ruta de configuración del artefacto de entrada**, introduzca la ruta del archivo. Asegúrese de que la ruta de configuración del artefacto de entrada coincida con la estructura de directorios del archivo.zip del bucket de S3. En este ejemplo, especifique la siguiente ruta de archivo: `appconfig-configurations/MyConfigurations/us-west-2/configuration.json`. 

   1. Elija **Siguiente**.

1. En el **paso 7: Revisar**, revise la información y, a continuación, seleccione **Crear canalización**.

## Paso 4: Realizar un cambio en cualquier archivo de origen y verificar la implementación
<a name="tutorials-AppConfig-verify"></a>

Realice un cambio en los archivos fuente y, a continuación, cárguelos en el bucket. Esto desencadena la ejecución de la canalización. Compruebe que la configuración esté disponible consultando la versión.

# Tutorial: Utilice un clon completo con una fuente de GitHub canalización
<a name="tutorials-github-gitclone"></a>

Puedes elegir la opción de clonación completa para tu acción GitHub fuente en CodePipeline. Usa esta opción para ejecutar CodeBuild comandos para los metadatos de Git en la acción de creación de tu canalización.

**nota**  
La opción de clonación completa que se describe aquí se refiere a especificar si se CodePipeline deben clonar los metadatos del repositorio, que solo pueden ser utilizados por CodeBuild comandos. Para usar un [token de acceso de GitHub usuario](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app) para usarlo en CodeBuild proyectos, siga los pasos que se indican a continuación para instalar el AWS Connector para la GitHub aplicación y, a continuación, deje el campo de instalación de la aplicación en blanco. CodeConnections utilizará el token de acceso de usuario para la conexión.



**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para fabricar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

En este tutorial, crearás una canalización que se conecte a tu GitHub repositorio, utilice la opción de clonación completa para los datos de origen y ejecutará una CodeBuild compilación que clone tu repositorio y ejecute los comandos de Git para el repositorio.

**nota**  
Esta función no está disponible en las regiones de Asia Pacífico (Hong Kong), África (Ciudad del Cabo), Oriente Medio (Baréin), Europa (Zúrich) AWS GovCloud o (EE. UU. Oeste). Para hacer referencia a otras acciones disponibles, consulte [Integraciones de productos y servicios con CodePipeline](integrations.md). Para ver consideraciones sobre esta acción en la región de Europa (Milán), consulte la nota que aparece en [CodeStarSourceConnection para Bitbucket Cloud GitHub, GitHub Enterprise Server, GitLab .com y acciones GitLab autogestionadas](action-reference-CodestarConnectionSource.md).

**Topics**
+ [

## Requisitos previos
](#tutorials-github-gitclone-prereq)
+ [

## Paso 1: Crear un archivo README
](#tutorials-github-gitclone-file)
+ [

## Paso 2: Crear la canalización y compilar el proyecto
](#tutorials-github-gitclone-pipeline)
+ [

## Paso 3: actualice la política CodeBuild de roles de servicio para usar las conexiones
](#tutorials-github-gitclone-rolepolicy)
+ [

## Paso 4: Ver comandos del repositorio en el resultado de la compilación
](#tutorials-github-gitclone-view)

## Requisitos previos
<a name="tutorials-github-gitclone-prereq"></a>

Antes de empezar, debe hacer lo siguiente:
+ Crea un GitHub repositorio con tu GitHub cuenta.
+ Ten tus GitHub credenciales preparadas. Cuando utilices el Consola de administración de AWS para configurar una conexión, se te pedirá que inicies sesión con tus GitHub credenciales. 

## Paso 1: Crear un archivo README
<a name="tutorials-github-gitclone-file"></a>

Tras crear el GitHub repositorio, sigue estos pasos para añadir un archivo README.

1. Inicia sesión en tu GitHub repositorio y elige tu repositorio.

1. Para crear un nuevo archivo, seleccione **Añadir archivo > Crear archivo nuevo**. Asigne un nombre al archivo `README.md`. y añada el siguiente texto.

   ```
   This is a GitHub repository!
   ```

1. Seleccione **Confirmar cambios**.

   Asegúrese de que el archivo `README.md` está en el nivel raíz del repositorio.

## Paso 2: Crear la canalización y compilar el proyecto
<a name="tutorials-github-gitclone-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una conexión a tu GitHub repositorio y a tu acción.
+ Una etapa de creación con una acción de AWS CodeBuild creación.

**Para crear una canalización con el asistente**

1. Inicia sesión en la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyGitHubPipeline**.

1. En **Tipo de canalización**, elija **V1** para los fines de este tutorial. También puede elegir **V2**; sin embargo, tenga en cuenta que los tipos de canalización difieren en cuanto a características y precio. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md).

1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Si opta por utilizar su función de CodePipeline servicio actual, asegúrese de haber añadido el permiso de `codestar-connections:UseConnection` IAM a su política de función de servicio. Para obtener instrucciones sobre la función de CodePipeline servicio, consulte [Añadir permisos a la función de CodePipeline servicio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. Para **Configuración avanzada** deje los valores predeterminados. En **Artifact store** (Almacén de artefactos), elija **Default location** (Ubicación predeterminada) para utilizar el almacén de artefactos predeterminado, como el bucket de artefacto de Amazon S3 que se estableció como predeterminado, para la canalización en la región que seleccionó para esta.
**nota**  
Este no es el bucket de origen para su código fuente. Este es el almacén de artefactos de la canalización. Cada canalización debe tener su propio almacén de artefactos independiente, como un bucket de S3.

   Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de origen**, elija **GitHub (a través de GitHub la aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md). 

      Se instala una aplicación para todas las conexiones a un proveedor en particular. Si ya ha instalado el AWS conector para la GitHub aplicación, elíjalo y omita este paso.
**nota**  
Si desea crear un [token de acceso de usuario](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app), asegúrese de que ya ha instalado el AWS Connector para la GitHub aplicación y, a continuación, deje vacío el campo de instalación de la aplicación. CodeConnections utilizará el token de acceso de usuario para la conexión. Para obtener más información, consulte [Acceder a su proveedor de origen en CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/access-tokens.html).

   1. En **Repository name (Nombre de repositorio)**, elija el nombre de su repositorio de GitHub.

   1. En **Nombre de ramificación**, elija la ramificación de repositorio que desea utilizar.

   1. Asegúrese de que la opción **Start the pipeline on source code change (Iniciar la canalización en el cambio del código fuente)** está seleccionada.

   1. En **Formato de artefacto de salida**, seleccione **Clonación completa** para habilitar la opción de clonación de Git para el repositorio de origen. Solo las acciones proporcionadas por CodeBuild pueden usar la opción de clonación de Git. [Paso 3: actualice la política CodeBuild de roles de servicio para usar las conexiones](#tutorials-github-gitclone-rolepolicy)En este tutorial, utilizarás esta opción para actualizar los permisos de tu rol de servicio de CodeBuild proyectos.

   Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, agregue una etapa de compilación:

   1. En **Build provider (Proveedor de compilación)**, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **Para **Imagen**, escoja: 5.0. aws/codebuild/standard**

   1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Anote el nombre de su función de servicio. CodeBuild Necesitará el nombre del rol para el paso final de este tutorial.

   1. En **Buildspec**, para **Build specifications** (Especificaciones de la compilación), elija **Insert build commands** (Insertar comandos de compilación). Elija **Cambiar a editor** y pegue lo siguiente en **Comandos de compilación**:
**nota**  
En la sección `env` de la especificación de compilación, asegúrese de que el ayudante de credenciales para los comandos de git esté habilitado, como se muestra en este ejemplo.

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git archive --format=zip HEAD > application.zip
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
          - application.zip
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Selecciona **Continuar a CodePipeline**. Esto vuelve a la CodePipeline consola y crea un CodeBuild proyecto que utiliza los comandos de compilación para la configuración. El proyecto de compilación usa un rol de servicio para administrar Servicio de AWS los permisos. Es posible que este paso tarde un par de minutos.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**.

## Paso 3: actualice la política CodeBuild de roles de servicio para usar las conexiones
<a name="tutorials-github-gitclone-rolepolicy"></a>

La ejecución inicial de la canalización fallará porque la función de CodeBuild servicio debe actualizarse con permisos para usar las conexiones. Añada el permiso de IAM de `codestar-connections:UseConnection` a la política de roles de servicio. Para obtener instrucciones sobre cómo actualizar la política en la consola de IAM, consulte [Añade CodeBuild GitClone permisos para las conexiones a Bitbucket, Enterprise Server o .com GitHub GitHub GitLab](troubleshooting.md#codebuild-role-connections).

## Paso 4: Ver comandos del repositorio en el resultado de la compilación
<a name="tutorials-github-gitclone-view"></a>

1. Cuando tu rol de servicio se haya actualizado correctamente, selecciona **Reintentar** en la CodeBuild fase fallida.

1. Después de que la canalización se ejecute correctamente, en la etapa de implementación, elija **Ver detalles**.

   En la página de detalles, elija la pestaña **Registros**. Vea el resultado de la CodeBuild compilación. Los comandos muestran el valor de la variable introducida.

   Los comandos muestran el contenido del archivo `README.md`, muestran los archivos en el directorio, clonan el repositorio, visualizan el registro y archivan el repositorio como un archivo ZIP.

# Tutorial: Utilice un clon completo con una fuente de CodeCommit canalización
<a name="tutorials-codecommit-gitclone"></a>

Puedes elegir la opción de clonación completa para tu acción CodeCommit fuente en CodePipeline. Usa esta opción para permitir el acceso CodeBuild a los metadatos de Git en la acción de creación de tu canalización.

En este tutorial, crearás una canalización que acceda a tu CodeCommit repositorio, usará la opción de clonación completa para los datos de origen y ejecutará una CodeBuild compilación que clona tu repositorio y ejecutará comandos de Git para el repositorio.

**nota**  
CodeBuild las acciones son las únicas acciones posteriores que admiten el uso de los metadatos de Git disponibles con la opción de clonación de Git. Además, aunque tu canalización puede contener acciones multicuenta, la CodeCommit acción y la CodeBuild acción deben estar en la misma cuenta para que la opción de clonación completa funcione correctamente.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para guardar artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**Topics**
+ [

## Requisitos previos
](#tutorials-codecommit-gitclone-prereq)
+ [

## Paso 1: Crear un archivo README
](#tutorials-codecommit-gitclone-file)
+ [

## Paso 2: Crear la canalización y compilar el proyecto
](#tutorials-codecommit-gitclone-pipeline)
+ [

## Paso 3: actualice la política CodeBuild de roles de servicio para clonar el repositorio
](#tutorials-codecommit-gitclone-rolepolicy)
+ [

## Paso 4: Ver comandos del repositorio en el resultado de la compilación
](#tutorials-codecommit-gitclone-view)

## Requisitos previos
<a name="tutorials-codecommit-gitclone-prereq"></a>

Antes de empezar, debes crear un CodeCommit repositorio en la misma AWS cuenta y región que tu canalización.

## Paso 1: Crear un archivo README
<a name="tutorials-codecommit-gitclone-file"></a>

Siga estos pasos para añadir un archivo README a su repositorio de origen. El archivo README proporciona un ejemplo de archivo fuente para que lo lea la acción CodeBuild descendente.

**Para añadir un archivo README**

1. Inicie sesión en su repositorio y elija su repositorio.

1. Para crear un nuevo archivo, seleccione **Añadir archivo > Crear archivo**. Asigne un nombre al archivo `README.md`. y añada el siguiente texto.

   ```
   This is a CodeCommit repository!
   ```

1. Seleccione **Confirmar cambios**.

   Asegúrese de que el archivo `README.md` está en el nivel raíz del repositorio.

## Paso 2: Crear la canalización y compilar el proyecto
<a name="tutorials-codecommit-gitclone-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una acción de CodeCommit origen.
+ Una etapa de construcción con una acción de AWS CodeBuild construcción.

**Para crear una canalización con el asistente**

1. Inicia sesión en la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyCodeCommitPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Service role (Rol de servicio)**, realice una de las operaciones siguientes:
   + Elija **Existing service role (Rol de servicio existente)**
   + Elija su función CodePipeline de servicio actual. El rol debe tener el permiso de IAM de `codecommit:GetRepository` para la política de rol de servicio. Consulte [Añadir permisos al rol CodePipeline de servicio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. Para **Configuración avanzada** deje los valores predeterminados. Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, haga lo siguiente:

   1. En **Source provider (Proveedor de código fuente)**, elija **CodeCommit**.

   1. En **Nombre de repositorio**, elija el nombre de su repositorio.

   1. En **Nombre de ramificación**, elija el nombre de su ramificación.

   1. Asegúrese de que la opción **Start the pipeline on source code change (Iniciar la canalización en el cambio del código fuente)** está seleccionada.

   1. En **Formato de artefacto de salida**, seleccione **Clonación completa** para habilitar la opción de clonación de Git para el repositorio de origen. Solo las acciones proporcionadas por CodeBuild pueden usar la opción de clonación de Git. 

   Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, haga lo siguiente:

   1. En **Build provider (Proveedor de compilación)**, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **En **Imagen**, escogeaws/codebuild/standard: 5.0.**

   1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Anote el nombre de su función de servicio. CodeBuild Necesitará el nombre del rol para el paso final de este tutorial.

   1. En **Buildspec**, para **Build specifications** (Especificaciones de la compilación), elija **Insert build commands** (Insertar comandos de compilación). Elija **Cambiar a editor** y en **Comandos de compilación** pegue el código siguiente:

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git describe --all
        #post_build:
          #commands:
            # - command
            # - command
      #artifacts:
        #files:
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Selecciona **Continuar a CodePipeline**. De este modo, volverá a la CodePipeline consola y se creará un CodeBuild proyecto que utilizará los comandos de compilación para la configuración. El proyecto de compilación utiliza un rol de servicio para administrar los permisos del Servicio de AWS . Es posible que este paso tarde un par de minutos.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**.

## Paso 3: actualice la política CodeBuild de roles de servicio para clonar el repositorio
<a name="tutorials-codecommit-gitclone-rolepolicy"></a>

La ejecución inicial de la canalización fallará porque tendrás que actualizar la función de CodeBuild servicio con permisos para extraerla de tu repositorio.

Añada el permiso de IAM de `codecommit:GitPull` a la política de roles de servicio. Para obtener instrucciones sobre cómo actualizar la política en la consola de IAM, consulte [Añada CodeBuild GitClone permisos para las acciones CodeCommit de origen](troubleshooting.md#codebuild-role-codecommitclone).

## Paso 4: Ver comandos del repositorio en el resultado de la compilación
<a name="tutorials-codecommit-gitclone-view"></a>

**Para ver el resultado de la compilación**

1. Cuando tu rol de servicio se haya actualizado correctamente, selecciona **Reintentar** en la CodeBuild fase fallida.

1. Después de que la canalización se ejecute correctamente, en la etapa de implementación, elija **Ver detalles**.

   En la página de detalles, elija la pestaña **Registros**. Vea el resultado de la CodeBuild compilación. Los comandos muestran el valor de la variable introducida.

   Los comandos muestran el contenido del archivo `README.md`, muestran los archivos en el directorio, clonan el repositorio, visualizan el registro y ejecutan `git describe --all`. 

# Tutorial: Crear una canalización con acciones AWS CloudFormation StackSets de despliegue
<a name="tutorials-stackset-deployment"></a>

En este tutorial, utilizará la AWS CodePipeline consola para crear una canalización con acciones de despliegue para crear un conjunto de pilas y crear instancias de pila. Cuando se ejecuta la canalización, la plantilla crea un conjunto de pilas y también crea y actualiza las instancias en las que se implementa el conjunto de pilas.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para crear artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

Hay dos formas de gestionar los permisos de un conjunto apilado: las funciones de IAM autogestionadas y AWS las administradas mediante funciones de IAM. En este tutorial, se proporcionan ejemplos con permisos autoadministrados.

Para utilizar Stacksets de la forma más eficaz posible CodePipeline, debes tener una idea clara de los conceptos subyacentes CloudFormation StackSets y de cómo funcionan. Consulta [StackSets los conceptos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html) en la Guía del *AWS CloudFormation usuario*.

**Topics**
+ [

## Requisitos previos
](#tutorials-stackset-deployment-prereq)
+ [

## Paso 1: Cargue la AWS CloudFormation plantilla de muestra y el archivo de parámetros
](#tutorials-stackset-deployment-upload)
+ [

## Paso 2: Crear la canalización
](#tutorials-stackset-action-pipeline)
+ [

## Paso 3: Ver la implementación inicial
](#tutorials-stackset-action-initial)
+ [

## Paso 4: Añadir una CloudFormationStackInstances acción
](#tutorials-stacksets-instances)
+ [

## Paso 5: Ver los recursos del conjunto de pilas para su implementación
](#tutorials-stacksets-view)
+ [

## Paso 6: Actualizar el conjunto de pilas
](#tutorials-stacksets-update)

## Requisitos previos
<a name="tutorials-stackset-deployment-prereq"></a>

Para las operaciones de conjuntos apilados, se utilizan dos cuentas diferentes: una cuenta de administración y una cuenta de destino. Los conjuntos de pilas se crean en la cuenta de administrador. Se crean pilas individuales que pertenecen a un conjunto de pilas de la cuenta de destino.

**Para crear un rol de administrador con su cuenta de administrador**
+ Siga las instrucciones de [Configuración de permisos básicos para operaciones con conjuntos de pilas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup). Su rol debe llamarse **`AWSCloudFormationStackSetAdministrationRole`**.

**Para crear el rol de servicio en la cuenta de destino**
+ Cree un rol de servicio en la cuenta de destino que confíe en la cuenta de administrador. Siga las instrucciones de [Configuración de permisos básicos para operaciones con conjuntos de pilas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup). Su rol debe llamarse **`AWSCloudFormationStackSetExecutionRole`**. 

## Paso 1: Cargue la AWS CloudFormation plantilla de muestra y el archivo de parámetros
<a name="tutorials-stackset-deployment-upload"></a>

Cree un bucket de origen para los archivos de parámetros y plantillas del conjunto de pilas. Descargue el archivo de AWS CloudFormation plantilla de ejemplo, configure un archivo de parámetros y comprima los archivos antes de cargarlos en su bucket de código fuente de S3.

**nota**  
Asegúrese de comprimir los archivos de origen antes de subirlos a su bucket de origen de S3, incluso si el único archivo fuente es la plantilla.



**Para crear un bucket de origen de S3**

1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Elija **Crear bucket**.

1. En **Nombre del bucket**, escriba un nombre para el bucket.

   En **Región** la región en la que desea crear la canalización. Elija **Crear bucket**.

1. Una vez creado el bucket, aparecerá un banner donde se indicará que la operación se ha realizado correctamente. Elija **Go to bucket details (Acceder a los detalles del bucket)**.

1. En la pestaña **Properties (Propiedades)**, elija **Versioning (Control de versiones)**. Elija **Enable versioning (Habilitar control de versiones)** y haga clic en **Save (Guardar)**.

**Para crear el archivo AWS CloudFormation de plantilla**

1. Descargue el siguiente archivo de plantilla de ejemplo para generar la CloudTrail configuración de los conjuntos de pilas:[https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml](https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml).

1. Guarde el archivo como `template.yml`.

**Para crear el archivo parameters.txt**

1. Cree un archivo con los parámetros para la implementación. Los parámetros son valores que desea actualizar en su pila en tiempo de ejecución. El siguiente archivo de ejemplo actualiza los parámetros de la plantilla del conjunto de pilas para permitir la validación del registro y los eventos globales.

   ```
   [
     {
       "ParameterKey": "EnableLogFileValidation",
       "ParameterValue": "true"
     }, 
     {
       "ParameterKey": "IncludeGlobalEvents",
       "ParameterValue": "true"
     }
   ]
   ```

1. Guarde el archivo como `parameters.txt`.

**Para crear el archivo accounts.txt**

1. Cree un archivo con las cuentas en las que desee crear las instancias, como se muestra en el siguiente archivo de ejemplo.

   ```
   [
       "111111222222","333333444444"
   ]
   ```

1. Guarde el archivo como `accounts.txt`.

**Para crear y cargar los archivos de origen**

1. Combine los archivos .zip en un solo archivo ZIP. Sus archivos deberían aparecer así en el archivo ZIP.

   ```
   template.yml
   parameters.txt
   accounts.txt
   ```

1. Cargue el archivo ZIP en el bucket de S3. Este archivo es el artefacto de origen creado por el asistente **Create Pipeline** para su acción de implementación en CodePipeline.

## Paso 2: Crear la canalización
<a name="tutorials-stackset-action-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una fase de origen con una acción de origen de S3 en la que el artefacto de origen es el archivo de plantilla y cualquier archivo de origen de respaldo.
+ Una etapa de despliegue con una acción de despliegue del conjunto de CloudFormation pilas que crea el conjunto de pilas.
+ Una etapa de despliegue con una acción de despliegue de instancias CloudFormation apiladas que crea las pilas e instancias dentro de las cuentas de destino.

**Para crear una canalización con una acción CloudFormationStackSet**

1. Inicia sesión en la CodePipeline consola Consola de administración de AWS y ábrela en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyStackSetsPipeline**.

1. En **Tipo de canalización**, elija **V1** para los fines de este tutorial. También puede elegir **V2**; sin embargo, tenga en cuenta que los tipos de canalización difieren en cuanto a características y precio. Para obtener más información, consulte [Tipos de canalización](pipeline-types.md).

1. En **Función de servicio**, elija **Nueva función de servicio** CodePipeline para poder crear una función de servicio en IAM.

1. En **Almacén de artefactos**, deje los valores predeterminados.
**nota**  
Este no es el bucket de origen para su código fuente. Este es el almacén de artefactos de la canalización. Cada canalización debe tener su propio almacén de artefactos independiente, como un bucket de S3. Al crear o editar una canalización, debes tener una cubeta de artefactos en la región de la canalización y una cubeta de artefactos por cada AWS región en la que ejecutes una acción.  
Para obtener más información, consulte [Artefactos de entrada y salida](welcome-introducing-artifacts.md) y [CodePipeline referencia de estructura de tubería](reference-pipeline-structure.md).

   Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, en **Proveedor de origen**, elija **Amazon S3**.

1. En **Bucket**, introduzca el bucket de origen de S3 creado para este tutorial, por ejemplo `BucketName`. En **Clave de objeto de S3**, escriba la ruta y el nombre del archivo ZIP, como `MyFiles.zip`.

1. Elija **Siguiente**.

1. En **Paso 4: agregar la etapa de compilación**, elija **Omitir la etapa de compilación** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En el **paso 6: añadir la fase de despliegue**:

   1. En **Proveedor de implementación**, elija **Conjunto de pilas de AWS CloudFormation )**.

   1. En **Nombre de conjunto de pilas**, escriba un nombre para el conjunto de pilas. Este es el nombre del conjunto de pilas que crea la plantilla.
**nota**  
Anote el nombre del conjunto de pilas. La usarás cuando agregues la segunda acción de StackSets despliegue a tu canalización.

   1. En **Ruta de plantilla**, introduzca el nombre del artefacto y la ruta del archivo donde subió el archivo de plantilla. Por ejemplo, introduzca lo siguiente utilizando el el nombre del artefacto de origen por defecto `SourceArtifact`.

      ```
      SourceArtifact::template.yml
      ```

   1. En **Destinos de implementación**, introduzca el nombre del artefacto y la ruta del archivo donde subió el archivo de cuentas. Por ejemplo, introduzca lo siguiente utilizando el el nombre del artefacto de origen por defecto `SourceArtifact`.

      ```
      SourceArtifact::accounts.txt
      ```

   1. En **Destino de despliegue Regiones de AWS**, introduce una región para el despliegue de tu instancia de pila inicial, por ejemplo`us-east-1`.

   1. Expanda **Opciones de implementación**. En **Parámetros**, introduzca el nombre del artefacto y la ruta del archivo donde cargó el archivo de parámetros. Por ejemplo, introduzca lo siguiente utilizando el el nombre del artefacto de origen por defecto `SourceArtifact`.

      ```
      SourceArtifact::parameters.txt
      ```

      Para introducir los parámetros como una entrada literal en lugar de como una ruta de archivo, introduzca lo siguiente:

      ```
      ParameterKey=EnableLogFileValidation,ParameterValue=true
      ParameterKey=IncludeGlobalEvents,ParameterValue=true
      ```

   1. En **Capacidades**, elija CAPABILITY\$1IAM y CAPABILITY\$1NAMED\$1IAM.

   1. En **Modelo de permiso**, elija SELF\$1MANAGED.

   1. En **Porcentaje de tolerancia a errores**, introduzca `20`.

   1. En **Porcentaje máximo simultáneo**, introduzca `25`.

   1. Elija **Siguiente**.

   1. En **Paso 7: revisión**, elija **Crear canalización**. Aparece su canalización. 

   1. Permita que su canalización se ejecute. 

## Paso 3: Ver la implementación inicial
<a name="tutorials-stackset-action-initial"></a>

Vea los recursos y el estado de su implementación inicial. Tras comprobar que la implementación ha creado correctamente el conjunto de pilas, puede añadir la segunda acción a la fase **Deploy /Implementación)**.

**Para ver los recursos**

1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Elige la CloudFormation acción de la **CloudFormationStackSet**acción de tu proceso. La plantilla, los recursos y los eventos de tu conjunto de pilas se muestran en la CloudFormation consola.

1. En el panel de navegación izquierdo, selecciona **StackSets**. En la lista, elija el nuevo conjunto de pilas.

1. Elija la pestaña **Instancias de la pila**. Verifique que se haya creado una instancia de pila para cada cuenta que haya proporcionado en la región us-east-1. Compruebe que el estado de cada instancia de pila sea `CURRENT`.

## Paso 4: Añadir una CloudFormationStackInstances acción
<a name="tutorials-stacksets-instances"></a>

Crea una siguiente acción en tu proceso que permita CloudFormation StackSets crear las instancias de la pila restantes.

**Para crear una acción siguiente en su canalización**

1. Abre la CodePipeline consola en. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

   En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Elija esta opción para editar la canalización. La canalización se muestra en modo de **edición**. 

1. En la etapa **Implementar**, elija **Editar**.

1. En la acción de implementación de **Conjunto de pilas de AWS CloudFormation CloudFormation**, seleccione **Añadir grupo de acciones**.

1. En la página **Editar acción**, añada los detalles de la acción:

   1. En **Nombre de la acción**, escriba un nombre para la acción.

   1. En **Proveedor de acciones**, elija **Instancias de pila de AWS CloudFormation )**.

   1. En **Artefactos de entrada**, elija **SourceArtifact**.

   1. En **Nombre de conjunto de pilas**, introduzca el nombre para el conjunto de pilas. Este es el nombre del conjunto de pilas proporcionado en la primera acción.

   1. En **Destinos de implementación**, introduzca el nombre del artefacto y la ruta del archivo donde subió el archivo de cuentas. Por ejemplo, introduzca lo siguiente utilizando el el nombre del artefacto de origen por defecto `SourceArtifact`.

      ```
      SourceArtifact::accounts.txt
      ```

   1. En **Destino de despliegue Regiones de AWS**, introduce las regiones en las que se desplegarán las instancias de pila restantes, por ejemplo, de la `eu-central-1` siguiente manera: `us-east-2`

      ```
      us-east2, eu-central-1
      ```

   1. En **Porcentaje de tolerancia a errores**, introduzca `20`.

   1. En **Porcentaje máximo simultáneo**, introduzca `25`.

   1. Seleccione **Save**.

   1. Publica un cambio manualmente. La canalización actualizada se muestra con dos acciones en la etapa de implementación.

## Paso 5: Ver los recursos del conjunto de pilas para su implementación
<a name="tutorials-stacksets-view"></a>

Puede ver los recursos y el estado de su implementación del conjunto de pilas.

**Para ver los recursos**

1. Abra la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En **Canalizaciones**, elija la canalización y luego **Ver**. El diagrama muestra las etapas de código fuente e implementación de la canalización.

1. Elige la CloudFormation acción de la **`AWS CloudFormation Stack Instances`**acción de tu proceso. La plantilla, los recursos y los eventos de tu conjunto de pilas se muestran en la CloudFormation consola.

1. En el panel de navegación izquierdo, selecciona **StackSets**. En la lista, elija el conjunto de pilas.

1. Elija la pestaña **Instancias de la pila**. Compruebe que todas las instancias de pila restantes de cada cuenta que haya proporcionado se hayan creado o actualizado en las regiones esperadas. Compruebe que el estado de cada instancia de pila sea `CURRENT`.

## Paso 6: Actualizar el conjunto de pilas
<a name="tutorials-stacksets-update"></a>

Actualice su conjunto de pilas e impleméntela en las instancias. En este ejemplo, también cambia los objetivos de implementación que desea designar para la actualización. Las instancias que no forman parte de la actualización pasan a un estado desactualizado.

1. Abre la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En **Canalizaciones**, elija la canalización y luego **Editar**. En la etapa **Implementar**, elija **Editar**.

1. Elija editar la acción **Conjunto de pila de AWS CloudFormation )** en su canalización. En **Descripción**, sobrescriba la descripción existente por una nueva descripción para el conjunto de pilas.

1. Elija editar la acción **Instancias de pila de AWS CloudFormation )** en su canalización. En **Deployment target Regiones de AWS**, elimine el `us-east-2` valor que se ingresó al crear la acción.

1. Guarde los cambios. Elija **Publicar modificación** para ejecutar su canalización.

1. Abra su acción en CloudFormation. Selecciona la pestaña de **StackSet información**. En la **StackSet descripción**, compruebe que se muestra la nueva descripción.

1. Elija la pestaña **Instancias de la pila**. En **Estado**, verifique que el estado de las instancias de la pila en us-east-2 sea `OUTDATED`.

# Tutorial: Cómo crear una regla de verificación de variables para una canalización como una condición de entrada
<a name="tutorials-varcheckrule"></a>

En este tutorial, configurará una canalización que entregue archivos de forma continua utilizando GitHub como proveedor de acciones de origen en la etapa de origen. La canalización completa detecta cambios cuando se realiza un cambio en los archivos de código fuente en el repositorio de código fuente. La canalización se ejecuta y, a continuación, compara las variables de salida con el nombre del repositorio de origen y el nombre de la ramificación proporcionados en la condición de entrada a la etapa de compilación.

**importante**  
Como parte de la creación de una canalización, se utilizará un depósito de artefactos de S3 proporcionado por el cliente CodePipeline para crear artefactos. (Es diferente del bucket que se usa para una acción de origen de S3). Si el depósito de artefactos de S3 está en una cuenta diferente a la de tu canalización, asegúrate de que el depósito de artefactos de S3 pertenezca a una Cuentas de AWS persona segura y fiable.

**importante**  
Muchas de las acciones que añades a la canalización en este procedimiento implican AWS recursos que debes crear antes de crear la canalización. AWS Los recursos para las acciones de origen siempre deben crearse en la misma AWS región en la que se creó la canalización. Por ejemplo, si creas tu canalización en la región EE.UU. Este (Ohio), tu CodeCommit repositorio debe estar en la región EE.UU. Este (Ohio).   
Puedes añadir acciones entre regiones al crear tu canalización. AWS los recursos para las acciones entre regiones deben estar en la misma AWS región en la que planeas ejecutar la acción. Para obtener más información, consulte [Añadir una acción interregional en CodePipeline](actions-create-cross-region.md).

En este ejemplo, se utiliza la canalización de ejemplo con una acción de origen GitHub (versión 2) y una acción de CodeBuild compilación en las que la condición de entrada de la etapa de compilación comprobará si hay variables.

## Requisitos previos
<a name="tutorials-varcheckrule-prereq"></a>

Antes de empezar, debe hacer lo siguiente:
+ Crea un GitHub repositorio con tu GitHub cuenta.
+ Ten tus GitHub credenciales preparadas. Cuando utilices el Consola de administración de AWS para configurar una conexión, se te pedirá que inicies sesión con tus GitHub credenciales. 
+ Una conexión a tu repositorio para configurarla GitHub (mediante una GitHub aplicación) como la acción de origen de tu canalización. Para crear una conexión con tu GitHub repositorio, consulta[GitHub conexiones](connections-github.md).

## Paso 1: Cree un archivo fuente de muestra y agréguelo a su GitHub repositorio
<a name="tutorials-varcheckrule-push"></a>

En esta sección, debe crear y agregar los archivos de código fuente al repositorio que utiliza la canalización para la etapa de origen. Para este ejemplo, va a generar y agregar lo siguiente: 
+ Un archivo `README.md`.

Tras crear el GitHub repositorio, sigue estos pasos para añadir el archivo README.

1. Inicia sesión en tu GitHub repositorio y elige tu repositorio.

1. Para crear un nuevo archivo, seleccione **Agregar el archivo** y, a continuación, **Crear nuevo archivo**. Asigne un nombre al archivo `README.md` y agregue el siguiente texto.

   ```
   This is a GitHub repository!
   ```

1. Seleccione **Confirmar cambios**. Para los fines de este tutorial, agregue un mensaje de confirmación que contenga la palabra “Update” en mayúscula, como en el siguiente ejemplo:

   ```
   Update to source files
   ```
**nota**  
La verificación de reglas para cadenas distingue entre mayúsculas y minúsculas.

   Asegúrese de que el archivo `README.md` está en el nivel raíz del repositorio.

## Paso 2: Crear la canalización
<a name="tutorials-varcheckrule-create-pipeline"></a>

En esta sección, debe crear una canalización con las siguientes acciones:
+ Una etapa de origen con una conexión a tu GitHub repositorio y a tu acción.
+ Una etapa de CodeBuild compilación en la que la etapa tiene una condición de entrada configurada para la regla de verificación de variables.

**Para crear una canalización con el asistente**

1. Inicie sesión en la CodePipeline consola en [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. En la página **Bienvenido**, **Introducción** o en la página **Canalizaciones**, elija **Crear canalización**.

1. En la página **Paso 1: elección de la opción de creación**, en **Opciones de creación**, seleccione la opción **Crear una canalización personalizada**. Elija **Siguiente**.

1. En **Paso 2: elegir la configuración de la canalización**, en **Nombre de la canalización**, escriba **MyVarCheckPipeline**.

1. CodePipeline proporciona tuberías de tipo V1 y V2, que difieren en características y precio. El tipo V2 es el único tipo que puede elegir en la consola. Para obtener más información, consulte [Tipos de canalización](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obtener información sobre los precios de CodePipeline, consulte [Precios](https://aws.amazon.com/codepipeline/pricing/).

1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Si opta por utilizar su función de CodePipeline servicio actual, asegúrese de haber añadido el permiso de `codeconnections:UseConnection` IAM a su política de función de servicio. Para obtener instrucciones sobre la función de CodePipeline servicio, consulte [Añadir permisos a la función de CodePipeline servicio](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services).

1. Para **Configuración avanzada** deje los valores predeterminados.

   Elija **Siguiente**.

1. En la página **Paso 3: agregar la etapa de origen**, agregue una etapa de origen:

   1. En **Proveedor de origen**, elija **GitHub(a través de GitHub la aplicación)**.

   1. En **Conexión**, seleccione una conexión existente o cree una nueva. Para crear o gestionar una conexión para la acción GitHub de origen, consulte[GitHub conexiones](connections-github.md).

   1. En **Repository name (Nombre de repositorio)**, elija el nombre de su repositorio de GitHub .

   1. En **Nombre de ramificación**, elija la ramificación de repositorio que desea utilizar.

   1. Compruebe que la opción **Sin desencadenador** esté seleccionada.

   Elija **Siguiente**.

1. En **Paso 4: agregación de la etapa de compilación**, agregue una etapa de compilación:

   1. En **Build provider (Proveedor de compilación)**, elija **AWS CodeBuild**. En el campo **Region (Región)** conserve el valor predeterminado de la región de la canalización.

   1. Elija **Crear proyecto**.

   1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación.

   1. En **Environment image (Imagen de entorno)**, elija **Managed image (Imagen administrada)**. En **Operating system (Sistema operativo)**, elija **Ubuntu**.

   1. En **Runtime**, elija **Standard (Estándar)**. **En **Imagen**, escoja: 5.0. aws/codebuild/standard**

   1. En **Service role (Rol de servicio)**, elija **New service role (Nuevo rol de servicio)**.
**nota**  
Anote el nombre de su función de servicio. CodeBuild Necesitará el nombre del rol para el paso final de este tutorial.

   1. En **Buildspec**, para **Build specifications** (Especificaciones de la compilación), elija **Insert build commands** (Insertar comandos de compilación). Elija **Cambiar a editor** y pegue lo siguiente en **Comandos de compilación**:

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. Selecciona **Continuar a CodePipeline**. Esto vuelve a la CodePipeline consola y crea un CodeBuild proyecto que utiliza los comandos de compilación para la configuración. El proyecto de compilación usa un rol de servicio para administrar Servicio de AWS los permisos. Es posible que este paso tarde un par de minutos.

   1. Elija **Siguiente**.

1. En **Paso 5: agregación de la etapa de prueba**, elija **Omitir la etapa de prueba** y, a continuación, acepte el mensaje de advertencia eligiendo **Omitir** una vez más. 

   Elija **Siguiente**.

1. En la página **Paso 6: Añadir fase de despliegue**, seleccione **Omitir fase de despliegue** y, a continuación, acepte el mensaje de advertencia seleccionando **Omitir** de nuevo. Elija **Siguiente**.

1. En el **paso 7: Revisar**, selecciona **Crear canalización**.

## Paso 2: edición de la etapa de compilación para agregar la condición y la regla
<a name="tutorials-varcheckrule-create-condition"></a>

En este paso, va a editar la etapa para agregar una condición de entrada a la regla de verificación de variables.

1. Seleccione su canalización y, a continuación, elija **Editar**. Elija agregar una regla de entrada en la etapa de compilación. 

   En **Proveedor de reglas**, elige **VariableCheck**.

1. En **Variable**, introduzca la variable o variables que desee verificar. En **Valor**, introduzca el valor de la cadena para compararlo con la variable resuelta. En las siguientes pantallas de ejemplo, se crea una regla para una verificación “igual a” y otra regla para una verificación “contiene”.  
![\[La página de creación de reglas para la verificación de la variable “igual a”\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/varcheck-tut-create-rule-equals.png)  
![\[La página de creación de reglas para la verificación de la variable “contiene”\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/varcheck-tut-create-rule-contains.png)

1. Seleccione **Save**. 

   Seleccione **Listo**.

## Paso 3: ejecución de la canalización y visualización de las variables resueltas
<a name="tutorials-varcheckrule-run"></a>

En este paso, va a ver los valores resueltos y los resultados de la regla de verificación de variables.

1. Vea la ejecución resuelta una vez que la verificación de reglas se haya realizado correctamente, tal y como se muestra en el siguiente ejemplo.  
![\[La ejecución realizada correctamente\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/varcheck-tut-run-succeeded.png)

1. Vea la información de las variables en la pestaña **Línea temporal**.   
![\[La página de historial que muestra la pestaña Línea temporal con variables verificadas correctamente\]](http://docs.aws.amazon.com/es_es/codepipeline/latest/userguide/images/varcheck-tut-history.png)