Cómo implementar una aplicación Node.js en Amazon Web Services con Docker

Enchufe: publicado originalmente en la revista Zeolearn.
Para obtener más contenido útil para desarrolladores, como este artículo, visite el blog de Zeolearn. El blog presenta artículos centrados en el desarrollo web / software: AngularJS, ReactJS, NodeJS, Django y Data Science (incluido el aprendizaje automático, la ciencia de datos, Python y el aprendizaje profundo).

Tabla de contenido

1. Introducción
2. Prerrequisitos
3. Una introducción rápida sobre Docker y AWS
4. Lo que estaremos desplegando
5. Crear un Dockerfile
6. Construyendo una imagen acoplable
7. Ejecutando un contenedor acoplable
8. Crear el Registro (ECR) y cargarle la imagen de la aplicación
9. Crear una nueva definición de tarea
10. Crear un clúster
11. Crear un servicio para ejecutarlo
12. Conclusión

1. Introducción

Escribir código que haga cosas es algo con lo que la mayoría de los desarrolladores están familiarizados. A veces, tenemos que asumir la responsabilidad de un ingeniero de SysAdmin o DevOps e implementar nuestra base de código en producción donde ayudará a una empresa a resolver problemas para los clientes.

En este tutorial, le mostraré cómo acoplar una aplicación Node.js y desplegarla en Amazon Web Service (AWS) usando Amazon ECR (Elastic Container Registry) y ECS (Elastic container service).

2. Prerrequisitos

Para seguir este tutorial, necesitará lo siguiente:

  1. Nodo y Npm: siga este enlace para instalar las últimas versiones.
  2. Conocimientos básicos de Node.js.
  3. Docker: la instalación proporciona Docker Engine, el cliente Docker CLI y otras cosas interesantes. Siga las instrucciones para su sistema operativo. Para verificar si la instalación funcionó, dispare esto en la terminal:
docker --version

El comando anterior debe mostrar el número de versión. Si no es así, la instalación no se completó correctamente.

4. Cuenta de AWS: regístrese para obtener un nivel gratuito. Hay un período de espera para verificar su número de teléfono y tarjeta bancaria. Después de esto, tendrá acceso a la consola.

5. CLI de AWS: siga las instrucciones para su sistema operativo. Necesita Python instalado.

3. Una introducción rápida sobre Docker y AWS

Docker es un software de código abierto que le permite empaquetar una aplicación junto con las dependencias y el entorno requeridos en un "Contenedor" que puede enviar y ejecutar en cualquier lugar. Es independiente de las plataformas o el hardware y, por lo tanto, la aplicación en contenedores puede ejecutarse en cualquier entorno de forma aislada.

Los contenedores Docker resuelven muchos problemas, como cuando una aplicación funciona en la computadora de un compañero de trabajo pero no se ejecuta en la suya, o funciona en el entorno de desarrollo local, pero no funciona cuando la implementa en un servidor.

Amazon Web Services (AWS) ofrece un servicio de computación en la nube confiable, escalable y económico para las empresas. Como mencioné antes, este tutorial se centrará en el uso de los servicios ECR y ECS.

4. Lo que estaremos desplegando

Creemos rápidamente una aplicación de muestra que usaremos para este tutorial. Será la aplicación Node.js muy simple.

Ingrese lo siguiente en su terminal:

// crea un nuevo directorio
mkdir sample-nodejs-app
// cambia al nuevo directorio
cd sample-nodejs-app
// Inicializar npm
npm init -y
// instalar express
npm install express
// crea un archivo server.js
toque server.js

Abra server.js y pegue el siguiente código en él:

// server.js
const express = require ('express')
aplicación const = express ()
app.get ('/', (req, res) => {
    res.send ('¡Hola mundo desde una aplicación Node.js!')
})
app.listen (3000, () => {
    console.log ('El servidor está funcionando en 3000')
})

Inicie la aplicación con:

nodo server.js

Acceda a él en http: // localhost: 3000. ¡Deberías obtener Hello world de una aplicación Node.js! se muestra en su navegador. El código completo está disponible en GitHub.

Ahora llevemos nuestra aplicación muy importante a producción .

5. Crear un Dockerfile

Vamos a comenzar a dockerizar la aplicación creando un solo archivo llamado Dockerfile en la base de nuestro directorio de proyectos.

El Dockerfile es el plano a partir del cual se construyen nuestras imágenes. Y luego las imágenes se convierten en contenedores, en los que ejecutamos nuestras aplicaciones.

Cada Dockerfile comienza con una imagen base como base. Hay dos formas de abordar la creación de su Dockerfile:

  1. Use una imagen base de sistema operativo simple (por ejemplo, Ubuntu OS, Debian, CentOS, etc.) e instale un entorno de aplicación como Node.js O
  2. Utilice una imagen base preparada para el entorno para obtener una imagen del sistema operativo con un entorno de aplicación ya instalado.

Procederemos con el segundo enfoque. Podemos usar la imagen oficial de Node.js alojada en Dockerhub que se basa en Alpine Linux.

Escribe esto en el Dockerfile:

DESDE nodo: 8-alpino
EJECUTAR mkdir -p / usr / src / app
WORKDIR / usr / src / app
COPIAR . .
EJECUTAR npm install
EXPOSE 3000
CMD ["nodo", "server.js"]

Pasemos por esta línea por línea para ver qué está sucediendo aquí y por qué.

DESDE nodo: 8-alpino

Aquí, estamos construyendo nuestra imagen Docker usando la imagen oficial Node.js de Dockerhub (un repositorio para imágenes base).

  • Comience nuestro Dockerfile con una declaración FROM. Aquí es donde especificas tu imagen base.
  • La instrucción RUN nos permitirá ejecutar un comando para cualquier cosa que desee hacer. Creamos un subdirectorio / usr / src / app que contendrá nuestro código de aplicación dentro de la imagen del acoplador.
  • La instrucción WORKDIR establece el subdirectorio que creamos como el directorio de trabajo para cualquier instrucción RUN, CMD, ENTRYPOINT, COPY y ADD que siga en el Dockerfile. / usr / src / app es nuestro directorio de trabajo.
  • COPY nos permite copiar archivos de una fuente a un destino. Copiamos el contenido de nuestro código de aplicación de nodo (server.js y package.json) de nuestro directorio actual al directorio de trabajo en nuestra imagen acoplable.
  • La instrucción EXPOSE informa a Docker que el contenedor escucha en los puertos de red especificados en tiempo de ejecución. Especificamos el puerto 3000.
  • Por último, pero no menos importante, la instrucción CMD especifica el comando para iniciar nuestra aplicación. Esto le dice a Docker cómo ejecutar su aplicación. Aquí usamos el nodo server.js, que normalmente es cómo se ejecutan los archivos en Node.js.

Con este archivo completado, ahora estamos listos para construir una nueva imagen de Docker.

6. Construyendo una imagen acoplable

Asegúrese de tener Docker en funcionamiento. Ahora que hemos definido nuestro Dockerfile, construyamos la imagen con un título usando -t:

docker build -t sample-nodejs-app.

Esto generará hashes y cadenas alfanuméricas que identifican contenedores e imágenes que dicen "Construcción exitosa" en la última línea:

Envío de contexto de compilación a Docker daemon 1.966MB
Paso 1/7: DESDE nodo: 6-alpino
 ---> 998971a692ca
Paso 2/7: EJECUTAR mkdir -p / usr / src / app
 ---> Usando caché
 ---> f1aa1c112188
Paso 3/7: WORKDIR / usr / src / app
 ---> Usando caché
 ---> b4421b83357b
Paso 4/7: COPIAR. .
 ---> 836112e1d526
Paso 5/7: RUN npm install
 ---> Ejecutando en 1c6b36b5381c
npm WARN sample-nodejs-app@1.0.0 Sin descripción
npm WARN sample-nodejs-app@1.0.0 Sin campo de repositorio.
Extracción del contenedor intermedio 1c6b36b5381c
 ---> 93999e6c807f
Paso 6/7: EXPOSE 3000
 ---> Corriendo en 7419020927f1
Extracción del contenedor intermedio 7419020927f1
 ---> ed4ac8a31f83
Paso 7/7: CMD ["nodo", "server.js"]
 ---> Ejecutando en c77d34f4c873
Extracción del contenedor intermedio c77d34f4c873
 ---> eaf97859f909
Construido con éxito eaf97859f909
// no esperes los mismos valores de tu terminal.

7. Ejecutar un contenedor Docker

Hemos creado la imagen del acoplador. Para ver imágenes creadas previamente, ejecute:

imágenes de la ventana acoplable

Debería ver la imagen que acabamos de crear como la más reciente en función del tiempo:

Copie el ID de la imagen. Para ejecutar el contenedor, escribimos en el terminal:

docker run -p 80: 3000 {image-id}
// rellena con tu ID de imagen

Por defecto, los contenedores Docker pueden hacer conexiones con el mundo exterior, pero el mundo exterior no puede conectarse a los contenedores. -p publica todos los puertos expuestos a las interfaces del host. Aquí publicamos la aplicación en el puerto 80: 3000. Debido a que estamos ejecutando Docker localmente, vaya a http: // localhost para ver.

En cualquier momento, puede verificar la ejecución de contenedores Docker escribiendo:

contenedor acoplable ls

Finalmente, puede detener la ejecución del contenedor:

docker stop {imagen-id}

Deje el demonio Docker ejecutándose.

8. Cree el registro (ECR) y cargue la imagen de la aplicación

Amazon Elastic Container Registry (ECR) es un registro de contenedores Docker totalmente administrado que facilita a los desarrolladores almacenar, administrar e implementar imágenes de contenedores Docker. Amazon ECR está integrado con Amazon Elastic Container Service (ECS), lo que simplifica su flujo de trabajo de desarrollo a producción.

La palabra clave "Elastic" significa que puede escalar la capacidad o reducirla según lo desee.

Pasos:

  1. Vaya a la consola de AWS e inicie sesión.
  2. Seleccione el servicio de contenedor EC2 y comience

3. Aparece la primera página de ejecución, desplácese hacia abajo y haga clic en cancelar> ingresar al panel de control de ECS.

4. Para garantizar que su CLI pueda conectarse con su cuenta de AWS, ejecute en el terminal:

aws configure

Si su AWS CLI se instaló correctamente, aws configure le pedirá lo siguiente:

$ aws configure
ID de clave de acceso de AWS [Ninguna]: tecla de acceso
Clave de acceso secreta de AWS [Ninguna]: clave secreta
Nombre de región predeterminado [Ninguno]: us-west-2
Formato de salida predeterminado [Ninguno]:

Obtenga las credenciales de seguridad de su cuenta de AWS con su nombre de usuario> Claves de acceso. Ejecute aws configure nuevamente y complete correctamente.

4. Cree un nuevo repositorio e ingrese un nombre (preferiblemente con el mismo nombre del contenedor que en su entorno de desarrollo local para mantener la coherencia).

Por ejemplo, use sample-nodejs-app.

Siga las 5 instrucciones de la consola de AWS para crear, etiquetar y enviar imágenes de Docker:

Nota: Los argumentos a continuación son míos y diferirán de los suyos, así que solo siga los pasos descritos en su consola.

  1. Recupere el comando de inicio de sesión de Docker que puede usar para autenticar su cliente Docker en su registro:
    Nota: Si recibe un error de "Opciones desconocidas: no incluir correo electrónico", instale la última versión de la AWS CLI. Aprende más aquí.
aws ecr get-login --no-include-email --region us-east-2

2. Ejecute el comando de inicio de sesión de Docker que se devolvió en el paso anterior (solo copie y pegue). Nota: Si está utilizando Windows PowerShell, ejecute el siguiente comando en su lugar:

Invoke-Expression -Command (aws ecr get-login --no-include-email --region us-east-2)

Debería generar: Inicio de sesión correcto.

3. Cree su imagen de Docker con el siguiente comando. Para obtener información sobre cómo crear un archivo Docker desde cero, consulte las instrucciones aquí. Puede omitir este paso ya que nuestra imagen ya está construida:

docker build -t sample-nodejs-app.

4. Con una compilación completada, etiquete su imagen con una palabra clave (por ejemplo, la última) para que pueda insertar la imagen en este repositorio:

docker tag sample-nodejs-app: último 559908478199.dkr.ecr.us-east-2.amazonaws.com/sample-nodejs-app:latest

5. Ejecute el siguiente comando para enviar esta imagen a su repositorio de AWS recién creado:

docker push 559908478199.dkr.ecr.us-east-2.amazonaws.com/sample-nodejs-app:latest

9. Crear una nueva definición de tarea

Las tareas funcionan como el comando docker run de la CLI de Docker pero para varios contenedores. Ellos definen:

  • Imágenes de contenedor (para usar)
  • Volúmenes (si los hay)
  • Variables de entorno de redes
  • Mapeos de puertos

Desde Definiciones de tareas en el panel de ECS, presione el botón Crear nueva definición de tareas (ECS):

Establezca un nombre de tarea y siga los siguientes pasos:

  • Añadir contenedor: sample-nodejs-app (el que empujamos).
  • Imagen: la URL de su contenedor. El mío es 559908478199.dkr.ecr.us-east-2.amazonaws.com/sample-nodejs-app
  • Límite suave: 512
  • Mapa 80 (host) a 3000 (contenedor) para sample-nodejs-app
  • Variables Env:

NODE_ENV: producción

10. Crear un clúster

Un clúster es el lugar donde se ejecutan los contenedores de AWS. Usan configuraciones similares a las instancias de EC2. Defina lo siguiente:

  • Nombre del clúster: demo-nodejs-app-cluster
  • Tipo de instancia EC2: t2.micro

(Nota: selecciona las instancias en función del tamaño de su solicitud. Aquí hemos seleccionado la más pequeña. Su selección afecta la cantidad de dinero que se le factura a fin de mes. Visite aquí para obtener más información). Gracias Nicholas Kolatsis por señalar que la selección anterior de m4.large era costosa para este tutorial.

  • Número de instancias: 1
  • Almacenamiento EBS: 22
  • Par clave: ninguno
  • VPC: nuevo

Cuando se complete el proceso, puede optar por hacer clic en "Ver clúster".

11. Crea un servicio para ejecutarlo

Vaya a Definición de tarea> haga clic en demo-nodejs-app> haga clic en la última revisión.

Dentro de la definición de tarea, haga clic en el menú desplegable de acciones y seleccione Crear servicio

Use lo siguiente:

  • Tipo de lanzamiento: EC2
  • Nombre del servicio: demo-nodejs-app-service
  • Número de tareas: 1

Omita las opciones y haga clic en Crear servicio y Ver servicio.

Verá su estado como PENDIENTE. Dale un poco de tiempo e indicará EN EJECUCIÓN.

Vaya a Cluster (a través de un enlace del servicio que acabamos de crear)> Instancias EC2> Haga clic en la instancia del contenedor para revelar el DNS público.

¡Visite el DNS público para ver nuestra aplicación! El mío es ec2–18–219–113–111.us-east-2.compute.amazonaws.com

12. Conclusión.

¡Felicidades por terminar esta publicación! Toma el código de la parte Docker de Github.

Siéntase libre de apoyarme (devapparel.co) y verse bien mientras lo hace. Además, comenta o comparte esta publicación. ¡Gracias por leer!

Plug: Nuevamente, para obtener más contenido de calidad como este, visite el blog de Zeolearn.