Implementación de aplicaciones de Node.js en AWS EC2 con Docker

AWS EC2 es un servicio central y la base para muchos otros servicios. En este artículo, crearemos una aplicación Node con Docker, configuraremos una instancia EC2 e implementaremos nuestra aplicación en ella.

Introducción

Una vez que haya escrito una aplicación web, hay docenas de ofertas para poner su aplicación en línea y que otras personas puedan utilizarla. Una oferta bien conocida es parte de la plataforma Amazon Web Services (AWS) - Nube informática elástica (EC2).

EC2 es una parte central de AWS, y muchos otros servicios de AWS se construyen sobre él; por lo tanto, es bueno comprender qué es EC2 y cómo implementarlo.

En este tutorial, vamos a crear una aplicación Node.js básica con Docker, iniciar y configurar una instancia EC2 e implementar nuestra aplicación en ella. Al final de este tutorial, tendrá su aplicación Node ejecutándose en AWS y comprenderá mejor cómo interactuar con un servicio central de AWS.

Requisitos previos

Cuenta de AWS

Servicios web de Amazon (AWS) es una colección de herramientas para construir aplicaciones en la nube. Como EC2 es un servicio de AWS, necesitaremos configurar una cuenta de AWS.

AWS tiene un nivel gratuito para muchas cosas increíbles, y EC2 no es una excepción: puede usar 750 horas (31 días) de EC2 al mes en el nivel gratuito durante todo un año.

ventana acoplable

Estibador nos permite agrupar nuestras aplicaciones en pequeñas unidades fácilmente implementables que se pueden ejecutar en cualquier lugar donde esté instalado Docker. Esto significa que no más de eso '¡pero funciona en mi máquina!'

Este artículo asumirá una familiaridad básica con Docker y no profundizará en él; sin embargo, si desea profundizar más, consulte Implementación de una aplicación Node.js en una gota de DigitalOcean with Docker.

Aplicación de nodo

Hagamos una aplicación de Nodo realmente simple que responda a una solicitud. Para hacer esto, abriremos una terminal y ejecutaremos:

1
2
3
$ mkdir node-ec2
$ cd node-ec2
$ npm init

Esto creará una nueva carpeta, se moverá a esa carpeta y luego inicializará una nueva aplicación Node.

Sigamos con los valores predeterminados de NPM por ahora: este artículo asumirá que dejó el punto de entrada como index.js. Esto generará nuestro archivo package.json, que es esencialmente un archivo de configuración para nuestra aplicación.

Una vez que se crea el archivo package.json, ábralo y agregue la siguiente línea al principio de la sección scripts:

1
"start": "node index.js",

Al hacer esto, en lugar de ejecutar node index.js, usaremos npm start, que ejecutará todo en nuestro script. En este caso específico, simplemente ejecuta node index.js, aunque en realidad podría ser mucho más que eso. Por ejemplo, si podemos agregar indicadores al comando sin tener que escribirlo cada vez, o podemos establecer algunas variables de entorno como NODE_ENV=index.js del nodo de producción.

Para atender nuestras solicitudes, vamos a utilizar el marco Expresar: es minimalista y fácil de usar:

1
$ npm install express --save

Nuestro package.json ahora debería verse así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
{
  "name": "app",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.17.1"
  }
}

Espere la instalación y luego abriremos nuestro editor de código preferido para crear otro archivo nuevo en la misma ubicación llamado index.js.

El archivo configurará Express y definirá un controlador de solicitudes:

1
2
3
4
5
6
7
const express = require('express');
const app = express();
const port = 3000;

app.get('/status', (req, res) => res.send({status: "I'm alive!"}));

app.listen(port, () => console.log(`Example app listening on port ${port}!`));

Esta aplicación se iniciará en el puerto 3000 y servirá un punto final en /status. Podemos verificar que esto funciona ejecutando:

1
2
$ npm start
Example app listening on port 3000!

Dirigiéndose a http://localhost:3000/status - deberíamos recibir una respuesta con {status: "¡Estoy vivo!"}. Una vez que haya tenido éxito, asegúrese de detener el servidor con [CTRL]{.kbd}+[C]{.kbd}.

Con nuestra sencilla aplicación Node lista, convirtámosla en una imagen de Docker que implementaremos en EC2.

Dockerizing the Node Application

Cree un nuevo archivo en el mismo directorio que su aplicación Node, llamado Dockerfile:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
FROM node:13-alpine

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000
CMD [ "node", "index.js" ]

Este es un Dockerfile básico que se puede usar para la mayoría de las aplicaciones de Nodo simples. A continuación, construyamos la imagen de Docker y luego ejecútela para verificar que funciona correctamente:

1
2
$ docker build . -t ec2-app
$ docker run -p 3000:3000 ec2-app

Si navega a http://localhost:3000/status nuevamente, debería ver la misma respuesta de estado anterior. Salga del proceso con [CTRL]{.kbd}+[C]{.kbd} nuevamente.

Finalmente, empujemos nuestra imagen de Docker a Centro acoplable:

1
2
3
$ docker login # Use your Docker Hub credentials here
$ docker tag ec2-app <YOUR_DOCKER_USERNAME>/ec2-app
$ docker push <YOUR_DOCKER_USERNAME>/ec2-app

Configuración de EC2

Con nuestra aplicación "dockerizada", necesitamos configurar una instancia EC2 para que se ejecute.

Dirígete a AWS e inicia sesión.

Haga clic en el menú desplegable 'Servicios' en la parte superior de la página y busque 'EC2'. AWS está experimentando actualmente con su interfaz, por lo que debería ver una página que se parece a la siguiente, pero el centro de la página puede verse ligeramente diferente.

Haga clic en el enlace 'Instancias' a la izquierda.

Página de bienvenida de EC2

En la siguiente vista, haga clic en el botón 'Iniciar instancia'. Verás una página que se ve así:

EC2 AMI Selection

AMI

Aquí es donde seleccionamos Amazon Machine Image - o AMI para abreviar. Una AMI es un servidor 'listo para usar' y puede venir con múltiples configuraciones.

Por ejemplo, podríamos seleccionar una de las AMI de inicio rápido que tienen amazonas linux 2 o, si se desplaza hacia abajo, hay instancias con Ubuntu ejecutándose en ellas, etc.

Cada AMI es una imagen congelada de una máquina con un sistema operativo y, potencialmente, algún software adicional instalado.

Para facilitar las cosas, podemos usar esto para crear una instancia EC2 con Docker ya configurado para nosotros.

Para hacer esto, debemos seleccionar 'AWS Marketplace' a la izquierda, y luego en el cuadro de búsqueda queremos ingresar 'ECS'. Deberíamos obtener algunos resultados, pero queremos la imagen 'ECS Optimized Amazon Linux 2'.

Esta imagen viene con Docker y está optimizada para ejecutar contenedores. Presiona 'Seleccionar' en la imagen elegida y continuaremos a la siguiente página:

Elegir una AMI

Tipos de instancia {#tipos de instancia}

En la siguiente vista, seleccionamos qué tipo de instancia queremos. En general, esto dicta los recursos disponibles para el servidor que estamos iniciando, con costos escalables para máquinas de mayor rendimiento.

El tipo de instancia t2.micro es elegible para el nivel gratuito, por lo que se recomienda usarlo:

Seleccionando el tipo de instancia EC2

Seleccione la casilla de verificación adecuada y luego haga clic en 'Revisar y lanzar' en la esquina inferior derecha. Haga clic en 'Iniciar' en el mismo lugar en la página siguiente y obtendrá una ventana emergente para seleccionar o crear un par de claves.

Seleccione el primer menú desplegable y seleccione 'Crear un nuevo par de claves'. En 'Nombre del par de claves', ingrese cómo desea llamar a su par de claves.

Asegúrese de 'Descargar el par de claves' en el lado derecho; esto es lo que usaremos para acceder a nuestra instancia EC2.

Al seleccionar 'Iniciar instancia' nuevamente, su instancia EC2 debería iniciarse:

Instancia de lanzamiento

Haga clic en el enlace resaltado para acceder a la página de detalles de la instancia.

Grupos de seguridad

Antes de intentar ejecutar nuestra aplicación, debemos asegurarnos de que podremos acceder a la aplicación.

La mayoría de los recursos de AWS operan bajo 'Security Groups': estos grupos dictan cómo se puede acceder a los recursos, en qué puerto y desde qué direcciones IP.

Haga clic en el grupo de seguridad resaltado aquí:

Enlace del grupo de seguridad

Desde aquí, podrá ver detalles sobre el grupo de seguridad, incluidas sus reglas de entrada y salida en varias pestañas. En la pestaña de entrada, con suerte verás esto:

Reglas de entrada

Lo que esto significa es que el tráfico que ingresa a través del puerto ‘22’, usando el protocolo TCP, está permitido desde cualquier lugar (‘0.0.0.0/0’ significa cualquier lugar). Necesitamos agregar otra regla para permitir que cualquiera acceda a nuestra aplicación en el puerto 3000.

En la parte superior de la página, haga clic en 'Acciones' y luego haga clic en 'Editar reglas de entrada'. En el cuadro de diálogo que se abre, haga clic en 'Agregar regla'.

Establezca el intervalo de puertos de la regla en 3000 y, en Fuente, haga clic en el menú desplegable y seleccione 'Anywhere'. El resto debe completarse automáticamente.

En última instancia, deberías terminar con algo como:

Editando las reglas de entrada

Conexión a su instancia EC2

Regrese a la página 'Instancias' (haga clic en el enlace de la izquierda) y seleccione la instancia que creó anteriormente. La dirección de su instancia EC2 se encuentra arriba del enlace a los grupos de seguridad en el campo 'DNS público'.

Regrese a la terminal y navegue a la carpeta donde se encuentra el par de claves que descargó anteriormente. Tendrá el nombre que haya ingresado para el nombre del par de claves, con un .pem como extensión.

Cambiemos los permisos de la clave y luego SSH en la instancia EC2:

1
2
$ chmod 400 <NAME_OF_KEYPAIR_FILE>
$ ssh -i <NAME_OF_KEYPAIR_FILE>[correo electrónico protegido]<PUBLIC_DNS>

Desde aquí, solo tenemos que iniciar nuestra aplicación a través de Docker:

1
$ docker run -p 3000:3000 <YOUR_DOCKER_USERNAME>/ec2-app

Podrá llegar a la instancia usando la misma dirección que usó para SSH en la instancia. Simplemente navegue en su navegador para:

1
<PUBLIC_DNS>:3000/status

Su aplicación debería devolverle el punto final de estado que vimos anteriormente. ¡Felicitaciones, acaba de ejecutar su primera aplicación en EC2!

¿Qué sigue? {#qué sigue}

Ejecute su aplicación sin cabeza

Sin embargo, una victoria rápida es ejecutar la aplicación "sin cabeza". A partir de ahora, su aplicación se está ejecutando actualmente en su sesión de shell, y tan pronto como cierre esa sesión, ¡la aplicación finalizará!

Para iniciar la aplicación de manera que siga ejecutándose en segundo plano, ejecute la aplicación con el indicador -d adicional:

1
$ docker run -d -p 3000:3000 <YOUR_DOCKER_USERNAME>/ec2-app

Seguridad

Es posible que desee volver atrás y reforzar la seguridad en la instancia/experimento con diferentes configuraciones, como configurarlo para que solo nosotros podamos acceder al puerto SSH, por ejemplo.

Cambie el campo 'Fuente' en la primera regla a 'Mi IP' - AWS averiguará automáticamente desde dónde está accediendo.

Nota: Si estás ejecutando este tutorial mientras te desplazas, o regresas a él más tarde, es posible que tu computadora tenga una IP diferente a la que tenías cuando configuraste inicialmente 'Mi IP'. Si encuentra alguna dificultad más adelante, asegúrese de volver aquí y seleccione 'Mi IP' de nuevo.

Otras AMI

Hay cientos de AMI diferentes, muchas de varias comunidades, con aplicaciones ya preinstaladas; vale la pena echar un vistazo para ver si hay una manera fácil de configurar algo que desea que funcione. ¡con!

Adición de un dominio

Ahora que tiene una aplicación ejecutándose en un servidor, es posible que desee configurar un nombre de dominio y apuntarlo a su aplicación.

Conclusión

EC2 es realmente la columna vertebral de una gran cantidad de servicios de AWS; por ejemplo, RDS (servicio de base de datos de AWS) es realmente solo instancias de EC2 muy optimizadas con un buen tablero.

Comprender este producto central en el arsenal de AWS seguramente abrirá las puertas a nuevas formas de implementar ideas.

En este tutorial, creamos una aplicación Node.js simple con la ayuda de Express, la dockerizamos, configuramos EC2 para la implementación y, finalmente, la implementamos en la instancia de EC2. C2.