Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Implementación de aplicaciones Node.js con Elastic Beanstalk
En este capítulo se proporcionan instrucciones para configurar e implementar la aplicación web Node.js en AWS Elastic Beanstalk. También se ofrecen instrucciones paso a paso para tareas comunes como la integración de bases de datos y el trabajo con el framework Express. Elastic Beanstalk facilita la implementación, administración y escalado de sus aplicaciones web Node.js con Amazon Web Services.
Puede implementar la aplicación en solo unos minutos mediante la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB) o mediante la consola de Elastic Beanstalk. Después de implementar la aplicación de Elastic Beanstalk, puede seguir utilizando la CLI de EB para administrar la aplicación y el entorno, o puede usar la consola de Elastic Beanstalk o la. AWS CLI APIs
Siga las step-by-step instrucciones [QuickStart para Node.js](nodejs-quickstart.md) para crear e implementar una aplicación web *Hello World* Node.js con la CLI de EB.
**Topics**
+ [QuickStart: Implemente una aplicación Node.js en Elastic Beanstalk](nodejs-quickstart.md)
+ [Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk](nodejs-devenv.md)
+ [Uso de la plataforma Elastic Beanstalk Node.js](create_deploy_nodejs.container.md)
+ [Más ejemplos de tutoriales y aplicaciones de Elastic Beanstalk para Node.js](nodejs-getstarted.md)
+ [Implementación de una aplicación Express Node Js. en Elastic Beanstalk](create_deploy_nodejs_express.md)
+ [Implementación de una aplicación Express Node Js. con clústeres en Elastic Beanstalk](nodejs-express-clustering.md)
+ [Implementación de una aplicación Node.js con DynamoDB en Elastic Beanstalk](nodejs-dynamodb-tutorial.md)
+ [Adición de una instancia de base de datos de Amazon RDS a su entorno de Node.js Elastic Beanstalk](create-deploy-nodejs.rds.md)
+ [Herramientas y recursos de Node.js](create_deploy_nodejs.resources.md)
# QuickStart: Implemente una aplicación Node.js en Elastic Beanstalk
Este QuickStart tutorial explica el proceso de creación de una aplicación Node.js e implementarla en un AWS Elastic Beanstalk entorno.
**No válido para uso en producción**
Los ejemplos se presentan solo con fines de demostración. No utilice aplicaciones de ejemplo en producción.
**Topics**
+ [Tu AWS cuenta](#nodejs-quickstart-aws-account)
+ [Requisitos previos](#nodejs-quickstart-prereq)
+ [Paso 1: crear una aplicación de Node.js](#nodejs-quickstart-create-app)
+ [Paso 2: ejecutar la aplicación a nivel local](#nodejs-quickstart-run-local)
+ [Paso 3: implementar la aplicación Node.js con la CLI de EB](#nodejs-quickstart-deploy)
+ [Paso 4: ejecutar la aplicación en Elastic Beanstalk](#nodejs-quickstart-run-eb-ap)
+ [Paso 5: Eliminar](#go-tutorial-cleanup)
+ [AWS recursos para su aplicación](#nodejs-quickstart-eb-resources)
+ [Siguientes pasos](#nodejs-quickstart-next-steps)
+ [Implementar con la consola de Elastic Beanstalk](#nodejs-quickstart-console)
## Tu AWS cuenta
Si aún no eres AWS cliente, debes crear una AWS cuenta. El registro le permite acceder a Elastic Beanstalk AWS y a otros servicios que necesite.
Si ya tiene una AWS cuenta, puede pasar a. [Requisitos previos](#nodejs-quickstart-prereq)
### Crea una AWS cuenta
#### Inscríbase en una Cuenta de AWS
Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.
**Para suscribirte a una Cuenta de AWS**
1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).
1. Siga las instrucciones que se le indiquen.
Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.
Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [Tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS te envía un correo electrónico de confirmación una vez finalizado el proceso de registro. En cualquier momento, puede ver la actividad de su cuenta actual y administrarla accediendo a [https://aws.amazon.com/](https://aws.amazon.com/)y seleccionando **Mi cuenta**.
#### Creación de un usuario con acceso administrativo
Después de crear un usuario administrativo Cuenta de AWS, asegúrelo Usuario raíz de la cuenta de AWS AWS IAM Identity Center, habilite y cree un usuario administrativo para no usar el usuario root en las tareas diarias.
**Proteja su Usuario raíz de la cuenta de AWS**
1. Inicie sesión [Consola de administración de AWS](https://console.aws.amazon.com/)como propietario de la cuenta seleccionando el **usuario root** e introduciendo su dirección de Cuenta de AWS correo electrónico. En la siguiente página, escriba su contraseña.
Para obtener ayuda para iniciar sesión con el usuario raíz, consulte [Iniciar sesión como usuario raíz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) en la *Guía del usuario de AWS Sign-In *.
1. Active la autenticación multifactor (MFA) para el usuario raíz.
Para obtener instrucciones, consulte [Habilitar un dispositivo MFA virtual para el usuario Cuenta de AWS raíz (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) en la Guía del usuario de *IAM*.
**Creación de un usuario con acceso administrativo**
1. Activar IAM Identity Center.
Consulte las instrucciones en [Activar AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) en la *Guía del usuario de AWS IAM Identity Center *.
1. En IAM Identity Center, conceda acceso administrativo a un usuario.
Para ver un tutorial sobre su uso Directorio de IAM Identity Center como fuente de identidad, consulte [Configurar el acceso de los usuarios con la configuración predeterminada Directorio de IAM Identity Center en la](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) Guía del *AWS IAM Identity Center usuario*.
**Inicio de sesión como usuario con acceso de administrador**
+ Para iniciar sesión con el usuario de IAM Identity Center, use la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center.
Para obtener ayuda para iniciar sesión con un usuario del Centro de identidades de IAM, consulte [Iniciar sesión en el portal de AWS acceso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) en la *Guía del AWS Sign-In usuario*.
**Concesión de acceso a usuarios adicionales**
1. En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos.
Para conocer las instrucciones, consulte [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) en la *Guía del usuario de AWS IAM Identity Center *.
1. Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo.
Para conocer las instrucciones, consulte [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) en la *Guía del usuario de AWS IAM Identity Center *.
## Requisitos previos
Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema (\$1) y del nombre del directorio actual, si es aplicable.
```
~/eb-project$ this is a command
this is output
```
En Linux y macOS, puede utilizar el administrador de shell y paquetes preferido. En Windows, puede [instalar Windows Subsystem para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obtener una versión de Ubuntu y Bash integrada con Windows.
### CLI DE EB
En este tutorial también se utiliza la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB). Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte [Instalación de la CLI de EB con el script de configuración (recomendado)](eb-cli3.md#eb-cli3-install) y [Configuración de la CLI de EB](eb-cli3-configuration.md).
### Node.js
Instale Node.js en su máquina local según el procedimiento [Cómo instalar Node.js en el sitio web Node.js](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs).
Verifique la instalación de Node.js con el siguiente comando.
```
~$ node -v
```
## Paso 1: crear una aplicación de Node.js
Cree el directorio del proyecto.
```
~$ mkdir eb-nodejs
~$ cd eb-nodejs
```
A continuación, vamos a crear una aplicación que implementará con Elastic Beanstalk. Crearemos un servicio RESTful web llamado «Hello World».
**Example `~/eb-nodejs/server.js`**
```
const http = require('node:http');
const hostname = '127.0.0.1';
const port = 8080;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello Elastic Beanstalk!\n');
});
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
```
Esta aplicación abre un oyente en el puerto 8080. Elastic Beanstalk reenvía las solicitudes a la aplicación en el puerto 8080 de forma predeterminada para Node.js.
## Paso 2: ejecutar la aplicación a nivel local
Para implementar la aplicación localmente, ejecute el siguiente comando.
```
~/eb-nodejs$ node server.js
```
Debería ver el texto siguiente.
```
Server running at http://127.0.0.1:8080/
```
Introduzca la URL `http://127.0.0.1:8080/` en su navegador. El navegador debería mostrar “Hola, Elastic Beanstalk”.
## Paso 3: implementar la aplicación Node.js con la CLI de EB
Ejecute los siguientes comandos para crear un entorno de Elastic Beanstalk en esta aplicación.
**Cómo crear un entorno e implementar la aplicación Node.js**
1. Inicialice el repositorio de la CLI de EB con el comando **eb init**.
```
~/eb-nodejs$ eb init -p node.js nodejs-tutorial --region us-east-2
```
Este comando crea una aplicación llamada `nodejs-tutorial` y configura el repositorio local para crear entornos con la última versión de la plataforma de Node.js.
1. (Opcional) **eb init** Vuelve a ejecutarlo para configurar un key pair predeterminado de forma que puedas usar SSH para conectarte a la EC2 instancia que ejecuta tu aplicación.
```
~/eb-nodejs$ eb init
Do you want to set up SSH for your instances?
(y/n): y
Select a keypair.
1) my-keypair
2) [ Create new KeyPair ]
```
Seleccione un par de claves si ya tiene uno o siga las instrucciones para crear uno. Si no ve el símbolo del sistema o más adelante necesita cambiar la configuración, ejecute **eb init -i**.
1. Cree un entorno e implemente la aplicación en él con **eb create**. Elastic Beanstalk crea automáticamente un archivo zip para la aplicación y lo EC2 despliega en una instancia del entorno. Después de implementar la aplicación, Elastic Beanstalk la inicia en el puerto 8080.
```
~/eb-nodejs$ eb create nodejs-env
```
Elastic Beanstalk tarda aproximadamente cinco minutos en crear el entorno.
## Paso 4: ejecutar la aplicación en Elastic Beanstalk
Cuando finalice el proceso de creación del entorno, abra el sitio web con **eb open**.
```
~/eb-nodejs$ eb open
```
¡Enhorabuena\$1 Ha implementado una aplicación de Node,js con Elastic Beanstalk. Se abre una ventana del navegador con el nombre de dominio creado para su aplicación.
## Paso 5: Eliminar
Cuando termine de trabajar con la aplicación, puede terminar el entorno. Elastic Beanstalk AWS cancela todos los recursos asociados a su entorno.
Utilice el comando siguiente de la CLI de EB para terminar su entorno de Elastic Beanstalk.
```
~/eb-nodejs$ eb terminate
```
## AWS recursos para su aplicación
Acaba de crear una aplicación de instancia única. Sirve como una aplicación de muestra sencilla con una sola EC2 instancia, por lo que no requiere balanceo de carga ni escalado automático. Para las aplicaciones de instancia única, Elastic Beanstalk crea los siguientes recursos: AWS
+ **EC2 instancia**: una máquina EC2 virtual de Amazon configurada para ejecutar aplicaciones web en la plataforma que elija.
Cada plataforma ejecuta un conjunto distinto de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco y contenedor web (o una combinación de ellos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que procesa el tráfico web delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.
+ **Grupo de seguridad de instancias**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP del balanceador de cargas llegue a la EC2 instancia que ejecuta tu aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Bucket de Amazon S3**: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.
+ ** CloudWatch Alarmas de Amazon**: dos CloudWatch alarmas que monitorean la carga de las instancias de su entorno y se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de escalado automático aumenta o reduce los recursos.
+ **CloudFormation pila**: Elastic CloudFormation Beanstalk se utiliza para lanzar los recursos de su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nombre de dominio***: un nombre de dominio que se dirige a su aplicación web en el formulario. *subdomain* *region*.elasticbeanstalk.com*.
Elastic Beanstalk administra todos estos recursos. Cuando termina su entorno, Elastic Beanstalk termina todos los recursos que este contiene.
## Siguientes pasos
Una vez que disponga de un entorno que ejecute una aplicación, podrá implementar una nueva versión de la aplicación o una aplicación distinta en cualquier momento. La implementación de una nueva versión de la aplicación es muy rápida porque no requiere aprovisionar ni reiniciar las instancias. EC2 También puede explorar el nuevo entorno con la consola de Elastic Beanstalk. Para ver los pasos detallados, consulte [Explore your environment](GettingStarted.md#GettingStarted.Explore) en el capítulo *Getting started* de esta guía.
**Probar más tutoriales**
Si desea probar otros tutoriales con diferentes aplicaciones de ejemplo, consulte [Más ejemplos de tutoriales y aplicaciones de Elastic Beanstalk para Node.js](nodejs-getstarted.md).
Después de que implemente una aplicación de muestra o dos y esté listo para empezar a desarrollar y poner en funcionamiento las aplicaciones de Node.js de forma local, consulte [Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk](nodejs-devenv.md).
## Implementar con la consola de Elastic Beanstalk
También puede utilizar la consola de Elastic Beanstalk para lanzar la aplicación de muestra. Para ver los pasos detallados, consulte [Create an example application](GettingStarted.md#GettingStarted.CreateApp) en el capítulo *Getting Started* de esta guía.
# Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk
Este tema proporciona instrucciones para configurar el entorno de desarrollo de Node.js para probar la aplicación localmente antes de implementarla en AWS Elastic Beanstalk. También hace referencia a sitios web que proporcionan instrucciones de instalación de herramientas útiles.
**Topics**
+ [Instale Node.js](#nodejs-devenv-nodejs)
+ [Confirmar la instalación de npm](#nodejs-devenv-npm)
+ [Instale el AWS SDK para Node.js](#nodejs-devenv-awssdk)
+ [Instale el generador Express](#nodejs-devenv-express)
+ [Configuración de una plataforma y un servidor Express](#nodejs-devenv-express-framework)
## Instale Node.js
Instale Node.js para ejecutar aplicaciones Node.js localmente. Si no tiene ninguna preferencia, obtenga la versión más reciente admitida por Elastic Beanstalk. Consulte [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) en el documento *AWS Elastic Beanstalk Plataformas* para ver una lista de las versiones que se admiten.
Descargue Node.js en [nodejs.org](https://nodejs.org/en/).
## Confirmar la instalación de npm
Node.js usa el administrador de paquetes npm como ayuda para instalar herramientas y marcos para usarlos en su aplicación. Dado que npm se distribuye con Node.js, lo instalará automáticamente cuando descargue e instale Node.js. Para confirmar que tiene npm instalado, puede ejecutar el siguiente comando:
```
$ npm -v
```
Para obtener más información sobre npm, visite el sitio web de [npmjs](https://www.npmjs.com/get-npm) .
## Instale el AWS SDK para Node.js
Si necesita administrar AWS los recursos desde su aplicación, instale el AWS SDK JavaScript en Node.js. Instale el SDK con npm:
```
$ npm install aws-sdk
```
Visita la página principal del [AWS SDK para JavaScript Node.js](https://aws.amazon.com/sdk-for-node-js/) para obtener más información.
## Instale el generador Express
Express es una plataforma de aplicaciones web que se ejecuta en Node.js. Para usarlo, primero debe instalar la aplicación de línea de comandos del generador Express. Una vez instalado el generador Express, puede ejecutar el comando **express** para generar una estructura de proyecto base para su aplicación web. Una vez el proyecto base, los archivos y las dependencias están instalados, puede iniciar un servidor Express local en su máquina de desarrollo.
**nota**
En estos pasos, se describe la instalación del generador Express en un sistema operativo Linux.
En el caso de Linux, en función de su nivel de permiso para los directorios del sistema, es posible que tenga que escribir delante de algunos de estos comandos con `sudo`.
**Para instalar el generador Express en su entorno de desarrollo**
1. Cree un directorio de trabajo para su plataforma y servidor Express.
```
~$ mkdir node-express
~$ cd node-express
```
1. Instale Express globalmente para disponer de acceso al comando `express`.
```
~/node-express$ npm install -g express-generator
```
1. En función del sistema operativo, es posible que tenga que definir la ruta para ejecutar el comando `express`. La salida del paso anterior proporciona información si necesita definir la variable de ruta. A continuación se muestra un ejemplo para Linux.
```
~/node-express$ export PATH=$PATH:/usr/local/share/npm/bin/express
```
Cuando siga los tutoriales de este capítulo, tendrá que ejecutar el comando **express** desde distintos directorios. Cada tutorial configura una estructura de proyecto Express de base en su propio directorio.
Ya tiene instalado el generador de línea de comandos Express. Puede usarlo para crear un directorio marco para su aplicación web, configurar dependencias e iniciar el servidor de aplicaciones web. A continuación, analizaremos los pasos para lograrlo en el directorio de `node-express` que hemos creado.
## Configuración de una plataforma y un servidor Express
Siga estos pasos para crear los directorios y el contenido del marco de Express de base. Los tutoriales en este capítulo también incluyen estos pasos para configurar el marco de Express de base en cada uno de los directorios de aplicaciones del tutorial.
**Para configurar un marco y un servidor Express**
1. Ejecute el comando `express`. Esto genera `package.json`, `app.js` y unos directorios.
```
~/node-express$ express
```
Cuando se le pregunte, escriba **y** si desea continuar.
1. Configure las dependencias locales.
```
~/node-express$ npm install
```
1. Compruebe que el servidor de aplicaciones web se inicie.
```
~/node-express$ npm start
```
Debería ver una salida similar a esta:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
El servidor se ejecuta en el puerto 3000 de forma predeterminada. Para probarlo, ejecute `curl http://localhost:3000` en otro terminal o abra un navegador en el equipo local e ingrese el `http://localhost:3000` de la dirección URL.
Presione **Ctrl\$1C** para detener el servidor.
# Uso de la plataforma Elastic Beanstalk Node.js
En este tema se describe cómo configurar, crear y ejecutar las aplicaciones Node.js en Elastic Beanstalk.
AWS Elastic Beanstalk admite varias ramas de plataforma para diferentes versiones del lenguaje de programación Node.js. Consulte [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) en el documento *Plataformas de AWS Elastic Beanstalk * para ver una lista completa.
Elastic Beanstalk proporciona [opciones de configuración](command-options.md) que se pueden utilizar para personalizar el software que se ejecuta en las instancias de EC2 del entorno de Elastic Beanstalk. Puede [configurar las variables de entorno](environments-cfg-softwaresettings.md#environments-cfg-softwaresettings-console) que necesita la aplicación, habilitar la rotación de registros en Amazon S3 y asignar carpetas del código fuente de la aplicación que contengan archivos estáticos a rutas proporcionadas por el servidor proxy.
En la consola de Elastic Beanstalk hay opciones de configuración disponibles para [modificar la configuración de un entorno en ejecución](environment-configuration-methods-after.md). Para evitar perder la configuración del entorno cuando lo termina, puede usar las [configuraciones guardadas](environment-configuration-savedconfig.md) para guardar la configuración y aplicarla posteriormente a otro entorno.
Para guardar la configuración en el código fuente, puede incluir [archivos de configuración](ebextensions.md). Los valores de configuración de los archivos de configuración se aplican cada vez que crea un entorno o que implementa la aplicación. También puede usar archivos de configuración para instalar paquetes, ejecutar scripts y llevar a cabo otras operaciones de personalización de instancias durante las implementaciones.
Puede [incluir un archivo `Package.json`](nodejs-platform-dependencies.md#nodejs-platform-packagejson) en el paquete de código fuente para instalar paquetes durante la implementación, para proporcionar un comando de inicio y para especificar la versión de Node.js que quiere que la aplicación utilice. Puede incluir un [archivo `npm-shrinkwrap.json`](nodejs-platform-shrinkwrap.md) para bloquear las versiones de dependencia.
La plataforma Node.js incluye un servidor proxy para distribuir recursos estáticos, reenviar el tráfico a la aplicación y comprimir las respuestas. Puede [ampliar o invalidar la configuración del proxy predeterminada](nodejs-platform-proxy.md) para escenarios avanzados.
Hay varias opciones para iniciar su aplicación. Puede agregar un [Procfile](nodejs-configuration-procfile.md) a su paquete de código fuente para especificar el comando que inicia la aplicación. Si no proporciona un `Procfile`, pero proporciona un archivo `package.json`, Elastic Beanstalk ejecuta `npm start`. Si no proporciona ninguno, Elastic Beanstalk busca los archivos `app.js` o `server.js`, en este orden, y ejecuta el script.
La configuración aplicada en la consola de Elastic Beanstalk anula la misma configuración en los archivos de configuración, si existe. Esto le permite tener la configuración predeterminada en los archivos de configuración y anularla con la configuración específica del entorno en la consola. Para obtener más información acerca de la prioridad y otros métodos para cambiar valores de configuración, consulte [Opciones de configuración](command-options.md).
Para obtener más información sobre las diversas formas en las que puede ampliar una plataforma Elastic Beanstalk basada en Linux, consulte [Ampliación de las plataformas Linux de Elastic Beanstalk](platforms-linux-extend.md).
## Configuración de su entorno de Node.js
Puede utilizar la configuración de la plataforma Node.js para ajustar el comportamiento de las instancias de Amazon EC2. Puede editar la configuración de la instancia de Amazon EC2 para el entorno de Elastic Beanstalk mediante la consola de Elastic Beanstalk.
Utilice la consola de Elastic Beanstalk para habilitar la rotación de registros en Amazon S3 y configurar variables que la aplicación pueda leer desde el entorno.
**Para configurar su entorno Node.js en la consola de Elastic Beanstalk**
1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS
1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.
1. En el panel de navegación, elija **Configuración**.
1. En la categoría de configuración **Actualizaciones, supervisión y registro**, seleccione **Edición de**.
### Opciones de contenedor
Puede especificar estas opciones específicas de la plataforma:
+ **Proxy server (Servidor proxy)**: el servidor proxy que utilizar en las instancias del entorno. Se utiliza NGINX de forma predeterminada.
### Log Options (Opciones de registro)
La sección **Log Options (Opciones de registro)** tiene dos valores:
+ **Perfil de instancia**: especifica el perfil de instancia que tiene permiso para obtener acceso al bucket de Amazon S3 asociado a la aplicación.
+ **Enable log file rotation to Amazon S3 (Habilitar la rotación de archivos de registro para Amazon S3)**: especifica si los archivos de registro de las instancias de Amazon EC2 de la aplicación se copian en el bucket de Amazon S3 asociado a la aplicación.
### Archivos estáticos
Para mejorar el rendimiento, puede utilizar la sección **Static files** (Archivos estáticos) para configurar el servidor proxy para entregar archivos estáticos de servidor (por ejemplo, HTML o imágenes) desde un conjunto de directorios dentro de su aplicación web. Para cada directorio, se establece la ruta virtual para la asignación de directorios. Cuando el servidor proxy recibe una solicitud de un archivo en la ruta especificada, proporciona directamente el archivo en lugar de direccionar la solicitud la aplicación.
Para obtener más información sobre la configuración de archivos estáticos mediante archivos de configuración o la consola de Elastic Beanstalk, consulte [Distribución de archivos estáticos](environment-cfg-staticfiles.md).
### Propiedades del entorno
Utilice la sección **Environment Properties (Propiedades de entorno)** para especificar opciones de configuración del entorno en las instancias Amazon EC2 que ejecutan la aplicación. Estos ajustes se pasan como pares clave-valor a la aplicación.
Dentro del Node.js entorno en el que se ejecuta AWS Elastic Beanstalk, puede acceder a las variables de entorno ejecutando`process.env.ENV_VARIABLE`.
```
var endpoint = process.env.API_ENDPOINT
```
La plataforma Node.js establece la variable de entorno PORT en el puerto al que el servidor proxy pasa el tráfico. Para obtener más información, consulte [Configuración del servidor proxy](nodejs-platform-proxy.md).
Para obtener más información, consulte [Configuración de las variables de entorno y otras opciones de software](environments-cfg-softwaresettings.md).
### Configuración de un entorno Node.js de la AMI de Amazon Linux (anterior a Amazon Linux 2)
Las siguientes categorías de configuración del software de la consola solo se admite en un entorno Node.js de Elastic Beanstalk que utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2).
**Notas**
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2023/las ramas de la AL2 plataforma son incompatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
[El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).
#### Opciones de contenedor: AMI de Amazon Linux (AL1)
En la página de configuración, especifique lo siguiente:
+ **Proxy Server** (Servidor proxy): especifica el servidor web que se utiliza para enviar las conexiones a Node.js. Se utiliza NGINX de forma predeterminada. Si selecciona **none** (ninguno), las asignaciones de archivos estáticos no se aplican y se desactiva la compresión GZIP.
+ **Versión de Node.js**: especifica la versión de Node.js. Para obtener una lista de las versiones de Node.js compatibles, consulte [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) en la guía *AWS Elastic Beanstalk Platforms*.
+ **Compresión GZIP**: especifica si la compresión GZIP está habilitada. La compresión GZIP está habilitada de forma predeterminada.
+ **Node command** (Comando de Node): permite escribir el comando que se utiliza para iniciar la aplicación de Node.js. Una cadena vacía (la predeterminada) significa que Elastic Beanstalk usa `app.js`, `server.js` y, luego, `npm start`.
## Espacio de nombres de configuración de Node.js
Puede usar un [archivo de configuración](ebextensions.md) para definir opciones de configuración y realizar otras tareas de configuración en las instancias durante las implementaciones. Las opciones de configuración pueden ser [específicas de la plataforma](command-options-specific.md) o aplicarse a [todas las plataformas](command-options-general.md) del servicio de Elastic Beanstalk en su conjunto. Las opciones de configuración se organizan en *espacios de nombres*.
Puede elegir el proxy que se utilizará en las instancias para el entorno mediante el uso del espacio de nombres `aws:elasticbeanstalk:environment:proxy`. En el siguiente ejemplo se configura el entorno para utilizar el servidor proxy Apache HTTPD.
**Example .ebextensions/nodejs-settings.config**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:
ProxyServer: apache
```
Puede configurar el proxy para que sirva archivos estáticos mediante el espacio de nombres `aws:elasticbeanstalk:environment:proxy:staticfiles`. Para obtener más información y un ejemplo, consulte [Distribución de archivos estáticos](environment-cfg-staticfiles.md).
Elastic Beanstalk cuenta con numerosas opciones de configuración para personalizar el entorno. Además de los archivos de configuración, también puede definir opciones en la consola, configuraciones guardadas, la CLI de EB o la AWS CLI. Para obtener más información, consulte [Opciones de configuración](command-options.md).
## Plataforma Node.js de la AMI de Amazon Linux (anterior a Amazon Linux 2)
Si el entorno Node.js de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), tenga en cuenta las configuraciones y las recomendaciones específicas de esta sección.
**Notas**
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2023/las ramas de la AL2 plataforma son incompatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
[El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).
### Node.jsopciones de configuración específicas de la plataforma: AMI de Amazon Linux () AL1
Elastic Beanstalk admite algunas opciones de configuración específicas de la plataforma para las versiones de la plataforma Node.js de la AMI de Amazon Linux. Puede elegir qué servidor proxy se ejecuta delante de su aplicación, la versión específica de Node.js que se debe ejecutar y el comando utilizado para ejecutar la aplicación.
Para el servidor proxy, puede utilizar un servidor proxy NGINX o Apache. Puede establecer el valor `none` en la opción `ProxyServer`. Con esta configuración, Elastic Beanstalk ejecuta la aplicación de forma independiente, sin que se relacione a ningún servidor proxy. Si el entorno ejecuta una aplicación independiente, actualice el código para escuchar al puerto al que NGINX reenvía tráfico.
```
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Server running at http://127.0.0.1:%s', port);
});
```
### Node.jsversiones lingüísticas — AMI de Amazon Linux (AL1)
En términos de la versión de lenguaje compatible, la plataforma Node.js de la AMI de Amazon Linux es diferente de otras plataformas administradas por Elastic Beanstalk. Esto se debe a que cada versión de la plataforma Node.js admite solo unas pocas versiones del lenguaje de Node.js. Para obtener una lista de las versiones de Node.js compatibles, consulte [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) en la guía *AWS Elastic Beanstalk Platforms*.
Puede utilizar una opción de configuración específica de la plataforma para establecer la versión del lenguaje. Para obtener instrucciones, consulte [Configuración de su entorno de Node.js](#nodejs-platform-console). Como alternativa, utilice la consola de Elastic Beanstalk para actualizar la versión Node.js que utiliza el entorno como parte de la actualización de la versión de la plataforma.
**nota**
Cuando la compatibilidad de la versión de Node.js que utiliza se elimine de la plataforma, deberá cambiar o eliminar la configuración de la versión antes de realizar una [actualización de la plataforma](using-features.platform.upgrade.md). Esto puede suceder cuando se identifica una vulnerabilidad de seguridad en una o varias versiones de Node.js
Cuando esto ocurre, se produce un [NodeVersion](command-options-specific.md#command-options-nodejs)error al intentar actualizar a una nueva versión de la plataforma que no admite la configuración. Para evitar tener que crear un entorno nuevo, cambie la opción de *NodeVersion*configuración a una versión de Node.js que sea compatible tanto con la versión antigua como con la nueva, o [elimine la configuración de la opción](environment-configuration-methods-after.md) y, a continuación, actualice la plataforma.
**Para configurar la versión Node.js del entorno en la consola de Elastic Beanstalk**
1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS
1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.
1. En la página de información general del entorno, en **Platform (Plataforma)**, elija **Change (Cambiar)**.
1. En el cuadro de diálogo **Update platform version** (Actualización de versiones de la plataforma), seleccione una versión de Node.js.
![\[Confirmación de la versión de la plataforma de actualización de Elastic Beanstalk\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/platform-nodejs-update-node-version.png)
1. Seleccione **Save**.
### Node.jsespacios de nombres de configuración: AMI de Amazon Linux () AL1
La plataforma Node.js de la AMI de Amazon Linux define opciones adicionales en los espacios de nombres `aws:elasticbeanstalk:container:nodejs:staticfiles` y `aws:elasticbeanstalk:container:nodejs`.
El siguiente archivo de configuración indica a Elastic Beanstalk que utilice`npm start` para ejecutar la aplicación. También establece el tipo de proxy en Apache y habilita la compresión. Por último, configura el proxy para que ofrezca archivos estáticos desde dos directorios fuente. Una fuente son los archivos HTML en la ruta `html` de la raíz del sitio web del directorio fuente `statichtml`. El otro origen son los archivos de imagen en la ruta `images` de la raíz del sitio web desde el directorio de origen `staticimages`.
**Example .ebextensions/node-settings.config**
```
option_settings:
aws:elasticbeanstalk:container:nodejs:
NodeCommand: "npm start"
ProxyServer: apache
GzipCompression: true
aws:elasticbeanstalk:container:nodejs:staticfiles:
/html: statichtml
/images: staticimages
```
Elastic Beanstalk cuenta con numerosas opciones de configuración para personalizar el entorno. Además de los archivos de configuración, también puede definir opciones en la consola, configuraciones guardadas, la CLI de EB o la AWS CLI. Para obtener más información, consulte [Opciones de configuración](command-options.md).
# Configuración de comandos de inicio personalizados con Procfile en Elastic Beanstalk
Puede incluir un archivo llamado `Procfile` en la raíz del paquete de código fuente para especificar el comando que inicia la aplicación.
**Example Procfile**
```
web: node index.js
```
Para obtener más información acerca del uso de `Procfile`, consulte [Buildfile y Procfile](platforms-linux-extend.build-proc.md).
**nota**
Esta característica reemplaza la opción heredada `NodeCommand` en el espacio de nombres `aws:elasticbeanstalk:container:nodejs`.
# Configuración de las dependencias de su aplicación en Elastic Beanstalk
La aplicación puede tener dependencias en algunos módulos Node.js, como los que se especifican en las declaraciones `require()`. Los módulos se almacenan en un directorio `node_modules`. Cuando se ejecuta la aplicación, Node.js carga los módulos de este directorio. Para obtener más información, consulte [Loading from node\$1modules folders](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) (Carga desde carpetas node\$1modules) en la documentación de Node.js.
Puede especificar las dependencias de módulos mediante un archivo `package.json`. Si Elastic Beanstalk detecta este archivo y no hay un directorio `node_modules`, ejecuta `npm install` como el usuario *webapp*. El comando `npm install` instala las dependencias en el directorio `node_modules`, que Elastic Beanstalk crea previamente. El comando `npm install` accede a los paquetes que figuran en el archivo `package.json` desde el registro npm público o de otras ubicaciones. Para obtener más información, consulte el sitio web [npm Docs](https://docs.npmjs.com/about-the-public-npm-registry).
Si Elastic Beanstalk detecta el directorio `node_modules`, no ejecuta `npm install`, incluso si existe un archivo `package.json`. Elastic Beanstalk asume que los paquetes de dependencias están disponibles en el directorio `node_modules` para que Node.js pueda acceder y cargar.
En las siguientes secciones, se ofrece más información sobre cómo establecer las dependencias de los módulos de Node.js de la aplicación.
**nota**
Si sufre algún problema de implementación cuando Elastic Beanstalk está ejecutando `npm install`, considere un enfoque alternativo. Incluya el directorio `node_modules` con los módulos de dependencias en el paquete de código fuente de la aplicación. De esta manera se pueden evitar problemas relacionados con la instalación de dependencias del registro npm público mientras se investiga el problema. Como los módulos de dependencia provienen de un directorio local, hacer esto también podría ayudar a reducir el tiempo de implementación. Para obtener más información, consulte [Inclusión de dependencias Node.js en un directorio node\$1modules](#nodejs-platform-nodemodules)
## Especificación de dependencias de Node.js con un archivo package.json
Incluya un archivo `package.json` en la raíz del proyecto de origen para especificar paquetes de dependencias y proporcionar un comando de inicio. Cuando hay un archivo `package.json` y no hay un directorio `node_modules` en la raíz de la fuente del proyecto, Elastic Beanstalk ejecuta `npm install` como el usuario *webapp* para instalar las dependencias del registro npm público. Elastic Beanstalk también utiliza el comando `start` para iniciar la aplicación. Para obtener más información sobre el archivo `package.json`, consulte [Especificación de dependencias en un archivo `package.json`](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) en el sitio web *npm Docs*.
Utilice la palabra clave `scripts` para proporcionar un comando de inicio. En la actualidad, la palabra clave `scripts` se utiliza en lugar de la opción heredada `NodeCommand` en el espacio de nombres `aws:elasticbeanstalk:container:nodejs`.
**Example package.json: Express**
```
{
"name": "my-app",
"version": "0.0.1",
"private": true,
"dependencies": {
"ejs": "latest",
"aws-sdk": "latest",
"express": "latest",
"body-parser": "latest"
},
"scripts": {
"start": "node app.js"
}
}
```
**Modo de producción y dependencias de desarrollo**
Para especificar sus dependencias en el archivo `package.json`, utilice los atributos *dependencies* y *devDependencies*. El atributo *dependencias* designa los paquetes que necesita la aplicación en producción. El atributo *devDependencies* designa los paquetes que solo se necesitan para el desarrollo y las pruebas locales.
Si necesita instalar los paquetes *devDependencies*, defina la propiedad del entorno NPM\$1USE\$1PRODUCTION en`false`. Con esta configuración, no utilizaremos las opciones anteriores cuando ejecutemos la instalación de npm. Esto hará que se instalen los paquetes de atributos *devDependencies*.
## Inclusión de dependencias Node.js en un directorio node\$1modules
Para implementar paquetes de dependencias en instancias del entorno junto con el código de la aplicación, inclúyalos en un directorio llamado `node_modules` en la raíz del origen del proyecto. Para obtener más información, consulte [Downloading and installing packages locally](https://docs.npmjs.com/downloading-and-installing-packages-locally) (Descarga e instalación de paquetes a nivel local) en el sitio web *npm Docs*.
[Al implementar un `node_modules` directorio en una versión de AL2 Node.js plataforma AL2023/, Elastic Beanstalk asume que está proporcionando sus propios paquetes de dependencias y evita instalar las dependencias especificadas en un archivo package.json.](#nodejs-platform-packagejson) Node.jsbusca las dependencias en el directorio. `node_modules` Para obtener más información, consulte [Loading from node\$1modules Folders](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders) (Carga desde carpetas node\$1modules) en la documentación de Node.js.
**nota**
Si sufre algún problema de implementación cuando Elastic Beanstalk ejecuta `npm install`, considere la posibilidad de utilizar el enfoque descrito en este tema como solución alternativa mientras investiga el problema.
### Consideraciones sobre Node.js en Amazon Linux 2
Lea esta sección si utiliza una rama de la plataforma *Node.js* que se ejecuta en *Amazon Linux 2*.
#### Consideraciones sobre Node.js en Amazon Linux 2
**nota**
La información de este tema se aplica a las ramas de Node.js plataforma que se ejecutan en Amazon Linux 2. El contenido aquí describe características y comportamientos AL2 específicos que difieren de AL2023.
**Variaciones de comandos**
Las opciones de comando varían en función de la versión de npm incluida en la rama de la plataforma Amazon Linux 2 en la que se ejecute la aplicación.
+ npm v6: de forma predeterminada, Elastic Beanstalk instala dependencias en modo de producción. Usa el comando `npm install --production`.
+ npm v7 o superior: Elastic Beanstalk omite el atributo *devDependencies*. Usa el comando `npm install --omit=dev`.
Los dos comandos enumerados anteriormente no instalan los paquetes que son atributos *devDependencies*.
**Protocolos SSH y HTTPS para las dependencias de Git**
A partir de la versión de la plataforma Amazon Linux 2 del 7 de marzo de 2023, puede utilizar los protocolos SSH y HTTPS para recuperar paquetes de un repositorio de Git. La ramificación de la plataforma 16 de Node.js admite los protocolos SSH y HTTPS. 14 de Node.js solo admite el protocolo HTTPS.
**Example package.json: 16 de Node.js admite HTTPS y SSH**
```
...
"dependencies": {
"aws-sdk": "https://github.com/aws/aws-sdk-js.git",
"aws-chime": "git+ssh://git@github.com:aws/amazon-chime-sdk-js.git"
}
```
**Versiones y rangos de las versiones**
Utilice la palabra clave `engines` del archivo `package.json` para especificar la versión de Node.js que desea que utilice la aplicación. También puede especificar un rango de versiones mediante la notación npm. Para obtener más información sobre la sintaxis de los rangos de versiones, consulte [Semantic Versioning using npm](https://nodejs.dev/learn/semantic-versioning-using-npm) (Control de versiones semánticas mediante npm) en el sitio web de Node.js. La palabra clave `engines` del archivo `package.json` de Node.js reemplaza la opción heredada `NodeVersion` en el espacio de nombres `aws:elasticbeanstalk:container:nodejs`.
**importante**
La función para especificar los rangos de versiones no está disponible para las sucursales de la plataforma Node.js en AL2023 las que se estén ejecutando. Solo admitimos una versión de Node.js en una rama Node.js específica AL2023. Si el archivo `package.json` especifica un rango de versiones, lo ignoraremos y utilizaremos de forma predeterminada la versión de la ramificación de la plataforma de Node.js.
**Example `package.json`: versión de Node.js única**
```
{
...
"engines": { "node" : "14.16.0" }
}
```
**Example `package.json`: rango de versiones de Node.js**
```
{
...
"engines": { "node" : ">=10 <11" }
}
```
Cuando se indica un rango de versiones, Elastic Beanstalk instala la última versión de Node.js que la plataforma tiene disponible dentro del rango. En este ejemplo, el rango indica que la versión debe ser mayor o igual que la versión 10, pero inferior que la versión 11. Como resultado, Elastic Beanstalk instala la última versión 10.x.y de Node.js, que está disponible en la [plataforma compatible](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs).
Tenga en cuenta que solo puede especificar una versión de Node.js que corresponda con la ramificación de la plataforma. Por ejemplo, si utiliza la ramificación de la plataforma 16 de Node.js, puede especificar solo una versión 16.x.y de Node.js. Puede utilizar las opciones del rango de versiones admitidas por npm para aumentar la flexibilidad. Para obtener versiones válidas de Node.js para cada ramificación de la plataforma, consulte [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs) en la guía *AWS Elastic Beanstalk Platforms*.
**nota**
Cuando la compatibilidad de la versión de Node.js que utiliza se elimine de la plataforma, deberá cambiar o eliminar la configuración de la versión de Node.js antes de realizar una [actualización de la plataforma](using-features.platform.upgrade.md). Esto puede suceder cuando se identifica una vulnerabilidad de seguridad en una o varias versiones de Node.js
Cuando esto sucede, si se intenta actualizar a una nueva versión de la plataforma no compatible con la versión de Node.js configurada, se producirá un error. Para evitar la necesidad de crear un nuevo entorno, cambie la configuración de la versión Node.js`package.json` a una versión Node.js compatible con las versiones anterior y nueva de la plataforma. Tiene la opción de especificar un rango de versiones de Node.js que incluya una versión compatible, como se describió anteriormente en este tema. También tiene la opción de eliminar la configuración e implementar el nuevo paquete de origen.
# Bloqueo de dependencias con npm shrinkwrap en Elastic Beanstalk
La plataforma Node.js ejecuta `npm install` como el usuario *webapp* cada vez que se realiza una implementación. Las versiones de dependencias nuevas disponibles se instalan cuando usted implementa la aplicación, lo que puede ocasionar demoras durante el proceso de implementación.
Puede evitar que se actualicen las dependencias creando un archivo `npm-shrinkwrap.json` que bloquee las dependencias de la aplicación en la versión actual.
```
$ npm install
$ npm shrinkwrap
wrote npm-shrinkwrap.json
```
Incluya este archivo en su paquete de código fuente para asegurarse de que las dependencias solo se instalan una vez.
# Configuración del servidor proxy
Elastic Beanstalk puede utilizar NGINX o Apache HTTPD como proxy inverso para asignar la aplicación al equilibrador de carga de Elastic Load Balancing en el puerto 80. El valor predeterminado es NGINX. Elastic Beanstalk proporciona una configuración de proxy predeterminada que puede ampliar o invalidar completamente su propia configuración.
De forma predeterminada, Elastic Beanstalk configura el proxy para reenviar las solicitudes a la aplicación en el puerto 5000. Puede invalidar el puerto predeterminado al establecer la `PORT`[propiedad del entorno](create_deploy_nodejs.container.md#nodejs-platform-console) en el puerto en el que la aplicación principal esté a la escucha.
**nota**
El puerto en el que su aplicación escucha no afecta al puerto en el que el servidor NGINX escucha para recibir solicitudes del equilibrador de carga.
**Configuración del servidor proxy en la versión de su plataforma**
Todas las AL2 plataformas AL2023/admiten una función de configuración de proxy uniforme. Para obtener más información sobre la configuración del servidor proxy en las versiones de su plataforma que ejecutan AL2023/AL2, consulte[Configuración del proxy inverso](platforms-linux-extend.proxy.md).
## Configuración del proxy en la AMI de Amazon Linux (anterior a Amazon Linux 2)
Si el entorno Node.js de Elastic Beanstalk utiliza una versión de la plataforma de la AMI de Amazon Linux (anterior a Amazon Linux 2), lea la información de esta sección.
**Notas**
La información de este tema solo se aplica a las ramas de plataforma basadas en la AMI de Amazon Linux (AL1). AL2023/las ramas de la AL2 plataforma son incompatibles con las versiones anteriores de la plataforma AMI (AL1) de Amazon Linux y *requieren ajustes de configuración diferentes*.
[El 18 de julio de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk estableció el estado de todas las ramas de plataforma basadas en la AMI AL1 de Amazon Linux () como retiradas.** Para obtener más información sobre la migración a una ramificación de la plataforma Amazon Linux 2023 actual y totalmente compatible, consulte [Migración de su aplicación de Linux de Elastic Beanstalk a Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).
### Ampliación y anulación de la configuración de proxy predeterminada: AMI de Amazon Linux () AL1
La plataforma Node.js utiliza un proxy inverso para transmitir las solicitudes del puerto 80 de la instancia a la aplicación que está a la escucha en el puerto 8081. Elastic Beanstalk proporciona una configuración de proxy predeterminada que puede ampliar o invalidar completamente su propia configuración.
Para ampliar la configuración predeterminada, añada archivos `.conf` a `/etc/nginx/conf.d` con un archivo de configuración. Para ver un ejemplo específico, consulte[Terminación de HTTPS en instancias EC2 que ejecutan Node.js](https-singleinstance-nodejs.md).
La plataforma Node.js establece la variable de entorno PORT en el puerto al que el servidor proxy pasa el tráfico. Lea esta variable en el código para configurar el puerto de la aplicación.
```
var port = process.env.PORT || 3000;
var server = app.listen(port, function () {
console.log('Server running at http://127.0.0.1:' + port + '/');
});
```
La configuración predeterminada de NGINX reenvía el tráfico a un servidor ascendente denominado `nodejs` en `127.0.0.1:8081`. Puede eliminar la configuración predeterminada y proporcionar la propia en un [archivo de configuración](ebextensions.md).
**Example .ebextensions/proxy.config**
El siguiente ejemplo elimina la configuración predeterminada y agrega una configuración personalizada que reenvía el tráfico al puerto 5000, en lugar del puerto 8081.
```
files:
/etc/nginx/conf.d/proxy.conf:
mode: "000644"
owner: root
group: root
content: |
upstream nodejs {
server 127.0.0.1:5000;
keepalive 256;
}
server {
listen 8080;
if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
set $year $1;
set $month $2;
set $day $3;
set $hour $4;
}
access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
access_log /var/log/nginx/access.log main;
location / {
proxy_pass http://nodejs;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
gzip on;
gzip_comp_level 4;
gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
location /static {
alias /var/app/current/static;
}
}
/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh:
mode: "000755"
owner: root
group: root
content: |
#!/bin/bash -xe
rm -f /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf
service nginx stop
service nginx start
container_commands:
removeconfig:
command: "rm -f /tmp/deployment/config/#etc#nginx#conf.d#00_elastic_beanstalk_proxy.conf /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf"
```
La configuración de ejemplo (`/etc/nginx/conf.d/proxy.conf`) utiliza la configuración predeterminada de `/etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf` como punto de partida para incluir el bloque de servidores predeterminado con configuración de compresión y registros y un mapeo de archivos estáticos.
El comando `removeconfig` elimina la configuración predeterminada del contenedor para asegurarse de que el servidor proxy utiliza la configuración personalizada. Elastic Beanstalk vuelve a crear la configuración predeterminada cuando se implementa cada configuración. Para tener esto en cuenta, en el siguiente ejemplo, se agrega un post-configuration-deployment hook (`/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh`). Esto elimina la configuración predeterminada y reinicia el servidor proxy.
**nota**
La configuración predeterminada puede cambiar en las próximas versiones de la plataforma Node.js. Utilice la última versión de la configuración como punto de partida para las personalizaciones con el fin de garantizar la compatibilidad.
Si anula la configuración predeterminada, debe definir las asignaciones de archivos estáticos y la compresión GZIP. Esto se debe a que la plataforma no puede aplicar la [ configuración estándar](create_deploy_nodejs.container.md#nodejs-namespaces).
# Más ejemplos de tutoriales y aplicaciones de Elastic Beanstalk para Node.js
En esta sección se proporcionan más aplicaciones y tutoriales. En el tema [QuickStart para Node.js](nodejs-quickstart.md) anterior, se explica cómo iniciar la aplicación Node.js de ejemplo con la CLI de EB.
Para empezar a utilizar las aplicaciones de Node.js AWS Elastic Beanstalk, lo único que necesita es un [paquete de código fuente](applications-sourcebundle.md) de la aplicación para cargarlo como primera versión de la aplicación e implementarlo en un entorno.
## Lanzar un entorno con una aplicación de Node.js de ejemplo
Elastic Beanstalk proporciona aplicaciones de muestra de una sola página para cada plataforma, así como ejemplos más complejos que muestran el uso de recursos AWS adicionales, como Amazon RDS y características específicas de cada idioma o plataforma y. APIs
**nota**
Siga los pasos del archivo `README.md` del paquete de origen para implementarlo.
**Muestras**
| Tipo de entorno | Paquete de código fuente | Description (Descripción) |
| --- | --- | --- |
| Servidor web | [nodejs.zip](samples/nodejs.zip) | Aplicación de una sola página. Para lanzar la aplicación de muestra con la CLI de EB, consulte [QuickStart para Node.js](nodejs-quickstart.md). También puede utilizar la consola de Elastic Beanstalk para lanzar la aplicación de muestra. Para ver los pasos detallados, consulte [Create an example application](GettingStarted.md#GettingStarted.CreateApp) en el capítulo *Getting Started* de esta guía. |
| Servidor web con Amazon RDS | [nodejs-example-express-rds.zip](samples/nodejs-example-express-rds.zip) | Aplicación de registros de hiking que utiliza el marco Express y un Amazon Relational Database Service (RDS). [Tutorial](create_deploy_nodejs_express.md) |
| Servidor web con Amazon ElastiCache | [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip) | Aplicación web Express que utiliza Amazon ElastiCache para la agrupación en clústeres. La agrupación en clústeres mejora la disponibilidad, el desempeño y la seguridad de su aplicación web. [Tutorial](nodejs-express-clustering.md) |
| Servidor web con DynamoDB, Amazon SNS y Amazon SQS | [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) | Sitio web Express que recopila información de contacto de los usuarios para la campaña de marketing de una empresa. Utiliza el AWS SDK de Node.js para escribir entradas JavaScript en una tabla de DynamoDB y los archivos de configuración de Elastic Beanstalk para crear recursos en DynamoDB, Amazon SNS y Amazon SQS. [Tutorial](nodejs-dynamodb-tutorial.md) |
## Siguientes pasos
Una vez que disponga de un entorno que ejecute una aplicación, podrá implementar una nueva versión de la aplicación o una aplicación totalmente diferente en cualquier momento. La implementación de una nueva versión de la aplicación es una tarea muy rápida, ya que no se requiere aprovisionar ni reiniciar instancias EC2. Para obtener más información sobre la implementación de aplicaciones, consulte [Implementar una nueva versión de la aplicación](GettingStarted.md#GettingStarted.DeployApp).
Después de haber implementado una o dos aplicaciones de ejemplo y una vez que esté preparado para empezar a desarrollar y ejecutar aplicaciones Node.js localmente, consulte [Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk](nodejs-devenv.md) para configurar un entorno de desarrollo de Node.js con todas las herramientas que va a necesitar.
# Implementación de una aplicación Express Node Js. en Elastic Beanstalk
En esta sección, se describe cómo se implementa una aplicación de muestra en Elastic Beanstalk con la interfaz de línea de comando de Elastic Beanstalk (CLI de EB), y cómo se la actualiza después para utilizar el marco de [Express](http://expressjs.com/).
## Requisitos previos
Este tutorial tiene siguientes los requisitos previos:
+ Los tiempos de ejecución de Node.js
+ El software de administración de paquetes de Node.js predeterminado, npm
+ El generador de línea de comandos Express
+ La interfaz de línea de comando de Elastic Beanstalk (CLI de EB)
Para obtener más detalles acerca de la instalación de los primeros tres componentes y la configuración de su entorno de desarrollo local, consulte [Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk](nodejs-devenv.md). Para este tutorial, no necesitas instalar el AWS SDK para Node.js, que también se menciona en el tema al que se hace referencia.
Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte [Instalación de la CLI de EB con el script de configuración (recomendado)](eb-cli3.md#eb-cli3-install) y [Configuración de la CLI de EB](eb-cli3-configuration.md).
## Cree un entorno de Elastic Beanstalk
**Su directorio de aplicaciones**
Este tutorial usa un directorio llamado `nodejs-example-express-rds` para el paquete de origen de la aplicación. Cree el directorio `nodejs-example-express-rds` para este tutorial.
```
~$ mkdir nodejs-example-express-rds
```
**nota**
Cada tutorial de este capítulo usa su propio directorio para el paquete de origen de la aplicación. El nombre del directorio coincide con el nombre de la aplicación de muestra utilizada en el tutorial.
Cambie su directorio de trabajo actual a `nodejs-example-express-rds`.
```
~$ cd nodejs-example-express-rds
```
Ahora configuremos un entorno de Elastic Beanstalk que ejecute la plataforma Node.js y la aplicación de muestra. Se usará la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB)
**Para configurar un repositorio en la CLI de EB para la aplicación y crear un entorno de Elastic Beanstalk que ejecute la plataforma Node.js**
1. Cree un repositorio con el comando **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-rds$ eb init --platform node.js --region
```
Este comando crea un archivo de configuración en una carpeta llamada `.elasticbeanstalk` que especifica los ajustes para crear los entornos de la aplicación y crea una aplicación de Elastic Beanstalk con el nombre de la carpeta actual.
1. Cree un entorno que ejecute una aplicación de muestra con el comando **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds
```
Este comando crea un entorno con equilibrador de carga utilizando la configuración predeterminada de la plataforma de Node.js y los siguientes recursos:
+ **EC2 instancia**: una máquina virtual de Amazon Elastic Compute Cloud (Amazon EC2) configurada para ejecutar aplicaciones web en la plataforma que elijas.
Cada plataforma ejecuta un conjunto específico de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco de trabajo y contenedor web (o una combinación de estos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que se sitúa delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.
+ **Grupo de seguridad de instancias**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP del balanceador de cargas llegue a la EC2 instancia que ejecuta tu aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Balanceador de carga**: equilibrador de carga de Elastic Load Balancing configurado para distribuir solicitudes a las instancias que se ejecutan en la aplicación. Los balanceadores de carga también permiten que las instancias no estén expuestas directamente a Internet.
+ **Grupo de seguridad del balanceador de carga**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente de Internet llegue al equilibrador de carga. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Grupo de escalado automático**: grupo de escalado automático configurado para reemplazar una instancia si termina o deja de estar disponible.
+ **Bucket de Amazon S3**: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.
+ ** CloudWatch Alarmas de Amazon**: dos CloudWatch alarmas que monitorean la carga de las instancias de su entorno y que se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de escalado automático aumenta o reduce los recursos.
+ **CloudFormation pila**: Elastic CloudFormation Beanstalk se utiliza para lanzar los recursos de su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nombre de dominio***: un nombre de dominio que se dirige a su aplicación web en el formulario. *subdomain* *region*.elasticbeanstalk.com*.
**Seguridad de dominios**
Para aumentar la seguridad de las aplicaciones de Elastic Beanstalk, el dominio *elasticbeanstalk.com* está registrado en la [lista de sufijos públicos (PSL)](https://publicsuffix.org/).
Para mayor seguridad, se recomienda que utilice cookies con un prefijo `__Host-` en caso de que necesite configurar cookies confidenciales en el nombre de dominio predeterminado de sus aplicaciones de Elastic Beanstalk. Esta práctica le ayuda a proteger su dominio de los intentos de falsificación de solicitudes entre sitios (CSRF). Para más información, consulte la página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) en la red de desarrolladores de Mozilla.
1. Cuando se complete la creación del entorno, utilice el comando [**eb open**](eb3-open.md) para abrir la URL del entorno en el navegador predeterminado.
```
~/nodejs-example-express-rds$ eb open
```
Ahora ha creado un entorno de Elastic Beanstalk para Node.js con una aplicación de muestra. Puede actualizarlo con su propia aplicación. Luego, actualizamos la aplicación de muestra para que use el marco de Express.
## Actualización de la aplicación para que use Express
Una vez que haya creado el entorno con una aplicación de muestra, puede actualizarlo con su propia aplicación. En este procedimiento, ejecutamos primero los comandos**express** y **npm install** para configurar el marco de Express en el directorio de la aplicación. Luego use la CLI de EB para actualizar su entorno Elastic Beanstalk con la aplicación actualizada.
**Si desea actualizar la aplicación para que use Express**
1. Ejecute el comando `express`. Esto genera `package.json`, `app.js` y unos directorios.
```
~/nodejs-example-express-rds$ express
```
Cuando se le pregunte, escriba **y** si desea continuar.
**nota**
Si el comando **express** no funciona, es posible que no haya instalado el generador de línea de comandos Express tal y como se describe en la sección *Requisitos previos* anterior. O bien, puede que sea necesario configurar la ruta del directorio de su máquina local para ejecutar el comando **express**. Consulte la sección *Requisitos previos* para conocer los pasos detallados sobre la configuración del entorno de desarrollo, de modo que pueda continuar con este tutorial.
1. Configure las dependencias locales.
```
~/nodejs-example-express-rds$ npm install
```
1. (Opcional) Compruebe que el servidor de aplicaciones web se inicie.
```
~/nodejs-example-express-rds$ npm start
```
Debería ver una salida similar a esta:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
El servidor se ejecuta en el puerto 3000 de forma predeterminada. Para probarlo, ejecute `curl http://localhost:3000` en otro terminal o abra un navegador en el equipo local e ingrese el `http://localhost:3000` de la dirección URL.
Presione **Ctrl\$1C** para detener el servidor.
1. Implemente los cambios en su entorno Elastic Beanstalk con el comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
1. Una vez que el entorno esté listo, actualice la dirección URL para verificar que ha funcionado. Debería aparecer una página web que diga **Welcome to Express**.
A continuación, vamos a actualizar la aplicación de Express para atender archivos estáticos y agregar una nueva página.
**Para configurar archivos estáticos y agregar una nueva página a la aplicación de Express**
1. Agregue un segundo archivo de configuración en la carpeta [`.ebextensions`](ebextensions.md) con el contenido siguiente:
**`nodejs-example-express-rds/.ebextensions/staticfiles.config`**
```
option_settings:
aws:elasticbeanstalk:environment:proxy:staticfiles:
/stylesheets: public/stylesheets
```
Esta opción configura el servidor proxy que proporcione los archivos en la carpeta `public` de la ruta `/public` de la aplicación. Si los archivos se sirven de forma estática desde el servidor proxy, se reduce la carga en la aplicación. Para obtener más información, consulte [Archivos estáticos](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles) mencionada previamente en este capítulo.
1. (Opcional) Para confirmar que las asignaciones estáticas están configuradas correctamente, comente la configuración de asignación estática en `nodejs-example-express-rds/app.js`. Esto elimina la asignación de la aplicación de nodos.
```
// app.use(express.static(path.join(__dirname, 'public')));
```
Las asignaciones de archivos estáticas del archivo `staticfiles.config` del paso anterior deberían seguir cargando la hoja de estilos correctamente, incluso después de comentar esta línea. Para comprobar que las asignaciones de archivos estáticas se cargan mediante la configuración de archivos estáticos del proxy, en lugar de mediante la aplicación exprés, elimine los valores siguientes`option_settings:`. Una vez que se haya eliminado de la configuración del archivo estático y de la aplicación de nodo, la hoja de estilos no se cargará.
Recuerde restablecer el contenido de `nodejs-example-express-rds/app.js` y de `staticfiles.config` cuando haya terminado las pruebas.
1. Añada `nodejs-example-express-rds/routes/hike.js`. Escriba lo siguiente:
```
exports.index = function(req, res) {
res.render('hike', {title: 'My Hiking Log'});
};
exports.add_hike = function(req, res) {
};
```
1. Actualice `nodejs-example-express-rds/app.js` para incluir tres nuevas líneas.
En primer lugar, inserte la siguiente línea para agregar un objeto `require` para esta ruta:
```
var hike = require('./routes/hike');
```
El archivo debe ser similar al siguiente fragmento:
```
var express = require('express');
var path = require('path');
var hike = require('./routes/hike');
```
A continuación, agregue las dos líneas siguientes a `nodejs-example-express-rds/app.js` detrás de `var app = express();`.
```
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
El archivo debe ser similar al siguiente fragmento:
```
var app = express();
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
```
1. Copie `nodejs-example-express-rds/views/index.jade` en `nodejs-example-express-rds/views/hike.jade`.
```
~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
```
1. Implemente los cambios con el comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
1. Su entorno se actualizará al cabo de unos minutos. Cuando el entorno esté listo, asegúrese de que funciona actualizando el navegador y agregando **hikes** al final de la URL (por ejemplo, `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`).
Debería ver una página web con el título **My Hiking Log**.
Ya ha creado una aplicación web que utiliza el marco Express. En la siguiente sección, modificaremos la aplicación para utilizar un Amazon Relational Database Service (RDS) para almacenar un registro de hiking.
## Actualice la aplicación para que use Amazon RDS.
En el siguiente paso, actualizamos la aplicación para usar Amazon RDS para MySQL.
**Para actualizar la aplicación para que use RDS para MySQL**
1. Para crear una base de datos RDS para MySQL acoplada a su entorno de Elastic Beanstalk, siga las instrucciones del tema [Agregar una base de datos](create-deploy-nodejs.rds.md) que se incluye más adelante en este capítulo. Añadir una instancia de base de datos demora aproximadamente 10 minutos.
1. Actualice la sección de dependencias en `package.json` con el siguiente contenido:
```
"dependencies": {
"async": "^3.2.4",
"express": "4.18.2",
"jade": "1.11.0",
"mysql": "2.18.1",
"node-uuid": "^1.4.8",
"body-parser": "^1.20.1",
"method-override": "^3.0.0",
"morgan": "^1.10.0",
"errorhandler": "^1.5.1"
}
```
1. Ejecute **npm install**.
```
~/nodejs-example-express-rds$ npm install
```
1. Actualice `app.js` para conectarse a la base de datos, crear una tabla e insertar un único registro de hiking predeterminado. Cada vez que se implemente esta aplicación, eliminará la tabla de hiking anterior y la volverá a crear.
```
/**
* Module dependencies.
*/
const express = require('express')
, routes = require('./routes')
, hike = require('./routes/hike')
, http = require('http')
, path = require('path')
, mysql = require('mysql')
, async = require('async')
, bodyParser = require('body-parser')
, methodOverride = require('method-override')
, morgan = require('morgan')
, errorhandler = require('errorhandler');
const { connect } = require('http2');
const app = express()
app.set('views', __dirname + '/views')
app.set('view engine', 'jade')
app.use(methodOverride())
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(express.static(path.join(__dirname, 'public')))
app.set('connection', mysql.createConnection({
host: process.env.RDS_HOSTNAME,
user: process.env.RDS_USERNAME,
password: process.env.RDS_PASSWORD,
port: process.env.RDS_PORT}));
function init() {
app.get('/', routes.index);
app.get('/hikes', hike.index);
app.post('/add_hike', hike.add_hike);
}
const client = app.get('connection');
async.series([
function connect(callback) {
client.connect(callback);
console.log('Connected!');
},
function clear(callback) {
client.query('DROP DATABASE IF EXISTS mynode_db', callback);
},
function create_db(callback) {
client.query('CREATE DATABASE mynode_db', callback);
},
function use_db(callback) {
client.query('USE mynode_db', callback);
},
function create_table(callback) {
client.query('CREATE TABLE HIKES (' +
'ID VARCHAR(40), ' +
'HIKE_DATE DATE, ' +
'NAME VARCHAR(40), ' +
'DISTANCE VARCHAR(40), ' +
'LOCATION VARCHAR(40), ' +
'WEATHER VARCHAR(40), ' +
'PRIMARY KEY(ID))', callback);
},
function insert_default(callback) {
const hike = {HIKE_DATE: new Date(), NAME: 'Hazard Stevens',
LOCATION: 'Mt Rainier', DISTANCE: '4,027m vertical', WEATHER:'Bad', ID: '12345'};
client.query('INSERT INTO HIKES set ?', hike, callback);
}
], function (err, results) {
if (err) {
console.log('Exception initializing database.');
throw err;
} else {
console.log('Database initialization complete.');
init();
}
});
module.exports = app
```
1. Agregue el siguiente contenido a `routes/hike.js`. Esto permitirá a las rutas insertar nuevos registros de hiking en la base de datos de *HIKES*.
```
const uuid = require('node-uuid');
exports.index = function(req, res) {
res.app.get('connection').query( 'SELECT * FROM HIKES', function(err,
rows) {
if (err) {
res.send(err);
} else {
console.log(JSON.stringify(rows));
res.render('hike', {title: 'My Hiking Log', hikes: rows});
}});
};
exports.add_hike = function(req, res){
const input = req.body.hike;
const hike = { HIKE_DATE: new Date(), ID: uuid.v4(), NAME: input.NAME,
LOCATION: input.LOCATION, DISTANCE: input.DISTANCE, WEATHER: input.WEATHER};
console.log('Request to log hike:' + JSON.stringify(hike));
req.app.get('connection').query('INSERT INTO HIKES set ?', hike, function(err) {
if (err) {
res.send(err);
} else {
res.redirect('/hikes');
}
});
};
```
1. Reemplace todo el contenido de `routes/index.js` por lo siguiente:
```
/*
* GET home page.
*/
exports.index = function(req, res){
res.render('index', { title: 'Express' });
};
```
1. Añada la siguiente plantilla de jade a `views/hike.jade` para proporcionar la interfaz de usuario para añadir registros de hiking.
```
extends layout
block content
h1= title
p Welcome to #{title}
form(action="/add_hike", method="post")
table(border="1")
tr
td Your Name
td
input(name="hike[NAME]", type="textbox")
tr
td Location
td
input(name="hike[LOCATION]", type="textbox")
tr
td Distance
td
input(name="hike[DISTANCE]", type="textbox")
tr
td Weather
td
input(name="hike[WEATHER]", type="radio", value="Good")
| Good
input(name="hike[WEATHER]", type="radio", value="Bad")
| Bad
input(name="hike[WEATHER]", type="radio", value="Seattle", checked)
| Seattle
tr
td(colspan="2")
input(type="submit", value="Record Hike")
div
h3 Hikes
table(border="1")
tr
td Date
td Name
td Location
td Distance
td Weather
each hike in hikes
tr
td #{hike.HIKE_DATE.toDateString()}
td #{hike.NAME}
td #{hike.LOCATION}
td #{hike.DISTANCE}
td #{hike.WEATHER}
```
1. Implemente los cambios con el comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-rds$ eb deploy
```
## Limpieza
Si ha terminado de trabajar con Elastic Beanstalk, puede terminar su entorno.
Utilice el comando **eb terminate** para terminar el entorno y todos los recursos que contiene.
```
~/nodejs-example-express-rds$ eb terminate
The environment "nodejs-example-express-rds-env" and all associated instances will be terminated.
To confirm, type the environment name: nodejs-example-express-rds-env
INFO: terminateEnvironment is starting.
...
```
# Implementación de una aplicación Express Node Js. con clústeres en Elastic Beanstalk
[http://expressjs.com/](http://expressjs.com/) La agrupación en clústeres mejora la disponibilidad, el desempeño y la seguridad de su aplicación web. Para obtener más información sobre Amazon ElastiCache, consulta [¿Qué es Amazon ElastiCache (Memcached](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Introduction.html))? en la Guía del *usuario de Amazon ElastiCache (Memcached)*.
**nota**
En este ejemplo se crean AWS recursos, por los que es posible que se le cobre. Para obtener más información sobre AWS los precios, consulte[https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/). Algunos servicios forman parte de la capa de uso AWS gratuito. Si es un cliente nuevo, puede probar estos servicios de forma gratuita. Para obtener más información, consulte [https://aws.amazon.com/free/](https://aws.amazon.com/free/).
## Requisitos previos
Este tutorial tiene siguientes los requisitos previos:
+ Los tiempos de ejecución de Node.js
+ El software de administración de paquetes de Node.js predeterminado, npm
+ El generador de línea de comandos Express
+ La interfaz de línea de comando de Elastic Beanstalk (CLI de EB)
Para obtener más detalles acerca de la instalación de los primeros tres componentes y la configuración de su entorno de desarrollo local, consulte [Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk](nodejs-devenv.md). Para este tutorial, no necesitas instalar el AWS SDK para Node.js, que también se menciona en el tema al que se hace referencia.
Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte [Instalación de la CLI de EB con el script de configuración (recomendado)](eb-cli3.md#eb-cli3-install) y [Configuración de la CLI de EB](eb-cli3-configuration.md).
## Cree un entorno de Elastic Beanstalk
**Su directorio de aplicaciones**
Este tutorial usa un directorio llamado `nodejs-example-express-elasticache` para el paquete de origen de la aplicación. Cree el directorio `nodejs-example-express-elasticache` para este tutorial.
```
~$ mkdir nodejs-example-express-elasticache
```
**nota**
Cada tutorial de este capítulo usa su propio directorio para el paquete de origen de la aplicación. El nombre del directorio coincide con el nombre de la aplicación de muestra utilizada en el tutorial.
Cambie su directorio de trabajo actual a `nodejs-example-express-elasticache`.
```
~$ cd nodejs-example-express-elasticache
```
Ahora configuremos un entorno de Elastic Beanstalk que ejecute la plataforma Node.js y la aplicación de muestra. Se usará la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB)
**Para configurar un repositorio en la CLI de EB para la aplicación y crear un entorno de Elastic Beanstalk que ejecute la plataforma Node.js**
1. Cree un repositorio con el comando **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-express-elasticache$ eb init --platform node.js --region
```
Este comando crea un archivo de configuración en una carpeta llamada `.elasticbeanstalk` que especifica los ajustes para crear los entornos de la aplicación y crea una aplicación de Elastic Beanstalk con el nombre de la carpeta actual.
1. Cree un entorno que ejecute una aplicación de muestra con el comando **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-express-elasticache$ eb create --sample nodejs-example-express-elasticache
```
Este comando crea un entorno con equilibrador de carga utilizando la configuración predeterminada de la plataforma de Node.js y los siguientes recursos:
+ **EC2 instancia**: una máquina virtual de Amazon Elastic Compute Cloud (Amazon EC2) configurada para ejecutar aplicaciones web en la plataforma que elijas.
Cada plataforma ejecuta un conjunto específico de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco de trabajo y contenedor web (o una combinación de estos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que se sitúa delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.
+ **Grupo de seguridad de instancias**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP del balanceador de cargas llegue a la EC2 instancia que ejecuta tu aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Balanceador de carga**: equilibrador de carga de Elastic Load Balancing configurado para distribuir solicitudes a las instancias que se ejecutan en la aplicación. Los balanceadores de carga también permiten que las instancias no estén expuestas directamente a Internet.
+ **Grupo de seguridad del balanceador de carga**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente de Internet llegue al equilibrador de carga. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Grupo de escalado automático**: grupo de escalado automático configurado para reemplazar una instancia si termina o deja de estar disponible.
+ **Bucket de Amazon S3**: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.
+ ** CloudWatch Alarmas de Amazon**: dos CloudWatch alarmas que monitorean la carga de las instancias de su entorno y que se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de escalado automático aumenta o reduce los recursos.
+ **CloudFormation pila**: Elastic CloudFormation Beanstalk se utiliza para lanzar los recursos de su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nombre de dominio***: un nombre de dominio que se dirige a su aplicación web en el formulario. *subdomain* *region*.elasticbeanstalk.com*.
**Seguridad de dominios**
Para aumentar la seguridad de las aplicaciones de Elastic Beanstalk, el dominio *elasticbeanstalk.com* está registrado en la [lista de sufijos públicos (PSL)](https://publicsuffix.org/).
Para mayor seguridad, se recomienda que utilice cookies con un prefijo `__Host-` en caso de que necesite configurar cookies confidenciales en el nombre de dominio predeterminado de sus aplicaciones de Elastic Beanstalk. Esta práctica le ayuda a proteger su dominio de los intentos de falsificación de solicitudes entre sitios (CSRF). Para más información, consulte la página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) en la red de desarrolladores de Mozilla.
1. Cuando se complete la creación del entorno, utilice el comando [**eb open**](eb3-open.md) para abrir la URL del entorno en el navegador predeterminado.
```
~/nodejs-example-express-elasticache$ eb open
```
Ahora ha creado un entorno de Elastic Beanstalk para Node.js con una aplicación de muestra. Puede actualizarlo con su propia aplicación. Luego, actualizamos la aplicación de muestra para que use el marco de Express.
## Actualización de la aplicación para que use Express
Actualice la aplicación de muestra en el entorno de Elastic Beanstalk para que utilice el marco de Express.
[Puede descargar el código fuente final desde .zip. nodejs-example-express-elasticache](samples/nodejs-example-express-elasticache.zip)
**Si desea actualizar la aplicación para que use Express**
Una vez que haya creado el entorno con una aplicación de muestra, puede actualizarlo con su propia aplicación. En este procedimiento, ejecutamos primero los comandos **express** y **npm install** para configurar el marco de Express en el directorio de la aplicación.
1. Ejecute el comando `express`. Esto genera `package.json`, `app.js` y unos directorios.
```
~/nodejs-example-express-elasticache$ express
```
Cuando se le pregunte, escriba **y** si desea continuar.
**nota**
Si el comando **express** no funciona, es posible que no haya instalado el generador de línea de comandos Express tal y como se describe en la sección *Requisitos previos* anterior. O bien, puede que sea necesario configurar la ruta del directorio de su máquina local para ejecutar el comando **express**. Consulte la sección *Requisitos previos* para conocer los pasos detallados sobre la configuración del entorno de desarrollo, de modo que pueda continuar con este tutorial.
1. Configure las dependencias locales.
```
~/nodejs-example-express-elasticache$ npm install
```
1. (Opcional) Compruebe que el servidor de aplicaciones web se inicie.
```
~/nodejs-example-express-elasticache$ npm start
```
Debería ver una salida similar a esta:
```
> nodejs@0.0.0 start /home/local/user/node-express
> node ./bin/www
```
El servidor se ejecuta en el puerto 3000 de forma predeterminada. Para probarlo, ejecute `curl http://localhost:3000` en otro terminal o abra un navegador en el equipo local e ingrese el `http://localhost:3000` de la dirección URL.
Presione **Ctrl\$1C** para detener el servidor.
1. Cambie el nombre de `nodejs-example-express-elasticache/app.js` a `nodejs-example-express-elasticache/express-app.js`.
```
~/nodejs-example-express-elasticache$ mv app.js express-app.js
```
1. Actualice la línea `var app = express();` en `nodejs-example-express-elasticache/express-app.js` a la siguiente:
```
var app = module.exports = express();
```
1. En el equipo local, cree un archivo llamado `nodejs-example-express-elasticache/app.js` con el siguiente código.
```
/**
* Module dependencies.
*/
const express = require('express'),
session = require('express-session'),
bodyParser = require('body-parser'),
methodOverride = require('method-override'),
cookieParser = require('cookie-parser'),
fs = require('fs'),
filename = '/var/nodelist',
app = express();
let MemcachedStore = require('connect-memcached')(session);
function setup(cacheNodes) {
app.use(bodyParser.raw());
app.use(methodOverride());
if (cacheNodes.length > 0) {
app.use(cookieParser());
console.log('Using memcached store nodes:');
console.log(cacheNodes);
app.use(session({
secret: 'your secret here',
resave: false,
saveUninitialized: false,
store: new MemcachedStore({ 'hosts': cacheNodes })
}));
} else {
console.log('Not using memcached store.');
app.use(session({
resave: false,
saveUninitialized: false, secret: 'your secret here'
}));
}
app.get('/', function (req, resp) {
if (req.session.views) {
req.session.views++
resp.setHeader('Content-Type', 'text/html')
resp.send(`You are session: ${req.session.id}. Views: ${req.session.views}`)
} else {
req.session.views = 1
resp.send(`You are session: ${req.session.id}. No views yet, refresh the page!`)
}
});
if (!module.parent) {
console.log('Running express without cluster. Listening on port %d', process.env.PORT || 5000)
app.listen(process.env.PORT || 5000)
}
}
console.log("Reading elastic cache configuration")
// Load elasticache configuration.
fs.readFile(filename, 'UTF8', function (err, data) {
if (err) throw err;
let cacheNodes = []
if (data) {
let lines = data.split('\n');
for (let i = 0; i < lines.length; i++) {
if (lines[i].length > 0) {
cacheNodes.push(lines[i])
}
}
}
setup(cacheNodes)
});
module.exports = app;
```
1. Reemplace el contenido del archivo `nodejs-example-express-elasticache/bin/www` por lo siguiente:
```
#!/usr/bin/env node
/**
* Module dependencies.
*/
const app = require('../app');
const cluster = require('cluster');
const debug = require('debug')('nodejs-example-express-elasticache:server');
const http = require('http');
const workers = {},
count = require('os').cpus().length;
function spawn() {
const worker = cluster.fork();
workers[worker.pid] = worker;
return worker;
}
/**
* Get port from environment and store in Express.
*/
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
if (cluster.isMaster) {
for (let i = 0; i < count; i++) {
spawn();
}
// If a worker dies, log it to the console and start another worker.
cluster.on('exit', function (worker, code, signal) {
console.log('Worker ' + worker.process.pid + ' died.');
cluster.fork();
});
// Log when a worker starts listening
cluster.on('listening', function (worker, address) {
console.log('Worker started with PID ' + worker.process.pid + '.');
});
} else {
/**
* Create HTTP server.
*/
let server = http.createServer(app);
/**
* Event listener for HTTP server "error" event.
*/
function onError(error) {
if (error.syscall !== 'listen') {
throw error;
}
const bind = typeof port === 'string'
? 'Pipe ' + port
: 'Port ' + port;
// handle specific listen errors with friendly messages
switch (error.code) {
case 'EACCES':
console.error(bind + ' requires elevated privileges');
process.exit(1);
break;
case 'EADDRINUSE':
console.error(bind + ' is already in use');
process.exit(1);
break;
default:
throw error;
}
}
/**
* Event listener for HTTP server "listening" event.
*/
function onListening() {
const addr = server.address();
const bind = typeof addr === 'string'
? 'pipe ' + addr
: 'port ' + addr.port;
debug('Listening on ' + bind);
}
/**
* Listen on provided port, on all network interfaces.
*/
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
}
/**
* Normalize a port into a number, string, or false.
*/
function normalizePort(val) {
const port = parseInt(val, 10);
if (isNaN(port)) {
// named pipe
return val;
}
if (port >= 0) {
// port number
return port;
}
return false;
}
```
1. Implemente los cambios en su entorno Elastic Beanstalk con el comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Su entorno se actualizará al cabo de unos minutos. Una vez que el entorno esté listo, actualice la dirección URL para verificar que ha funcionado. Debería aparecer una página web que diga “Welcome to Express”.
Puede acceder a los registros de las EC2 instancias que ejecutan la aplicación. Para obtener instrucciones acerca del acceso a los logs, consulte [Visualización de registros de instancias de Amazon EC2 en su entorno de Elastic Beanstalk](using-features.logging.md).
A continuación, vamos a actualizar la aplicación Express para usar Amazon ElastiCache.
**Para actualizar tu aplicación Express para usar Amazon ElastiCache**
1. En su equipo local, cree un directorio `.ebextensions` en el directorio de nivel superior del paquete de código fuente. En este ejemplo, usaremos `nodejs-example-express-elasticache/.ebextensions`.
1. Cree un archivo de configuración `nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config` con el siguiente fragmento. Para obtener más información sobre el archivo de configuración, consulta [Espacio de nombres de configuración de Node.js](create_deploy_nodejs.container.md#nodejs-namespaces). Se crea un usuario de IAM con los permisos necesarios para descubrir los nodos de elasticache y se escribe en un archivo siempre que cambia la caché. También puedes copiar el archivo desde un [nodejs-example-express-elasticachearchivo.zip.](samples/nodejs-example-express-elasticache.zip) Para obtener más información sobre las ElastiCache propiedades, consulte[Ejemplo: ElastiCache](customize-environment-resources-elasticache.md).
**nota**
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.
```
Resources:
MyCacheSecurityGroup:
Type: 'AWS::EC2::SecurityGroup'
Properties:
GroupDescription: "Lock cache down to webserver access only"
SecurityGroupIngress:
- IpProtocol: tcp
FromPort:
Fn::GetOptionSetting:
OptionName: CachePort
DefaultValue: 11211
ToPort:
Fn::GetOptionSetting:
OptionName: CachePort
DefaultValue: 11211
SourceSecurityGroupName:
Ref: AWSEBSecurityGroup
MyElastiCache:
Type: 'AWS::ElastiCache::CacheCluster'
Properties:
CacheNodeType:
Fn::GetOptionSetting:
OptionName: CacheNodeType
DefaultValue: cache.t2.micro
NumCacheNodes:
Fn::GetOptionSetting:
OptionName: NumCacheNodes
DefaultValue: 1
Engine:
Fn::GetOptionSetting:
OptionName: Engine
DefaultValue: redis
VpcSecurityGroupIds:
-
Fn::GetAtt:
- MyCacheSecurityGroup
- GroupId
AWSEBAutoScalingGroup :
Metadata :
ElastiCacheConfig :
CacheName :
Ref : MyElastiCache
CacheSize :
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
WebServerUser :
Type : AWS::IAM::User
Properties :
Path : "/"
Policies:
-
PolicyName: root
PolicyDocument :
Statement :
-
Effect : Allow
Action :
- cloudformation:DescribeStackResource
- cloudformation:ListStackResources
- elasticache:DescribeCacheClusters
Resource : "*"
WebServerKeys :
Type : AWS::IAM::AccessKey
Properties :
UserName :
Ref: WebServerUser
Outputs:
WebsiteURL:
Description: sample output only here to show inline string function parsing
Value: |
http://`{ "Fn::GetAtt" : [ "AWSEBLoadBalancer", "DNSName" ] }`
MyElastiCacheName:
Description: Name of the elasticache
Value:
Ref : MyElastiCache
NumCacheNodes:
Description: Number of cache nodes in MyElastiCache
Value:
Fn::GetOptionSetting:
OptionName : NumCacheNodes
DefaultValue: 1
files:
"/etc/cfn/cfn-credentials" :
content : |
AWSAccessKeyId=`{ "Ref" : "WebServerKeys" }`
AWSSecretKey=`{ "Fn::GetAtt" : ["WebServerKeys", "SecretAccessKey"] }`
mode : "000400"
owner : root
group : root
"/etc/cfn/get-cache-nodes" :
content : |
# Define environment variables for command line tools
export AWS_ELASTICACHE_HOME="/home/ec2-user/elasticache/$(ls /home/ec2-user/elasticache/)"
export AWS_CLOUDFORMATION_HOME=/opt/aws/apitools/cfn
export PATH=$AWS_CLOUDFORMATION_HOME/bin:$AWS_ELASTICACHE_HOME/bin:$PATH
export AWS_CREDENTIAL_FILE=/etc/cfn/cfn-credentials
export JAVA_HOME=/usr/lib/jvm/jre
# Grab the Cache node names and configure the PHP page
aws cloudformation list-stack-resources --stack `{ "Ref" : "AWS::StackName" }` --region `{ "Ref" : "AWS::Region" }` --output text | grep MyElastiCache | awk '{print $4}' | xargs -I {} aws elasticache describe-cache-clusters --cache-cluster-id {} --region `{ "Ref" : "AWS::Region" }` --show-cache-node-info --output text | grep '^ENDPOINT' | awk '{print $2 ":" $3}' > `{ "Fn::GetOptionSetting" : { "OptionName" : "NodeListPath", "DefaultValue" : "/var/www/html/nodelist" } }`
mode : "000500"
owner : root
group : root
"/etc/cfn/hooks.d/cfn-cache-change.conf" :
"content": |
[cfn-cache-size-change]
triggers=post.update
path=Resources.AWSEBAutoScalingGroup.Metadata.ElastiCacheConfig
action=/etc/cfn/get-cache-nodes
runas=root
sources :
"/home/ec2-user/elasticache" : "https://elasticache-downloads.s3.amazonaws.com/AmazonElastiCacheCli-latest.zip"
commands:
make-elasticache-executable:
command: chmod -R ugo+x /home/ec2-user/elasticache/*/bin/*
packages :
"yum" :
"aws-apitools-cfn" : []
container_commands:
initial_cache_nodes:
command: /etc/cfn/get-cache-nodes
```
1. En su equipo local, cree un archivo de configuración `nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config` con el siguiente fragmento de código para configurarlo. ElastiCache
```
option_settings:
"aws:elasticbeanstalk:customoption":
CacheNodeType: cache.t2.micro
NumCacheNodes: 1
Engine: memcached
NodeListPath: /var/nodelist
```
1. En el equipo local,sustituya `nodejs-example-express-elasticache/express-app.js` con el siguiente fragmento. Este archivo lee la lista de nodos del disco (`/var/nodelist`) y configura Express para que utilice `memcached` como un almacén de sesiones si los nodos están presentes. Su archivo debería tener el siguiente aspecto.
```
/**
* Module dependencies.
*/
var express = require('express'),
session = require('express-session'),
bodyParser = require('body-parser'),
methodOverride = require('method-override'),
cookieParser = require('cookie-parser'),
fs = require('fs'),
filename = '/var/nodelist',
app = module.exports = express();
var MemcachedStore = require('connect-memcached')(session);
function setup(cacheNodes) {
app.use(bodyParser.raw());
app.use(methodOverride());
if (cacheNodes) {
app.use(cookieParser());
console.log('Using memcached store nodes:');
console.log(cacheNodes);
app.use(session({
secret: 'your secret here',
resave: false,
saveUninitialized: false,
store: new MemcachedStore({'hosts': cacheNodes})
}));
} else {
console.log('Not using memcached store.');
app.use(cookieParser('your secret here'));
app.use(session());
}
app.get('/', function(req, resp){
if (req.session.views) {
req.session.views++
resp.setHeader('Content-Type', 'text/html')
resp.write('Views: ' + req.session.views)
resp.end()
} else {
req.session.views = 1
resp.end('Refresh the page!')
}
});
if (!module.parent) {
console.log('Running express without cluster.');
app.listen(process.env.PORT || 5000);
}
}
// Load elasticache configuration.
fs.readFile(filename, 'UTF8', function(err, data) {
if (err) throw err;
var cacheNodes = [];
if (data) {
var lines = data.split('\n');
for (var i = 0 ; i < lines.length ; i++) {
if (lines[i].length > 0) {
cacheNodes.push(lines[i]);
}
}
}
setup(cacheNodes);
});
```
1. En el equipo local, actualice `package.json` con el siguiente contenido:
```
"dependencies": {
"cookie-parser": "~1.4.4",
"debug": "~2.6.9",
"express": "~4.16.1",
"http-errors": "~1.6.3",
"jade": "~1.11.0",
"morgan": "~1.9.1",
"connect-memcached": "*",
"express-session": "*",
"body-parser": "*",
"method-override": "*"
}
```
1. Ejecute **npm install**.
```
~/nodejs-example-express-elasticache$ npm install
```
1. Implemente la aplicación actualizada.
```
~/nodejs-example-express-elasticache$ eb deploy
```
1. Su entorno se actualizará al cabo de unos minutos. Una vez que su entorno esté listo, verifique que el código ha funcionado.
1. Consulta la [ CloudWatch consola de Amazon](https://console.aws.amazon.com/cloudwatch/home) para ver tus ElastiCache estadísticas. Para ver tus ElastiCache métricas, selecciona **Métricas** en el panel izquierdo y, a continuación, busca **CurrItems**. Seleccione **ElastiCache > Métricas del nodo de caché** y, a continuación, seleccione su nodo de caché para ver el número de elementos de la caché.
![\[CloudWatch dashboard showing CurrItems metric for an ElastiCache node over time.\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/elasticache-express.png)
**nota**
Asegúrese de buscar en la misma región en la que ha implementado su aplicación.
Si copias y pegas la URL de tu aplicación en otro navegador web y actualizas la página, el CurrItem recuento debería aumentar al cabo de 5 minutos.
1. Tome una instantánea de los registros.. Para obtener más información acerca de la recuperación de registros, consulte [Visualización de registros de instancias de Amazon EC2 en su entorno de Elastic Beanstalk](using-features.logging.md).
1. Compruebe el archivo `/var/log/nodejs/nodejs.log` en el paquete del registro. Debería ver algo similar a lo siguiente:
```
Using memcached store nodes:
[ 'aws-my-1oys9co8zt1uo.1iwtrn.0001.use1.cache.amazonaws.com:11211' ]
```
## Limpieza
Si ya no desea ejecutar la aplicación, puede limpiar los recursos terminando el entorno y eliminando la aplicación.
Utilice el comando `eb terminate` para finalizar el entorno y el comando `eb delete` para eliminar la aplicación.
**Para terminar su entorno**
En el directorio en el que creó el repositorio local, ejecute `eb terminate`.
```
$ eb terminate
```
Este proceso puede tardar unos minutos. Elastic Beanstalk muestra un mensaje cuando el entorno termina correctamente.
# Implementación de una aplicación Node.js con DynamoDB en Elastic Beanstalk
Este tutorial y su aplicación de ejemplo, [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip), explican el proceso de implementación de una aplicación de Node.js que utiliza el AWS SDK de Node.js para JavaScript interactuar con el servicio Amazon DynamoDB. Creará una tabla de DynamoDB que esté en una base de datos desacoplada o externa del entorno. AWS Elastic Beanstalk También configurará la aplicación para que utilice una base de datos desacoplada. En un entorno de producción, se recomienda utilizar una base de datos que esté desacoplada del entorno de Elastic Beanstalk para que sea independiente del ciclo de vida del entorno. Esta práctica también permite realizar [implementaciones azul/verde](using-features.CNAMESwap.md).
La aplicación de muestra ilustra lo siguiente:
+ Una tabla de DynamoDB que almacena los datos de texto proporcionados por el usuario.
+ Los [archivos de configuración](ebextensions.md) para crear la tabla.
+ Un tema de Amazon Simple Notification Service.
+ Uso de un [archivo package.json](nodejs-platform-dependencies.md#nodejs-platform-packagejson) para instalar paquetes durante la implementación.
**Topics**
+ [Requisitos previos](#nodejs-dynamodb-tutorial-prereqs)
+ [Cree un entorno de Elastic Beanstalk](#nodejs-dynamodb-tutorial-launch)
+ [Añadir permisos a las instancias del entorno](#nodejs-dynamodb-tutorial-role)
+ [Implementar la aplicación de muestra](#nodejs-dynamodb-tutorial-deploy)
+ [Creación de una tabla de DynamoDB](#nodejs-dynamodb-tutorial-database)
+ [Actualización de los archivos de configuración de la aplicación](#nodejs-dynamodb-tutorial-update)
+ [Configuración de su entorno para alta disponibilidad](#nodejs-dynamodb-tutorial-configure)
+ [Limpieza](#nodejs-dynamodb-tutorial-cleanup)
+ [Siguientes pasos](#nodejs-dynamodb-tutorial-nextsteps)
## Requisitos previos
Este tutorial tiene siguientes los requisitos previos:
+ Los tiempos de ejecución de Node.js
+ El software de administración de paquetes de Node.js predeterminado, npm
+ El generador de línea de comandos Express
+ La interfaz de línea de comando de Elastic Beanstalk (CLI de EB)
Para obtener más detalles acerca de la instalación de los primeros tres componentes y la configuración de su entorno de desarrollo local, consulte [Configuración del entorno de desarrollo de Node.js para Elastic Beanstalk](nodejs-devenv.md). Para este tutorial, no necesita instalar el AWS SDK para Node.js, que también se menciona en el tema al que se hace referencia.
Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte [Instalación de la CLI de EB con el script de configuración (recomendado)](eb-cli3.md#eb-cli3-install) y [Configuración de la CLI de EB](eb-cli3-configuration.md).
## Cree un entorno de Elastic Beanstalk
**Su directorio de aplicaciones**
Este tutorial usa un directorio llamado `nodejs-example-dynamo` para el paquete de origen de la aplicación. Cree el directorio `nodejs-example-dynamo` para este tutorial.
```
~$ mkdir nodejs-example-dynamo
```
**nota**
Cada tutorial de este capítulo usa su propio directorio para el paquete de origen de la aplicación. El nombre del directorio coincide con el nombre de la aplicación de muestra utilizada en el tutorial.
Cambie su directorio de trabajo actual a `nodejs-example-dynamo`.
```
~$ cd nodejs-example-dynamo
```
Ahora configuremos un entorno de Elastic Beanstalk que ejecute la plataforma Node.js y la aplicación de muestra. Se usará la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB)
**Para configurar un repositorio en la CLI de EB para la aplicación y crear un entorno de Elastic Beanstalk que ejecute la plataforma Node.js**
1. Cree un repositorio con el comando **[**eb init**](eb3-init.md)**.
```
~/nodejs-example-dynamo$ eb init --platform node.js --region
```
Este comando crea un archivo de configuración en una carpeta llamada `.elasticbeanstalk` que especifica los ajustes para crear los entornos de la aplicación y crea una aplicación de Elastic Beanstalk con el nombre de la carpeta actual.
1. Cree un entorno que ejecute una aplicación de muestra con el comando **[**eb create**](eb3-create.md)**.
```
~/nodejs-example-dynamo$ eb create --sample nodejs-example-dynamo
```
Este comando crea un entorno con equilibrador de carga utilizando la configuración predeterminada de la plataforma de Node.js y los siguientes recursos:
+ **EC2 instancia**: una máquina virtual de Amazon Elastic Compute Cloud (Amazon EC2) configurada para ejecutar aplicaciones web en la plataforma que elijas.
Cada plataforma ejecuta un conjunto específico de software, archivos de configuración y scripts compatibles con una determinada versión de lenguaje, marco de trabajo y contenedor web (o una combinación de estos). La mayoría de las plataformas utilizan Apache o nginx como un proxy inverso que se sitúa delante de la aplicación web, reenvía las solicitudes a esta, administra los recursos estáticos y genera registros de acceso y errores.
+ **Grupo de seguridad de instancias**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP del balanceador de cargas llegue a la EC2 instancia que ejecuta tu aplicación web. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Balanceador de carga**: equilibrador de carga de Elastic Load Balancing configurado para distribuir solicitudes a las instancias que se ejecutan en la aplicación. Los balanceadores de carga también permiten que las instancias no estén expuestas directamente a Internet.
+ **Grupo de seguridad del balanceador de carga**: un grupo EC2 de seguridad de Amazon configurado para permitir el tráfico entrante en el puerto 80. Este recurso permite que el tráfico HTTP procedente de Internet llegue al equilibrador de carga. De forma predeterminada, el tráfico no está permitido en otros puertos.
+ **Grupo de escalado automático**: grupo de escalado automático configurado para reemplazar una instancia si termina o deja de estar disponible.
+ **Bucket de Amazon S3**: ubicación de almacenamiento para el código fuente, los registros y otros artefactos que se crean al utilizar Elastic Beanstalk.
+ ** CloudWatch Alarmas de Amazon**: dos CloudWatch alarmas que monitorean la carga de las instancias de su entorno y que se activan si la carga es demasiado alta o demasiado baja. Cuando se activa una alarma, en respuesta, el grupo de escalado automático aumenta o reduce los recursos.
+ **CloudFormation pila**: Elastic CloudFormation Beanstalk se utiliza para lanzar los recursos de su entorno y propagar los cambios de configuración. Los recursos se definen en una plantilla que puede verse en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nombre de dominio***: un nombre de dominio que se dirige a su aplicación web en el formulario. *subdomain* *region*.elasticbeanstalk.com*.
**Seguridad de dominios**
Para aumentar la seguridad de las aplicaciones de Elastic Beanstalk, el dominio *elasticbeanstalk.com* está registrado en la [lista de sufijos públicos (PSL)](https://publicsuffix.org/).
Para mayor seguridad, se recomienda que utilice cookies con un prefijo `__Host-` en caso de que necesite configurar cookies confidenciales en el nombre de dominio predeterminado de sus aplicaciones de Elastic Beanstalk. Esta práctica le ayuda a proteger su dominio de los intentos de falsificación de solicitudes entre sitios (CSRF). Para más información, consulte la página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) en la red de desarrolladores de Mozilla.
1. Cuando se complete la creación del entorno, utilice el comando [**eb open**](eb3-open.md) para abrir la URL del entorno en el navegador predeterminado.
```
~/nodejs-example-dynamo$ eb open
```
Ahora ha creado un entorno de Elastic Beanstalk para Node.js con una aplicación de muestra. Puede actualizarlo con su propia aplicación. Luego, actualizamos la aplicación de muestra para que use el marco de Express.
## Añadir permisos a las instancias del entorno
La aplicación se ejecuta en una o más EC2 instancias detrás de un balanceador de carga y atiende las solicitudes HTTP de Internet. Cuando recibe una solicitud que requiere el uso de AWS servicios, la aplicación utiliza los permisos de la instancia en la que se ejecuta para acceder a esos servicios.
La aplicación de ejemplo usa permisos de instancia para escribir datos en una tabla de DynamoDB y enviar notificaciones a un tema de Amazon SNS con el SDK de Node.js. JavaScript Añada las siguientes políticas administradas al [perfil de instancia](concepts-roles-instance.md) predeterminado para conceder a las EC2 instancias de su entorno permiso de acceso a DynamoDB y Amazon SNS:
+ **AmazonDynamoDBFullAcceso**
+ **Amazon SNSFull Access**
**Para agregar políticas al perfil de instancia predeterminado**
1. Abra la [página Roles](https://console.aws.amazon.com/iam/home#roles) en la consola de IAM.
1. Elige **aws-elasticbeanstalk-ec2 funciones**.
1. En la pestaña **Permissions (Permisos)**, elija **Attach policies (Adjuntar políticas)**.
1. Seleccione la política administrada que se aplicará a los demás servicios que utilice la aplicación. Para este tutorial, seleccione `AmazonSNSFullAccess` y `AmazonDynamoDBFullAccess`.
1. Elija **Asociar política**.
Para obtener más información acerca de cómo administrar perfiles de instancia, consulte [Administración de perfiles de instancia de Elastic Beanstalk](iam-instanceprofile.md).
## Implementar la aplicación de muestra
Ahora su entorno está listo para implementar y ejecutar la aplicación de ejemplo de este tutorial: [nodejs-example-dynamo.zip.](samples/nodejs-example-dynamo.zip)
**Para implementar y ejecutar la aplicación de muestra del tutorial**
1. Cambie el directorio de trabajo actual a `nodejs-example-dynamo` de directorio de la aplicación.
```
~$ cd nodejs-example-dynamo
```
1. Descargue y extraiga el contenido del paquete de código fuente de la aplicación de ejemplo ([nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip)) en el directorio de la aplicación. `nodejs-example-dynamo`
1. Implemente la aplicación de muestra en su entorno Elastic Beanstalk con el comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-dynamo$ eb deploy
```
**nota**
De forma predeterminada, el comando `eb deploy` crea un archivo ZIP de la carpeta del proyecto. Puede configurar la CLI de EB para implementar un artefacto de su proceso de compilación en lugar de crear un archivo ZIP de la carpeta del proyecto. Para obtener más información, consulte [Implementar un artefacto en lugar de la carpeta del proyecto](eb-cli3-configuration.md#eb-cli3-artifact).
1. Cuando se complete la creación del entorno, utilice el comando [**eb open**](eb3-open.md) para abrir la URL del entorno en el navegador predeterminado.
```
~/nodejs-example-dynamo$ eb open
```
El sitio recopila la información de contacto del usuario y utiliza una tabla de DynamoDB para almacenar los datos. Para agregar una entrada, elija **Sign up today (Regístrese hoy mismo)**, introduzca un nombre y dirección de correo electrónico y, a continuación, elija **Sign Up\$1 (Regístrese)** La aplicación web escribe el contenido del formulario en la tabla y activa una notificación por correo electrónico de Amazon SNS.
![\[Startup landing page with teaser message and sign-up button for upcoming product launch.\]](http://docs.aws.amazon.com/es_es/elasticbeanstalk/latest/dg/images/nodejs-dynamodb-tutorial-app.png)
De momento, el tema de Amazon SNS está configurado con un marcador de posición para el correo electrónico de las notificaciones. Actualización deá la configuración en breve, pero entretanto puede verificar la tabla de DynamoDB y el tema de Amazon SNS en la Consola de administración de AWS.
**Para ver la tabla**
1. Abra la [página Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) en la consola de DynamoDB.
1. Busque la tabla que creó la aplicación. El nombre comienza por **awseb y contiene**. **StartupSignupsTable**
1. Seleccione la tabla, elija **Items (Elementos)** y, a continuación, elija **Start search (Iniciar búsqueda)** para ver todos los elementos de la tabla.
La tabla contiene una entrada para cada dirección de correo electrónico enviada en el sitio de inscripción. Además de escribir en la tabla, la aplicación envía un mensaje a un tema de Amazon SNS que tiene dos suscripciones: una para las notificaciones por correo electrónico que se le envían a usted y otra para una cola de Amazon Simple Queue Service que una aplicación de trabajo puede leer para procesar las solicitudes y enviar mensajes de correo electrónico a los clientes interesados.
**Para ver el tema**
1. Abra la página [Topics (Temas)](https://console.aws.amazon.com/sns/v2/home?#/topics) en la consola de Amazon SNS.
1. Busque el tema que creó la aplicación. El nombre comienza por **awseb** y contiene. **NewSignupTopic**
1. Seleccione el tema para ver sus suscripciones.
La aplicación (`[app.js](https://github.com/awslabs/eb-node-express-sample/blob/master/app.js)`) define dos rutas. La ruta raíz (`/`) devuelve una página web renderizada a partir de una plantilla integrada JavaScript (EJS) con un formulario que el usuario rellena para registrar su nombre y dirección de correo electrónico. Al enviar el formulario se envía una solicitud POST con los datos del formulario a la ruta `/signup`, que escribe una entrada en la tabla de DynamoDB y publica un mensaje en el tema de Amazon SNS para enviar una notificación al propietario de la inscripción.
La aplicación de muestra incluye [archivos de configuración](ebextensions.md) que crean la tabla de DynamoDB, el tema de Amazon SNS y la cola de Amazon SQS usados por la aplicación. Esto le permite crear un nuevo entorno y probar la funcionalidad de forma inmediata, pero tiene el inconveniente de que la tabla de DynamoDB está asociada al entorno. Para un entorno de producción, debería crear la tabla de DynamoDB fuera de su entorno para evitar perderla cuando termine el entorno o actualice su configuración.
## Creación de una tabla de DynamoDB
Para utilizar una tabla de DynamoDB externa con una aplicación que se ejecuta en Elastic Beanstalk, primero cree una tabla en DynamoDB. Cuando crea una tabla fuera de Elastic Beanstalk, es completamente independiente de Elastic Beanstalk y de sus entornos de Elastic Beanstalk, y Elastic Beanstalk no la finalizará.
Cree una tabla con la siguiente configuración:
+ **Table name (Nombre de la tabla)** – **nodejs-tutorial**
+ **Primary key (Clave principal)** – **email**
+ Tipo de clave principal: **String (Cadena)**
**Para crear una tabla de DynamoDB**
1. Abra la [página Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) en la consola de administración de DynamoDB.
1. Seleccione **Create table (Creación de tabla)**.
1. Escriba un **Table name (Nombre de tabla)** y una **Primary key (Clave principal)**.
1. Elija el tipo de clave principal.
1. Seleccione **Creación de**.
## Actualización de los archivos de configuración de la aplicación
Actualice los [archivos de configuración](ebextensions.md) del origen de la aplicación para que utilicen la tabla **nodejs-tutorial** en lugar de crear una nueva.
**Para actualizar la aplicación de muestra para su uso en producción**
1. Cambie el directorio de trabajo actual a `nodejs-example-dynamo` de directorio de la aplicación.
```
~$ cd nodejs-example-dynamo
```
1. Abra `.ebextensions/options.config` y cambie los valores de las siguientes opciones:
+ **NewSignupEmail**— Su dirección de correo electrónico.
+ **STARTUP\$1SIGNUP\$1TABLE**: **nodejs-tutorial**
**Example .ebextensions/options.config**
```
option_settings:
aws:elasticbeanstalk:customoption:
NewSignupEmail: you@example.com
aws:elasticbeanstalk:application:environment:
THEME: "flatly"
AWS_REGION: '`{"Ref" : "AWS::Region"}`'
STARTUP_SIGNUP_TABLE: nodejs-tutorial
NEW_SIGNUP_TOPIC: '`{"Ref" : "NewSignupTopic"}`'
aws:elasticbeanstalk:container:nodejs:
ProxyServer: nginx
aws:elasticbeanstalk:container:nodejs:staticfiles:
/static: /static
aws:autoscaling:asg:
Cooldown: "120"
aws:autoscaling:trigger:
Unit: "Percent"
Period: "1"
BreachDuration: "2"
UpperThreshold: "75"
LowerThreshold: "30"
MeasureName: "CPUUtilization"
```
Esto se aplica a las siguientes configuraciones para la aplicación:
+ La dirección de correo electrónico que el tema de Amazon SNS utiliza para las notificaciones está configurado en su dirección o en la que introduzca en el archivo `options.config`.
+ Se utilizará la tabla **nodejs-tutorial** en lugar de la creada por `.ebextensions/create-dynamodb-table.config`.
1. Remove `.ebextensions/create-dynamodb-table.config`.
```
~/nodejs-tutorial$ rm .ebextensions/create-dynamodb-table.config
```
La próxima vez que implemente la aplicación, se eliminará la tabla creada por este archivo de configuración.
1. Implemente la aplicación actualizada en su entorno Elastic Beanstalk con el comando [**eb deploy**](eb3-deploy.md).
```
~/nodejs-example-dynamo$ eb deploy
```
1. Cuando se complete la creación del entorno, utilice el comando [**eb open**](eb3-open.md) para abrir la URL del entorno en el navegador predeterminado.
```
~/nodejs-example-dynamo$ eb open
```
Cuando lo implemente, Elastic Beanstalk actualizará la configuración del tema de Amazon SNS y eliminará la tabla de DynamoDB que se creó cuando implementó la primera versión de la aplicación.
Ahora, cuando termine el entorno, no se eliminará la tabla **nodejs-tutorial**. Esto le permite realizar implementaciones blue/green, modificar los archivos de configuración o retirar su sitio web sin arriesgarse a perder datos.
Abra su sitio en un navegador y verifique que el formulario funciona según lo previsto. Cree un par de entradas y, a continuación, consulte la consola de DynamoDB para verificar la tabla.
**Para ver la tabla**
1. Abra la [página Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) en la consola de DynamoDB.
1. Busque la tabla **nodejs-tutorial**.
1. Seleccione la tabla, elija **Items (Elementos)** y, a continuación, elija **Start search (Iniciar búsqueda)** para ver todos los elementos de la tabla.
También puede ver que Elastic Beanstalk eliminó la tabla que creó anteriormente.
## Configuración de su entorno para alta disponibilidad
Por último, configure el grupo de escalado automático de su entorno con un número mínimo de instancias mayor. Ejecute al menos dos instancias en todo momento para evitar que los servidores web de su entorno se conviertan en un único punto de error y para poder implementar cambios sin que el sitio se quede fuera de servicio.
**Si desea configurar el grupo de escalado automático del entorno para disponer de una alta disponibilidad**
1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS
1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.
1. En el panel de navegación, elija **Configuration (Configuración)**.
1. En la categoría de configuración **Capacity (Capacidad)**, elija **Edit (Edición de)**.
1. En la sección **escalado automático group (grupo de escalado automático)** defina **Min instances (Instancias mínimas)** en **2**.
1. Para guardar los cambios, elija **Aplicar** en la parte inferior de la página.
## Limpieza
Cuando finalice su trabajo con el código de demostración, puede terminar el entorno. [Elastic Beanstalk elimina todos los recursos AWS relacionados, [como las instancias de EC2 Amazon](using-features.managing.ec2.md), las [instancias de bases de datos, los balanceadores de carga,](using-features.managing.db.md)[los grupos de seguridad y las](using-features.managing.elb.md) alarmas.](using-features.alarms.md#using-features.alarms.title)
Al eliminar recursos no se elimina la aplicación de Elastic Beanstalk, por lo que puede crear nuevos entornos para su aplicación en cualquier momento.
**Cómo terminar su entorno de Elastic Beanstalk desde la consola**
1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS
1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.
1. Elija **Actions** (Acciones) y, a continuación, **Terminate Environment** (Terminar el entorno).
1. Utilice el cuadro de diálogo en pantalla para confirmar la terminación del entorno.
También puede eliminar las tablas de DynamoDB externas que haya creado.
**Para eliminar una tabla de DynamoDB**
1. Abra la [página Tables](https://console.aws.amazon.com/dynamodb/home?#tables:) en la consola de DynamoDB.
1. Seleccione una tabla.
1. Seleccione **Actions (Acciones)** y **Delete table (Eliminar tabla)**.
1. Elija **Eliminar**.
## Siguientes pasos
La aplicación de ejemplo utiliza archivos de configuración para configurar los ajustes del software y crear AWS recursos como parte de su entorno. Para obtener más información sobre los archivos de configuración y cómo se utilizan, consulte [Personalización avanzada de entornos con archivos de configuración (`.ebextensions`)](ebextensions.md).
La aplicación de muestra de este tutorial utiliza la plataforma web Express para Node.js. Para obtener más información sobre Express, consulte la documentación oficial en [expressjs.com](https://expressjs.com).
Por último, si pretende utilizar la aplicación en un entorno de producción, [configure un nombre de dominio personalizado](customdomains.md) para el entorno y [habilite HTTPS](configuring-https.md) para las conexiones seguras.
# Adición de una instancia de base de datos de Amazon RDS a su entorno de Node.js Elastic Beanstalk
En este tema se proporcionan instrucciones para crear un Amazon RDS mediante la consola de Elastic Beanstalk. Puede utilizar una instancia de base de datos de Amazon Relational Database Service (Amazon RDS) para almacenar datos recopilados y modificados por su aplicación. La base de datos se puede adjuntar al entorno y administrarse con Elastic Beanstalk, o bien, crearse como desacoplada y administrarse de forma externa a través de otro servicio. En estas instrucciones, la base de datos se acoplará al entorno y se administrará con Elastic Beanstalk. Para obtener más información sobre el uso de Elastic Beanstalk con Amazon RDS, consulte [Añadir una base de datos al entorno de Elastic Beanstalk](using-features.managing.db.md).
**Topics**
+ [Añadir una instancia de base de datos al entorno](#nodejs-rds-create)
+ [Descargar un controlador](#nodejs-rds-drivers)
+ [Conexión a una base de datos](#nodejs-rds-connect)
## Añadir una instancia de base de datos al entorno
**Para agregar una instancia de base de datos al entorno**
1. Abra la consola de [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) y, **en** la lista Regiones, seleccione su. Región de AWS
1. En el panel de navegación, elija **Environments** (Entornos) y, a continuación, elija el nombre del entorno en la lista.
1. En el panel de navegación, elija **Configuration (Configuración)**.
1. En la categoría de configuración **Database (Base de datos)**, seleccione **Edit (Edición de)**.
1. Seleccione un motor de base de datos y escriba el nombre de usuario y la contraseña.
1. Para guardar los cambios, elija **Aplicar** en la parte inferior de la página.
Se tarda alrededor de 10 minutos en añadir una instancia de base de datos. Cuando se haya completado la actualización del entorno, el nombre de host de la instancia de base de datos y otra información de conexión estarán disponibles para su aplicación mediante las siguientes propiedades de entorno
| Nombre de la propiedad | Descripción | Valor de la propiedad |
| --- | --- | --- |
| `RDS_HOSTNAME` | El nombre de host de la instancia de base de datos. | En la pestaña **Connectivity & security (Conectividad y seguridad)** de la consola de Amazon RDS: **Endpoint (Punto de conexión)**. |
| `RDS_PORT` | El puerto en donde la instancia de base de datos acepta las conexiones. El valor predeterminado varía dependiendo del motor de base de datos. | En la pestaña **Connectivity & security (Conectividad y seguridad)** de la consola de Amazon RDS: **Port (Puerto)**. |
| `RDS_DB_NAME` | El nombre de la base de dato, **ebdb**. | En la pestaña **Configuration (Configuración)** de la consola de Amazon RDS: **DB Name (Nombre de la base de datos)**. |
| `RDS_USERNAME` | El nombre de usuario que ha configurado para la base de datos. | En la pestaña **Configuration (Configuración)** de la consola de Amazon RDS: **Master username (Nombre de usuario maestro)**. |
| `RDS_PASSWORD` | La contraseña que ha configurado para la base de datos. | No está disponible como referencia en la consola de Amazon RDS. |
Para obtener más información sobre la configuración de una instancia de bases de datos acopladas a un entorno de Elastic Beanstalk, consulte [Añadir una base de datos al entorno de Elastic Beanstalk](using-features.managing.db.md).
## Descargar un controlador
Añada el controlador de base de datos al archivo [`package.json` del proyecto](nodejs-platform-dependencies.md#nodejs-platform-packagejson) bajo `dependencies`.
**Example `package.json`: Express con MySQL**
```
{
"name": "my-app",
"version": "0.0.1",
"private": true,
"dependencies": {
"ejs": "latest",
"aws-sdk": "latest",
"express": "latest",
"body-parser": "latest",
"mysql": "latest"
},
"scripts": {
"start": "node app.js"
}
}
```
**Paquetes de controladores comunes para Node.js**
+ **MySQL** — [mysql](https://www.npmjs.com/package/mysql)
+ **PostgreSQL** — [node-postgres](https://www.npmjs.com/package/pg)
+ **SQL Server** — [node-mssql](https://www.npmjs.com/package/mssql)
+ **Oracle** — [node-oracledb](https://www.npmjs.com/package/oracledb)
## Conexión a una base de datos
Elastic Beanstalk proporciona información de conexión para instancias de base de datos asociadas en propiedades de entorno. Use `process.env.VARIABLE` para leer las propiedades y configurar una conexión con la base de datos.
**Example app.js: conexión con una base de datos MySQL**
```
var mysql = require('mysql');
var connection = mysql.createConnection({
host : process.env.RDS_HOSTNAME,
user : process.env.RDS_USERNAME,
password : process.env.RDS_PASSWORD,
port : process.env.RDS_PORT
});
connection.connect(function(err) {
if (err) {
console.error('Database connection failed: ' + err.stack);
return;
}
console.log('Connected to database.');
});
connection.end();
```
[Para obtener más información sobre cómo crear una cadena de conexión mediante node-mysql, consulte npmjs. org/package/mysql](https://npmjs.org/package/mysql).
# Herramientas y recursos de Node.js
Existen varios lugares a los que puede acudir para obtener ayuda adicional con el desarrollo de sus aplicaciones Node.js:
****
| Recurso | Description (Descripción) |
| --- | --- |
| [GitHub](https://github.com/aws/aws-sdk-js) | Instale el AWS SDK para Node.js mediante GitHub. |
| [AWS SDK para Node.js (versión preliminar para desarrolladores)](https://aws.amazon.com/sdkfornodejs/) | Un único lugar para obtener código de ejemplo, documentación, herramientas y recursos adicionales. |