# Implementación de aplicaciones en Amazon EC2
<a name="deploying.applications"></a>

Puede usar CloudFormation para instalar, configurar e iniciar automáticamente aplicaciones en instancias de Amazon EC2. Esto le permite duplicar fácilmente implementaciones y actualizar instalaciones existentes sin conectarse directamente a la instancia, lo que permite ahorrar mucho tiempo y esfuerzo.

CloudFormation incluye un conjunto de scripts auxiliares (`cfn-init`, `cfn-signal`, `cfn-get-metadata` y `cfn-hup`) que se basan en `cloud-init`. Se llama a estos scripts auxiliares desde las plantillas de CloudFormation para instalar, configurar y actualizar aplicaciones en instancias Amazon EC2 que se encuentran en la misma plantilla. Para obtener más información, consulte [Referencia de scripts auxiliares de CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html) en la *Guía de referencia de plantillas de CloudFormation*.

En el [tutorial de introducción](gettingstarted.walkthrough.md), creó un servidor web sencillo utilizando `UserData` con un script de bash básico. Si bien esto funcionó para una página sencilla de “Hello World”, las aplicaciones reales suelen necesitar una configuración más sofisticada, que incluya:
+ Varios paquetes de software instalados en el orden correcto.
+ Archivos de configuración complejos creados con contenido específico.
+ Servicios iniciados y configurados para iniciarse automáticamente.
+ Gestión de errores y validación del proceso de configuración.

Los scripts auxiliares de CloudFormation proporcionan una forma más sólida y sostenible de configurar las instancias de EC2 en comparación con los scripts de bash básicos en `UserData`. El script auxiliar `cfn-init` lee los datos de configuración de los metadatos de la plantilla y los aplica sistemáticamente a la instancia.

En este tutorial, aprenderá a utilizar el script auxiliar `cfn-init` y a supervisar el proceso de arranque.

**nota**  
CloudFormation es gratuito, pero se le cobrarán los recursos de Amazon EC2 que cree. Sin embargo, si es la primera vez que utiliza AWS, puede aprovechar el [nivel gratuito](https://aws.amazon.com/free/) para minimizar o eliminar los costos durante este proceso de aprendizaje.

**Topics**
+ [Requisitos previos](#bootstrapping-tutorial-prerequisites)
+ [Descripción de los conceptos de arranque](#bootstrapping-tutorial-understand-concepts)
+ [Inicio con un ejemplo sencillo de arranque](#bootstrapping-tutorial-simple-example)
+ [Cómo agregar archivos y comandos](#bootstrapping-tutorial-add-complexity)
+ [Cómo agregar la seguridad a la red](#bootstrapping-tutorial-security-group)
+ [La plantilla de arranque completa](#bootstrapping-tutorial-complete-template)
+ [Creación de la pila con la consola](#bootstrapping-tutorial-create-stack)
+ [Supervisión del proceso de arranque](#bootstrapping-tutorial-validate-bootstrap)
+ [Prueba del servidor web arrancado](#bootstrapping-tutorial-test-web-server)
+ [Solución de problemas de arranque](#bootstrapping-tutorial-troubleshooting)
+ [Eliminar recursos](#bootstrapping-tutorial-clean-up)
+ [Siguientes pasos](#bootstrapping-tutorial-next-steps)

## Requisitos previos
<a name="bootstrapping-tutorial-prerequisites"></a>
+ Debe haber completado el tutorial [Creación de su primera pila](gettingstarted.walkthrough.md) o una experiencia equivalente con los conceptos básicos de CloudFormation.
+ Debe tener acceso a una Cuenta de AWS con un usuario o rol de IAM que tenga permisos para usar Amazon EC2 y CloudFormation, o acceso de usuario administrativo.
+ Debe tener una nube privada virtual (VPC) que tenga acceso a Internet. Esta plantilla de tutorial requiere una VPC predeterminada, que se incluye automáticamente con las Cuentas de AWS más recientes. Si no tiene una VPC predeterminada o si se ha eliminado, consulte la sección de solución de problemas en el tutorial [Creación de su primera pila](gettingstarted.walkthrough.md) para ver soluciones alternativas.

## Descripción de los conceptos de arranque
<a name="bootstrapping-tutorial-understand-concepts"></a>

Vamos a describir los conceptos clave que hacen que el arranque funcione antes de crear la plantilla.

### El script auxiliar `cfn-init`
<a name="bootstrapping-tutorial-cfn-init-overview"></a>

CloudFormation proporciona scripts auxiliares de Python que puede utilizar para instalar software e iniciar servicios en una instancia de Amazon EC2. El script `cfn-init` lee los metadatos de los recursos de su plantilla y aplica la configuración a su instancia.

El proceso funciona de la siguiente manera:

1. Define la configuración en la sección `Metadata` de su recurso de EC2.

1. Llama a `cfn-init` desde el script `UserData`.

1. `cfn-init` lee los metadatos y aplica la configuración.

1. La instancia se configura de acuerdo con sus especificaciones.

### Estructura de los metadatos
<a name="bootstrapping-tutorial-metadata-structure"></a>

La configuración se define en una estructura específica dentro de su instancia de EC2.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:                       # Metadata section for the resource
      AWS::CloudFormation::Init:    # Required key that cfn-init looks for
        config:                     # Configuration name (you can have multiple)
          packages:                 # Install packages
          files:                    # Create files
          commands:                 # Run commands
          services:                 # Start/stop services
```

El script `cfn-init` procesa estas secciones en un orden específico: paquetes, grupos, usuarios, orígenes, archivos, comandos y, a continuación, servicios.

## Inicio con un ejemplo sencillo de arranque
<a name="bootstrapping-tutorial-simple-example"></a>

Comencemos con un ejemplo mínimo de arranque que simplemente instale e inicie Apache.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:                 # Install Apache web server
            yum:
              httpd: []
          services:                 # Start Apache and enable it to start on boot
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      UserData: !Base64             # Script that runs when instance starts
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource EC2Instance --region ${AWS::Region}
```

En este ejemplo sencillo se ilustran los conceptos básicos:
+ La sección `packages` instala el paquete `httpd` usando yum. Esto funciona en Amazon Linux y en otras distribuciones de Linux que utilizan yum.
+ La sección `services` garantiza que `httpd` se inicie y ejecute automáticamente.
+ `UserData` instala las herramientas de arranque más recientes y llama a `cfn-init`.

## Cómo agregar archivos y comandos
<a name="bootstrapping-tutorial-add-complexity"></a>

Ahora, para mejorar nuestro ejemplo, vamos a agregar una página web personalizada y un archivo de registro en el directorio `/var/log` de la instancia de EC2.

### Creación de archivos
<a name="bootstrapping-tutorial-files-section"></a>

La sección `files` le permite crear archivos en la instancia con contenido específico. La barra vertical (`|`) le permite pasar un bloque literal de texto (código HTML) como contenido del archivo (`/var/www/html/index.html`).

```
files:
  /var/www/html/index.html:
    content: |
      <body>
        <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
      </body>
```

### Ejecución de comandos
<a name="bootstrapping-tutorial-commands-section"></a>

La sección `commands` le permite ejecutar comandos del intérprete de comandos durante el proceso de arranque. Este comando crea un archivo de registro en `/var/log/welcome.txt` en la instancia de EC2. Para verlo, necesita un par de claves de Amazon EC2 que utilizará para el acceso mediante SSH y un rango de direcciones IP que se pueda utilizar para acceder mediante SSH a la instancia (no se trata aquí).

```
commands:
  createWelcomeLog:
    command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
```

## Cómo agregar la seguridad a la red
<a name="bootstrapping-tutorial-security-group"></a>

Como vamos a configurar un servidor web, debemos permitir que el tráfico web (HTTP) llegue a nuestra instancia de EC2. Para ello, crearemos un grupo de seguridad que permita el tráfico entrante en el puerto 80 desde su dirección IP. Las instancias de EC2 también tienen que enviar tráfico a Internet, por ejemplo, para instalar actualizaciones de paquetes. De forma predeterminada, los grupos de seguridad permiten el tráfico saliente. A continuación, asociaremos este grupo de seguridad a nuestra instancia de EC2 mediante la propiedad `SecurityGroupIds`.

```
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Allow HTTP access from my IP address
    SecurityGroupIngress:
      - IpProtocol: tcp
        Description: HTTP
        FromPort: 80
        ToPort: 80
        CidrIp: !Ref MyIP
```

## La plantilla de arranque completa
<a name="bootstrapping-tutorial-complete-template"></a>

Ahora vamos a juntar todas las partes. Esta es la plantilla completa en la que se combinan todos los conceptos que hemos tratado.

```
AWSTemplateFormatVersion: 2010-09-09
Description: Bootstrap an EC2 instance with Apache web server using cfn-init

Parameters:
  LatestAmiId:
    Description: The latest Amazon Linux 2 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'

  InstanceType:
    Description: EC2 instance type
    Type: String
    Default: t2.micro
    AllowedValues:
      - t3.micro
      - t2.micro
    ConstraintDescription: must be a valid EC2 instance type.

  MyIP:
    Description: Your IP address in CIDR format (e.g. 203.0.113.1/32)
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.

Resources:
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow HTTP access from my IP address
      SecurityGroupIngress:
        - IpProtocol: tcp
          Description: HTTP
          FromPort: 80
          ToPort: 80
          CidrIp: !Ref MyIP

  WebServer:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <body>
                  <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
                </body>
          commands:
            createWelcomeLog:
              command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServer --region ${AWS::Region}
      Tags:
        - Key: Name
          Value: Bootstrap Tutorial Web Server

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServer.PublicDnsName}'
    Description: EC2 instance public DNS name
```

## Creación de la pila con la consola
<a name="bootstrapping-tutorial-create-stack"></a>

El siguiente procedimiento implica cargar la plantilla de pila de ejemplo desde un archivo. Abra un editor de texto en su equipo local y agregue la plantilla. Guarde el archivo con el nombre `samplelinux2stack.template`.

**Para lanzar la plantilla de pila**

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

1. Elija **Create stack (Crear pila)**, **With new resources (standard) (Con nuevos recursos [estándar])**.

1. En **Especificar plantilla**, seleccione **Cargar un archivo de plantilla** y, a continuación, seleccione **Elegir archivo** para cargar el archivo `samplelinux2stack.template`. 

1. Elija **Siguiente**.

1. En la página **Especificar los detalles de la pila**, ingrese **BootstrapTutorialStack** como nombre de la pila.

1. En **Parámetros**, haga lo siguiente.
   + **LatestAmiId**: deje el valor predeterminado.
   + **InstanceType**: elija **t2.micro** o **t3.micro** para el tipo de instancia de EC2.
   + **MyIP**: ingrese su dirección IP pública real con el sufijo `/32`.

1. Elija **Siguiente** dos veces y, luego, **Enviar** para crear la pila.

## Supervisión del proceso de arranque
<a name="bootstrapping-tutorial-validate-bootstrap"></a>

Los procesos de arranque tardan más que los lanzamientos sencillos de EC2 porque se instala y configura software adicional.

**Supervisión del progreso del arranque**

1. En la consola de CloudFormation, seleccione su pila y abra la pestaña **Eventos**.

1. Preste atención al evento `WebServer CREATE_IN_PROGRESS`. El proceso de arranque comienza después del lanzamiento de la instancia.

1. El proceso de arranque normalmente dura unos minutos. Verá `WebServer CREATE_COMPLETE` cuando haya terminado.

Si quiere ver lo que ocurre durante el proceso de arranque, puede consultar los registros de la instancia.

**Visualización de los registros de arranque (opcional)**

1. Abra la [consola de EC2](https://console.aws.amazon.com/ec2/) y busque su instancia.

1. Seleccione la instancia y, luego, elija **Acciones**, **Monitoreo y solución de problemas**, **Obtener registro del sistema** para ver el progreso del arranque.

1. Si no ve los registros inmediatamente, espere y actualice la página. 

## Prueba del servidor web arrancado
<a name="bootstrapping-tutorial-test-web-server"></a>

Cuando la pila muestre `CREATE_COMPLETE`, pruebe su servidor web.

**Prueba del servidor web**

1. En la consola de CloudFormation, vaya a la pestaña **Salidas** de su pila.

1. Haga clic en el valor de **WebsiteURL** para abrir su servidor web en una pestaña nueva.

1. Debería ver la página web personalizada con el mensaje `Congratulations, you have successfully launched the AWS CloudFormation sample`.

**nota**  
Si la página no se carga inmediatamente, espere un minuto e inténtelo de nuevo. Es posible que el proceso de arranque aún se esté completando incluso después de que la pila muestre `CREATE_COMPLETE`.

## Solución de problemas de arranque
<a name="bootstrapping-tutorial-troubleshooting"></a>

Si el proceso de arranque falla o el servidor web no funciona, aquí tiene algunos problemas y soluciones comunes.

### Problemas comunes
<a name="bootstrapping-tutorial-common-issues"></a>
+ **No se puede crear la pila**: consulte la pestaña **Eventos** para ver mensajes de error específicos.
+ **No se puede acceder al servidor web**: compruebe que la dirección IP sea correcta en el parámetro `MyIP`. Recuerde incluir `/32` al final.
+ **No se puede completar el proceso de arranque**: es posible que la instancia se lance, pero `cfn-init` falla. Compruebe los registros del sistema tal como se describe en la sección de supervisión.

## Eliminar recursos
<a name="bootstrapping-tutorial-clean-up"></a>

Para evitar cargos continuos, puede llevar a cabo una limpieza eliminando la pila y sus recursos. 

**Eliminación de la pila y sus recursos**

1. Abra la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation/).

1. En la página **Pilas**, seleccione la opción situada junto al nombre de la pila que ha creado (**BootstrapTutorialStack**) y, a continuación, seleccione **Eliminar**.

1. Cuando se le pida confirmación, seleccione **Eliminar**.

1. Supervise el progreso del proceso de eliminación de la pila en la pestaña **Evento**. El estado de **BootstrapTutorialStack** cambia a `DELETE_IN_PROGRESS`. Cuando CloudFormation completa la eliminación de la pila, quita la pila de la lista.

## Siguientes pasos
<a name="bootstrapping-tutorial-next-steps"></a>

¡Enhorabuena\$1 Ha aprendido correctamente a arrancar instancias de EC2 con CloudFormation. Ahora sabe:
+ Cómo usar los scripts auxiliares de `cfn-init`.
+ Cómo estructurar los metadatos para el arranque.
+ Cómo instalar paquetes, crear archivos, ejecutar comandos y administrar servicios.
+ Cómo supervisar si se producen problemas de arranque.

Para seguir aprendiendo:
+ Aprenda a actualizar una pila en ejecución y a usar el script auxiliar `cfn-hup`. Para obtener más información, consulte [Actualización de una pila de CloudFormation](updating.stacks.walkthrough.md).
+ Aprenda a arrancar una pila de Windows. Para obtener más información, consulte [Arranque de pilas de CloudFormation basadas en Windows](cfn-windows-stacks-bootstrapping.md).
+ Explore escenarios de arranque más complejos con varios conjuntos de configuración. Para obtener más información, consulte [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) y [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html) en la *Guía de referencia de plantillas de CloudFormation*.
+ Obtenga información sobre cómo usar `cfn-signal` para informar sobre el estado de finalización del arranque. Para obtener más información, consulte [cfn-signal](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-signal.html) en la *Guía de referencia de plantillas de CloudFormation*.