

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.

# Personalización de software en servidores Linux
<a name="customize-containers-ec2"></a>

En esta sección, se describe el tipo de información que puede incluir en un archivo de configuración para personalizar el software en las EC2 instancias que ejecutan Linux. Para obtener información general acerca de cómo personalizar y configurar los entornos de Elastic Beanstalk, consulte [Configuración de entornos de Elastic Beanstalk](customize-containers.md). Para obtener información sobre cómo personalizar el software en EC2 las instancias que ejecutan Windows, consulte[Personalización de software en servidores Windows](customize-containers-windows-ec2.md).

Tal vez desee personalizar y configurar el software del que depende la aplicación. Puede agregar comandos que se ejecutarán durante el aprovisionamiento de instancias; definir usuarios y grupos de Linux; y descargar o crear archivos directamente en las instancias de entorno. Estos archivos podrían ser dependencias necesarias para la aplicación (por ejemplo, paquetes adicionales del repositorio de yum) o archivos de configuración, por ejemplo, un archivo sustituto de un archivo de configuración del proxy que anulara ciertos valores específicos establecidos de forma predeterminada por Elastic Beanstalk).

**Notas**  
En las plataformas de Amazon Linux 2, en lugar de proporcionar archivos y comandos en los archivos de configuración .ebextensions, recomendamos encarecidamente que utilice *Buildfile*. *Procfile*, y *enlaces de la plataforma* siempre que sea posible para configurar y ejecutar código personalizado en las instancias de entorno durante el aprovisionamiento de instancias. Para obtener más información sobre estos mecanismos, consulte [Ampliación de las plataformas Linux de Elastic Beanstalk](platforms-linux-extend.md).
YAML usa la sangría uniforme. Utilice el mismo nivel de sangría cuando sustituya el contenido en el archivo de configuración de ejemplo y asegúrese de que el editor de texto utiliza espacios para la sangría, no tabuladores.

Los archivos de configuración admiten las siguientes claves que afectan al servidor Linux en el que se ejecuta la aplicación.

**Topics**
+ [Paquetes](#linux-packages)
+ [Groups](#linux-groups)
+ [Users](#linux-users)
+ [Orígenes](#linux-sources)
+ [Archivos](#linux-files)
+ [Comandos](#linux-commands)
+ [Services](#linux-services)
+ [Comandos de contenedor](#linux-container-commands)
+ [Ejemplo: usar CloudWatch métricas personalizadas de Amazon](customize-containers-cw.md)

Las claves se procesan en el orden en el que se muestran.

Vigile los [eventos](using-features.events.md) de su entorno mientras desarrolle y pruebe archivos de configuración. Elastic Beanstalk hará caso omiso de un archivo de configuración si este contiene errores de validación, como una clave no válida, por ejemplo, y no procesará ninguna de las claves contenidas en ese mismo archivo. Si esto sucede, Elastic Beanstalk agrega un evento de advertencia al registro de eventos.

## Paquetes
<a name="linux-packages"></a>

Puede utilizar la clave `packages` para descargar e instalar aplicaciones y componentes previamente empaquetados.

### Sintaxis
<a name="linux-packages-syntax"></a>

```
packages: 
  name of package manager:
    package name: version
    ...
  name of package manager:
    package name: version
    ...
  ...
```

Puede especificar varios paquetes con la clave de cada administrador de paquetes.

### Formatos de paquetes admitidos
<a name="linux-packages-support"></a>

En la actualidad, Elastic Beanstalk es compatible con los siguientes administradores de paquetes: yum, rubygems, python y rpm. Los paquetes se procesan en el orden siguiente: rpm, yum y, después, rubygems y python. No hay ningún orden entre rubygems y python. Dentro de cada administrador de paquetes, no está garantizado el orden de instalación de paquetes. Utilice un administrador de paquetes que sea compatible con el sistema operativo.

**nota**  
Elastic Beanstalk es compatible con dos administradores de paquetes subyacentes para Python: pip y easy\$1install. Sin embargo, en la sintaxis del archivo de configuración, debe especificarse el nombre del administrador de paquetes como `python`. Si utiliza un archivo de configuración para especificar un administrador de paquetes de Python, Elastic Beanstalk utilizará Python 2.7. Si la aplicación se basa en una versión diferente de Python, puede especificar los paquetes que se van a instalar en un archivo `requirements.txt`. Para obtener más información, consulte [Especificación de dependencias mediante un archivo de requisitos en Elastic Beanstalk](python-configuration-requirements.md).

### Especificación de versiones
<a name="linux-packages-versions"></a>

Dentro de cada administrador de paquetes, cada paquete se especifica con un nombre de paquete y una lista de versiones. La versión puede ser una cadena, una lista de versiones o una cadena o lista vacía. Una cadena o lista vacía indica que se debe usar la versión más reciente. Para el administrador de rpm, la versión se especifica como una ruta a un archivo en el disco o una URL. No se admiten rutas relativas.

Si especifica una versión de un paquete, Elastic Beanstalk intentará instalar esa versión incluso si ya hay una versión más reciente del paquete instalada en la instancia. Si ya hay una versión más reciente instalada, la implementación fallará. Algunos administradores de paquetes admiten varias versiones, pero puede haber otros que no. Consulte la documentación del administrador de paquetes para obtener más información. Si no se especifica ninguna versión y ya hay una versión del paquete instalada, Elastic Beanstalk no instalará una nueva versión, sino que presupondrá que se desea mantener y utilizar la versión existente.

### Fragmento de código de ejemplo
<a name="linux-packages-snippet"></a>

En el siguiente fragmento de código, se especifica la URL de una versión de rpm y se solicita la última versión de yum y la versión 0.10.2 de chef de rubygems.

```
packages: 
  yum:
    libmemcached: [] 
    ruby-devel: []
    gcc: []
  rpm:
    epel: http://download.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm
  rubygems: 
    chef: '0.10.2'
```

## Groups
<a name="linux-groups"></a>

Puede usar la `groups` tecla para crear Linux/UNIX grupos y asignar grupos IDs. Para crear un grupo, añada un nuevo par clave-valor que asigne un nuevo nombre de grupo a un ID de grupo opcional. La clave “groups” puede contener uno o varios nombres de grupo. En la tabla siguiente, se muestran las claves disponibles.

### Sintaxis
<a name="linux-groups-syntax"></a>

```
groups:
  name of group: {}
  name of group:
    gid: "group id"
```

### Opciones
<a name="linux-groups-options"></a>

`gid`  
Número de ID de grupo.  
Si se especifica un ID de grupo y el nombre del grupo ya existe, se producirá un error al crear el grupo. Si otro grupo tuviera el ID de grupo especificado, el sistema operativo podría rechazar la creación del grupo.

### Fragmento de código de ejemplo
<a name="linux-groups-snippet"></a>

En el siguiente fragmento de código, se especifica un grupo denominado groupOne sin asignar un ID de grupo y un grupo denominado groupTwo cuyo ID de grupo es 45.

```
groups:
  groupOne: {}
  groupTwo:
    gid: "45"
```

## Users
<a name="linux-users"></a>

Puedes usar la `users` clave para crear Linux/UNIX usuarios en la EC2 instancia.

### Sintaxis
<a name="linux-users-syntax"></a>

```
users:
  name of user:
    groups:
      - name of group
    uid: "id of the user"
    homeDir: "user's home directory"
```

### Opciones
<a name="linux-users-options"></a>

`uid`  
ID de usuario. El proceso de creación falla si existe un nombre de usuario con otro ID. Si el ID de usuario ya estuviera asignado a un usuario existente, el sistema operativo podría rechazar la solicitud de creación.

`groups`  
Lista de nombres de grupos. El usuario se agrega a cada grupo de la lista.

`homeDir`  
Directorio de inicio del usuario.

Los usuarios se crean como usuarios de un sistema no interactivo con el shell `/sbin/nologin`. Esto es así por diseño y no se puede modificar.

### Fragmento de código de ejemplo
<a name="linux-users-snippet"></a>

```
users:
  myuser:
    groups:
      - group1
      - group2
    uid: "50"
    homeDir: "/tmp"
```

## Orígenes
<a name="linux-sources"></a>

Puedes usar la `sources` clave para descargar un archivo comprimido desde una URL pública y descomprimirlo en un directorio de destino de la EC2 instancia.

### Sintaxis
<a name="linux-sources-syntax"></a>

```
sources:
  target directory: location of archive file
```

### Formatos admitidos
<a name="linux-sources-support"></a>

Los formatos admitidos son: tar, tar\$1gzip, tar\$1bz2 y zip. Puede hacer referencia a ubicaciones externas, como Amazon Simple Storage Service (Amazon S3) (por ejemplo, `https://amzn-s3-demo-bucket.s3.amazonaws.com/myobject`) siempre que la URL esté accesible públicamente.

### Fragmento de código de ejemplo
<a name="linux-sources-example"></a>

En el siguiente ejemplo, se descarga un archivo .zip público de un bucket de Amazon S3 y se desempaqueta en `/etc/myapp`:

```
sources:  
  /etc/myapp: https://amzn-s3-demo-bucket.s3.amazonaws.com/myobject
```

**nota**  
Varias extracciones no deben reutilizar la misma ruta de destino. La extracción de otro origen en la misma ruta de destino reemplazará en lugar de añadirse al contenido. 

## Archivos
<a name="linux-files"></a>

Puedes usar la `files` clave para crear archivos en la EC2 instancia. El contenido puede estar insertado en el archivo de configuración o extraerse de una URL. Los archivos se escriben en el disco en orden lexicográfico.

Puede utilizar la clave `files` para descargar archivos privados de Amazon S3 si proporciona un perfil de instancia para su autorización.

Si la ruta de archivo especificada ya existe en la instancia, el archivo existente se conserva con la extensión `.bak` anexada a su nombre.

### Sintaxis
<a name="linux-files-syntax"></a>

```
files:  
  "target file location on disk": 
     mode: "six-digit octal value"
     owner: name of owning user for file
     group: name of owning group for file
     source: URL
     authentication: authentication name:

  "target file location on disk": 
     mode: "six-digit octal value"
     owner: name of owning user for file
     group: name of owning group for file
     content: |
      # this is my
      # file content
     encoding: encoding format
     authentication: authentication name:
```

### Opciones
<a name="linux-files-options"></a>

`content`  
Contenido de la cadena que se va a agregar al archivo. Especifica `content` o `source`, pero no ambos.

`source`  
URL de un archivo que se va a descargar. Especifica `content` o `source`, pero no ambos.

`encoding`  
Formato de codificación de la cadena especificada con la opción `content`.  
Valores válidos: `plain` \$1 `base64`

`group`  
Grupo de Linux al que pertenece el archivo.

`owner`  
Usuario de Linux al que pertenece el archivo.

`mode`  
Un valor octal de seis dígitos que representa el modo para este archivo. No es compatible con sistemas Windows. Utilice los tres primeros dígitos para symlinks y los últimos tres dígitos para la configuración de permisos. Para crear un symlink, especifique `120xxx`, donde `xxx` define los permisos del archivo de destino. Para especificar los permisos de un archivo, utilice los tres últimos dígitos, como `000644`.

`authentication`  
Nombre del[ método de autenticación de CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-authentication.html) que se utilizará. Puede añadir métodos de autenticación a los metadatos del grupo de escalado automático con la clave Resources. Consulte a continuación un ejemplo.

### Fragmento de código de ejemplo
<a name="linux-files-snippet"></a>

```
files:
  "/home/ec2-user/myfile" :
    mode: "000755"
    owner: root
    group: root
    source: http://foo.bar/myfile
 
  "/home/ec2-user/myfile2" :
    mode: "000755"
    owner: root
    group: root
    content: |
      this is my
      file content
```

En el ejemplo se utiliza un objeto symlink. Este crea un enlace, `/tmp/myfile2.txt`, que apunta al archivo existente `/tmp/myfile1.txt`.

```
files:
  "/tmp/myfile2.txt" :
    mode: "120400"
    content: "/tmp/myfile1.txt"
```

En el siguiente ejemplo, se utiliza la clave Resources para añadir un método de autenticación denominado S3Auth que se emplea para descargar un archivo privado en el bucket de Amazon S3:

```
Resources:
  AWSEBAutoScalingGroup:
    Metadata:
      AWS::CloudFormation::Authentication:
        S3Auth:
          type: "s3"
          buckets: ["amzn-s3-demo-bucket2"]
          roleName:
            "Fn::GetOptionSetting":
              Namespace: "aws:autoscaling:launchconfiguration"
              OptionName: "IamInstanceProfile"
              DefaultValue: "aws-elasticbeanstalk-ec2-role"

files:
  "/tmp/data.json" :
    mode: "000755"
    owner: root
    group: root
    authentication: "S3Auth"
    source: https://elasticbeanstalk-us-west-2-123456789012.s3-us-west-2.amazonaws.com/data.json
```

## Comandos
<a name="linux-commands"></a>

Puedes usar la `commands` tecla para ejecutar comandos en la EC2 instancia. Los comandos se ejecutan antes de que se configuren la aplicación y el servidor web y se extraiga el archivo de versión de la aplicación.

Lo comandos especificados se ejecutan como el usuario root y se procesan en orden alfabético por nombre. De forma predeterminada, los comandos se ejecutan en el directorio raíz. Para ejecutar comandos en otro directorio, utilice la opción `cwd`.

Para solucionar problemas con los comandos, puede encontrar su salida en los [registros de instancia](using-features.logging.md).

### Sintaxis
<a name="linux-commands-syntax"></a>

```
commands:
  command name: 
    command: command to run
    cwd: working directory
    env: 
      variable name: variable value
    test: conditions for command 
    ignoreErrors: true
```

### Opciones
<a name="linux-commands-options"></a>

`command`  
Puede ser una matriz ([colección de secuencias de bloques](http://yaml.org/spec/1.2/spec.html#id2759963) en la sintaxis YAML) o una cadena que especifique el comando que hay que ejecutar. Notas importantes:  
+ Si utiliza una cadena, no es preciso que la cadena completa vaya incluida entre comillas. Si aun así utiliza comillas, deberá utilizar el carácter de escape para las comillas literales del mismo tipo que aparezcan en la cadena.
+ Si utiliza una matriz, no es preciso que utilizar el carácter de escape para los caracteres de espacio ni incluir los parámetros de comandos entre comillas. Cada elemento de la matriz es un solo argumento de comando. No utilice una matriz para especificar varios comandos.
Los siguientes ejemplos son equivalentes:  

```
commands:
  command1:
    command: git commit -m "This is a comment."
  command2:
    command: "git commit -m \"This is a comment.\""
  command3:
    command: 'git commit -m "This is a comment."'
  command4:
    command:
      - git
      - commit
      - -m
      - This is a comment.
```
Para especificar varios comandos, use un [escalar de bloque literal](http://yaml.org/spec/1.2/spec.html#id2760844), tal y como se muestra en el siguiente ejemplo.  

```
commands:
  command block:
    command: |
      git commit -m "This is a comment."
      git push
```

`env`  
(Opcional) Establece las variables de entorno del comando. Esta propiedad sobrescribe, en lugar de anexar, el entorno existente.

`cwd`  
(Opcional) El directorio de trabajo. Si no se especifica, los comandos se ejecutan en el directorio raíz (/).

`test`  
(Opcional) Comando que debe devolver el valor `true` (código de salida 0) para que Elastic Beanstalk pueda procesar el comando (por ejemplo, un script de shell) incluido en la clave `command`.

`ignoreErrors`  
(Opcional) Valor booleano que determina si otros comandos deben ejecutarse en caso de que se produzca un error (se devuelva un valor distinto de cero) en el comando incluido en la clave `command`. Establezca este valor en `true` si desea continuar ejecutando comandos aunque se produzca un error. Establézcalo en `false` si desea detener la ejecución de comandos en caso de que se produzca un error. El valor predeterminado es `false`.

### Fragmento de código de ejemplo
<a name="linux-commands-snippet"></a>

En el siguiente fragmento de ejemplo se ejecuta un script de Python.

```
commands:
  python_install:
    command: myscript.py
    cwd: /home/ec2-user
    env:
      myvarname: myvarvalue
    test: "[ -x /usr/bin/python ]"
```

## Services
<a name="linux-services"></a>

Puede utilizar la clave `services` para definir qué servicios deben iniciarse o detenerse cuando se lance la instancia. La clave `services` también le permite especificar dependencias en orígenes, paquetes y archivos, de manera que si es necesario reiniciar debido a los archivos que se están instalado, Elastic Beanstalk se encargará de reiniciar el servicio.

### Sintaxis
<a name="linux-services-syntax"></a>

```
services:
  sysvinit:
    name of service:
      enabled: "true"
      ensureRunning: "true"
      files: 
        - "file name"
      sources: 
        - "directory"	
      packages: 
        name of package manager:
          "package name[: version]"
      commands: 
        - "name of command"
```

### Opciones
<a name="linux-services-options"></a>

`ensureRunning`  
Establézcalo en `true` para asegurarse de que el servicio se está ejecutando una vez que Elastic Beanstalk finalice.  
Establézcalo en `false` para asegurarse de que el servicio no se está ejecutando una vez que Elastic Beanstalk finalice.  
Omita esta clave para no realizar ningún cambio en el estado del servicio.

`enabled`  
Establézcalo en `true` para garantizar que el servicio se iniciará automáticamente al arrancar.  
Establézcalo en `false` para garantizar que el servicio no se iniciará automáticamente al arrancar.  
Omita esta clave para no realizar ningún cambio a esta propiedad.

`files`  
Una lista de archivos. Si Elastic Beanstalk cambia uno directamente a través del bloque de archivos, el servicio se reinicia.

`sources`  
Una lista de directorios. Si Elastic Beanstalk expande un archivo en uno de estos directorios, el servicio se reinicia.

`packages`  
Una asignación del administrador de paquetes a una lista de nombres de paquetes. Si Elastic Beanstalk instala o actualiza uno de estos paquetes, el servicio se reinicia.

`commands`  
Una lista de nombres de comandos. Si Elastic Beanstalk ejecuta el comando especificado, se reinicia el servicio.

### Fragmento de código de ejemplo
<a name="linux-services-snippet"></a>

A continuación, se muestra un fragmento de código de ejemplo:

```
services: 
  sysvinit:
    myservice:
      enabled: true
      ensureRunning: true
```

## Comandos de contenedor
<a name="linux-container-commands"></a>

Puede utilizar la clave `container_commands` para ejecutar comandos que afecten el código abierto de la aplicación. Estos comandos se ejecutan una vez configurada la aplicación y el servidor web, y una vez que se ha extraído el archivo de versiones de la aplicación, pero antes de que se implemente la versión de la aplicación. Los comandos que no son de contenedor y otras operaciones de personalización se realizan antes de que se extraiga el código fuente de la aplicación.

Lo comandos especificados se ejecutan como el usuario root y se procesan en orden alfabético por nombre. Los comandos de contenedor se ejecutan desde el directorio de ensayo, del que se extrae el código fuente antes de implementarse en el servidor de la aplicación. Todos los cambios que realice en el código fuente en el directorio de ensayo con un comando de contenedor se incluirán cuando se implemente el código fuente en su ubicación final.

**nota**  
Los resultados de los comandos del contenedor se registran en el registro de instancias `cfn-init-cmd.log`. Para obtener más información sobre la recuperación y visualización de los registros de instancias, consulta [Visualización de registros de EC2 instancias de Amazon](using-features.logging.md).

Puede utilizar `leader_only` para ejecutar el comando en una sola instancia o configurar un objeto `test` para que el comando se ejecute exclusivamente cuando un comando “test” se evalúe como `true`. Los comandos de contenedor “leader-only” solo se ejecutan durante la creación del entorno y las implementaciones, mientras que otros comandos y operaciones de personalización del servidor se ejecutan cada vez que se aprovisiona o se actualiza una instancia. Los comandos de contenedor “leader-only” no se ejecutan debido a los cambios en la configuración de lanzamiento, como un cambio en el ID de AMI o tipo de instancia.

### Sintaxis
<a name="linux-container-commands-syntax"></a>

```
container_commands:
  name of container_command:
    command: "command to run"
    leader_only: true
  name of container_command:
    command: "command to run"
```

### Opciones
<a name="linux-container-commands-options"></a>

`command`  
Cadena o matriz de cadenas que se va a ejecutar.

`env`  
(Opcional) Establezca las variables de entorno antes de ejecutar el comando para invalidar cualquier valor existente.

`cwd`  
(Opcional) El directorio de trabajo. De forma predeterminada, este es el directorio de ensayo de la aplicación sin descomprimir.

`leader_only`  
(Opcional) Ejecute solo el comando en una sola instancia seleccionada por Elastic Beanstalk. Los comandos de contenedor “leader-only” se ejecutan antes que otros comandos de contenedor. Un comando puede ser “leader-only” o tener un objeto `test`, pero no ambas cosas (`leader_only` tiene prioridad).

`test`  
(Opcional) Ejecute un comando de prueba que deba devolver `true` para poder ejecutar el comando de contenedor. Un comando puede ser “leader-only” o tener un objeto `test`, pero no ambas cosas (`leader_only` tiene prioridad).

`ignoreErrors`  
(Opcional) No produce un error en las implementaciones si el comando de contenedor devuelve un valor distinto de 0 (correcto). Establézcalo en `true` para habilitarlo.

### Fragmento de código de ejemplo
<a name="linux-container-commands-snippet"></a>

A continuación, se muestra un fragmento de código de ejemplo.

```
container_commands:
  collectstatic:
    command: "django-admin.py collectstatic --noinput"
  01syncdb:
    command: "django-admin.py syncdb --noinput"
    leader_only: true
  02migrate:
    command: "django-admin.py migrate"
    leader_only: true
  99customize:
    command: "scripts/customize.sh"
```

# Ejemplo: usar CloudWatch métricas personalizadas de Amazon
<a name="customize-containers-cw"></a>

En este tema se proporciona un ejemplo de configuración que integra las métricas de Elastic Beanstalk CloudWatch con el agente de Amazon para plataformas basadas en Amazon Linux 2 y versiones posteriores. El ejemplo de configuración utiliza archivos y comandos de un archivo de configuración `.ebextensions`.

Amazon CloudWatch es un servicio web que le permite supervisar, gestionar y publicar diversas métricas, así como configurar acciones de alarma en función de los datos de las métricas. Puede definir métricas personalizadas para su propio uso y Elastic Beanstalk las enviará a Amazon. CloudWatch Una vez que Amazon CloudWatch contenga tus métricas personalizadas, podrás verlas en la CloudWatch consola de Amazon.

**El CloudWatch agente de Amazon**  
El CloudWatch agente de Amazon permite la recopilación de CloudWatch métricas y registros tanto de EC2 las instancias de Amazon como de los servidores locales de todos los sistemas operativos. El agente admite las métricas recopiladas a nivel del sistema. También admite la recopilación de métricas y registros personalizados desde las aplicaciones o servicios. Para obtener más información sobre el CloudWatch agente de Amazon, consulta [Cómo recopilar estadísticas y registros con el CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) en la *Guía del CloudWatch usuario de Amazon*.

**nota**  
Los informes de salud [mejorados de Elastic Beanstalk](health-enhanced.md) cuentan con soporte nativo para publicar una amplia gama de métricas de instancias y entornos en. CloudWatch Para obtener más información, consulte [Publicar métricas CloudWatch personalizadas de Amazon para un entorno](health-enhanced-cloudwatch.md).

**Topics**
+ [Archivo de configuración .ebextensions](#customize-containers-cw-update-roles)
+ [Permisos](#customize-containers-cw-policy)
+ [Visualización de las métricas en la CloudWatch consola](#customize-containers-cw-console)

## Archivo de configuración .ebextensions
<a name="customize-containers-cw-update-roles"></a>

En este ejemplo, se utilizan los archivos y comandos de un archivo de configuración .ebextensions para configurar y ejecutar el CloudWatch agente de Amazon en la plataforma Amazon Linux 2. El agente está preempaquetado con Amazon Linux 2. Si utiliza otro sistema operativo, es posible que sean necesarios pasos adicionales para instalar el agente. Para obtener más información, consulte [Instalación del CloudWatch agente](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/install-CloudWatch-Agent-on-EC2-Instance.html) en la *Guía del CloudWatch usuario de Amazon*.

Para utilizar este ejemplo, guárdelo en un archivo llamado `cloudwatch.config` que esté situado en un directorio denominado `.ebextensions` en el nivel superior del directorio del proyecto. A continuación, implemente la aplicación a través de la consola de Elastic Beanstalk (incluya el directorio .ebextensions en el [paquete de código fuente](applications-sourcebundle.md)) o la [CLI de EB](eb-cli3.md).

Para obtener más información sobre los archivos de configuración, consulta [Personalización avanzada de entornos con archivos de configuración (`.ebextensions`)](ebextensions.md).

Este archivo tiene dos secciones:
+ `files`: en esta sección se agrega el archivo de configuración del agente. Indica qué métricas y registros debe enviar el agente a Amazon CloudWatch. En este ejemplo, solo enviamos la métrica *mem\$1used\$1percent*. Para obtener una lista completa de las métricas a nivel del sistema admitidas por el CloudWatch agente de Amazon, consulta [las métricas recopiladas por el CloudWatch agente](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html) en la *Guía del CloudWatch usuario de Amazon*.
+ `container_commands`: esta sección contiene el comando que inicia el agente al transferir el archivo de configuración como parámetro. Para obtener información detallada acerca de `container_commands`, consulte [Comandos de contenedor](customize-containers-ec2.md#linux-container-commands).

**.ebextensions/cloudwatch.config**

```
files:  
  "/opt/aws/amazon-cloudwatch-agent/bin/config.json": 
    mode: "000600"
    owner: root
    group: root
    content: |
      {
        "agent": {
          "metrics_collection_interval": 60,
          "run_as_user": "root"
        },
        "metrics": {
          "namespace": "System/Linux",
          "append_dimensions": {
            "AutoScalingGroupName": "${aws:AutoScalingGroupName}"
          },
          "metrics_collected": {
            "mem": {
              "measurement": [
                "mem_used_percent"
              ]
            }
          }
        }
      }  
container_commands:
  start_cloudwatch_agent: 
    command: /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a append-config -m ec2 -s -c file:/opt/aws/amazon-cloudwatch-agent/bin/config.json
```

## Permisos
<a name="customize-containers-cw-policy"></a>

Las instancias de su entorno necesitan los permisos de IAM adecuados para poder publicar CloudWatch métricas de Amazon personalizadas mediante el CloudWatch agente de Amazon. Los permisos para las instancias del entorno se conceden agregándolas al [perfil de instancias](concepts-roles-instance.md) del entorno. Los permisos pueden agregarse al perfil de instancia antes o después de implementar la aplicación.

**Para conceder permisos para publicar métricas CloudWatch**

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

1. Seleccione **Roles** en el panel de navegación.

1. Seleccione el rol del perfil de instancia del entorno. De forma predeterminada, cuando se crea un entorno con la consola de Elastic Beanstalk o la [CLI de EB](eb-cli3.md), el rol es `aws-elasticbeanstalk-ec2-role`.

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

1. Bajo **Permissions Policies** (Políticas de permisos), en la sección **Permissions** (Permisos), elija **Attach policies** (Adjuntar políticas).

1. En **Adjuntar permisos**, selecciona la política AWS gestionada **CloudWatchAgentServerPolicy**. Haga clic en **Attach Policy** (Adjuntar política).

Para obtener más información acerca de la administración de políticas, consulte [Uso de las políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html) en la *Guía del usuario de IAM*.

## Visualización de las métricas en la CloudWatch consola
<a name="customize-containers-cw-console"></a>

Tras implementar el archivo de CloudWatch configuración en su entorno, consulte la [ CloudWatchconsola de Amazon](https://console.aws.amazon.com/cloudwatch/home) para ver las métricas. Las métricas personalizadas se ubicarán en el espacio de **CWAgent**nombres.

Para obtener más información, consulta Cómo [ver las métricas disponibles](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) en la *Guía del CloudWatch usuario de Amazon*.