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.

# 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.