Cómo dockerizar una API REST de Node.js

El proceso de implementación y ejecución de aplicaciones en diferentes entornos puede ser complicado, ya que hay una serie de factores a considerar. como configurar las variables de entorno para configurar las dependencias necesarias y versiones específicas de diferentes paquetes de software.

Sin embargo, al utilizar la tecnología de contenedores de Docker, puede implementar aplicaciones en diferentes entornos con un esfuerzo mínimo con todas las dependencias necesarias en la imagen de Docker. Es decir, no tienes que preocuparte por hacer ninguna configuración. Esto hace que el proceso de implementación y ejecución de aplicaciones en diferentes entornos sea muy sencillo.

¿Qué es Docker?

Estibador es una plataforma de desarrollo que proporciona las herramientas y el entorno para empaquetar aplicaciones como imágenes portátiles que se pueden ejecutar como componentes ejecutables autónomos en contenedores.

Estos contenedores constituyen el código de la aplicación y las dependencias necesarias para que la aplicación se ejecute correctamente en diferentes entornos de tiempo de ejecución sin ningún problema.

Antes de comenzar, instale Docker en su máquina local. Consulte los requisitos previos específicos de la plataforma y las instrucciones de instalación de la documentación oficial.

Crear una API REST de Node.js

Para empezar, crear un servidor web Node.js.

Puede encontrar el código de esta aplicación en su repositorio GitHub.

A continuación, instale los paquetes necesarios para este proyecto.

npm instalar morgan pg knex

El pág. El paquete se utiliza para establecer una conexión con una base de datos PostgreSQL. knex, por otro lado, proporciona una API simple para interactuar con PostgreSQL: la usará para escribir consultas SQL.

Por último, utilizará morgan, un middleware que registra solicitudes y respuestas HTTP en la consola, para depurar y monitorear su aplicación que se ejecuta en un contenedor Docker.

Finalmente, abra el índice.js archivo, y agregue el código debajo de eso implementa una API REST simple con tres rutas.

constante expresar = requerir("expresar")
constante morgan = requerir("morgan")
constante aplicación = expreso()
constante db = requerir('./db')
constante PUERTO = proceso.env. PUERTO || 5000
aplicación.use (morgan('desarrollador'))
aplicación.use (express.json())
app.use (express.urlencoded({ extendido: verdadero }))
aplicación.obtener('/', (req, res) => res.enviar('¡Hola Mundo!' ))
aplicación.obtener('/usuarios', asíncrono (requerido, res) => {
constante usuarios = esperar db.select().from('usuarios')
 res.json (usuarios)
})
aplicación.post('/usuarios', asíncrono (requerido, res) => {
constante usuario = esperar base de datos('usuarios').insertar({ nombre: req.body.name }).returning('*')
 res.json (usuario)
})
app.escuchar (PORT, () => consola.registro(`Servidor en PUERTO:${PORT}`))

Configurar la conexión de la base de datos

La API REST interactuará con la instancia de PostgreSQL de Docker; sin embargo, primero debe configurar la conexión de la base de datos en su aplicación. En el directorio raíz de la carpeta de su proyecto, cree un db.js archivo y agregue el código a continuación.

constante knex = requerir('knex')
módulo.exportaciones = knex({
 cliente: 'postgres',
 conexión: {
 anfitrión: 'db',
 usuario: 'usuario de prueba',
 contraseña: 'micontraseña123',
 base de datos: 'usuario de prueba',

 },
})

Configurar los archivos migrate.js y seed.js

Estos dos archivos permitirán crear una tabla en la base de datos y llenarla con datos de prueba a través de la API. Crear una nueva carpeta, guiones, en el directorio raíz de su proyecto y agregue dos archivos: migrar.js y semilla.js.

En el migrar.js archivo, agregue el siguiente código:

constante db = requerir('../db');
(asíncrono () => {
intentar {
esperar db.schema.dropTableIfExists('usuarios')
esperar db.schema.withSchema('público').crear mesa('usuarios', (tabla) => {
 tabla.incrementos()
 tabla.cadena('nombre')
 })
consola.registro('¡Tabla de usuarios creada!')
 proceso.salir(0)
 } atrapar (Error) {
consola.log (error)
 proceso.salir(1)
 }
})()

Este código creará un usuarios tabla con una columna de identificación de incremento automático y una nombre columna en la base de datos.

A continuación, en el semilla.js archivo, agregue el siguiente código:

constante db = requerir('../db');
(asíncrono () => {
intentar {
esperar base de datos('usuarios').insertar({ nombre: 'Usuario de prueba1' })
esperar base de datos('usuarios').insertar({ nombre: 'Usuario de prueba2' })
consola.registro('¡Usuarios ficticios agregados!')
 proceso.salir(0)
 } atrapar (Error) {
consola.log (error)
 proceso.salir(1)
 }
})()

Este código implementa una función asíncrona que insertará dos usuarios en la base de datos de PostgreSQL.

Finalmente, agregue estos comandos a su paquete.json archivo.

"guiones": {
"comenzar": "nodo index.js",
"emigrar": "secuencias de comandos de nodo/migrar.js",
"semilla": "scripts de nodo/seed.js"
 },

Dado que no tiene un cliente configurado, para probar la API, deberá ejecutar los dos archivos como secuencias de comandos junto con el npm ejecutar dominio.

Configurar un Dockerfile

Un Dockerfile define las instrucciones requeridas por el motor de Docker para crear una imagen de Docker. En el directorio raíz de su proyecto, cree un nuevo archivo y asígnele un nombre, Dockerfile. Luego, agregue las siguientes instrucciones para crear una imagen de Docker para la aplicación Node.js.

DE nodo:16.3.0-alpino3.13
DIR.TRABAJO /app
COPIAR paquete*.json ./
CORRER instalar npm
COPIAR. .
EXPONER8000
CMD [ "nodo", "index.js" ]

Vamos a desglosarlo:

• DE - Esta instrucción establece la imagen base para la aplicación, que es la imagen Alpine de Node.js, una versión ligera de la imagen de Node.js que se puede encontrar en el registro de Docker.
• DIR.TRABAJO - conjuntos /app directorio como directorio de trabajo.
• COPIAR paquete*.json./ - indica a Docker que copie todos los archivos con ese formato de nombre de archivo del directorio actual al /app carpeta.
• CORRER - ejecuta y construye la imagen.
• COPIAR.. - copia los archivos fuente en el /app carpeta.
• EXPONER - esto indica a Docker que exponga un puerto dentro del contenedor al entorno externo, en este caso, la máquina host.
• CMD: especifica el comando que se ejecutará cuando se cree el contenedor Docker a partir de la imagen.

Crear el archivo de redacción de Docker

Para que la aplicación Node.js interactúe con la instancia PostgreSQL de Docker, las dos aplicaciones deben ejecutarse en contenedores Docker dentro del mismo entorno de red.

Por esta razón, debe definir y construir tanto la imagen de la aplicación como la instancia de PostgreSQL usando Componer ventana acoplable — una herramienta que le permite construir y administrar múltiples contenedores Docker.

En pocas palabras, utilizando un Docker Compose, puede definir los servicios que componen su aplicación como una sola unidad, para este caso, la API REST de Node.js y la base de datos PostgreSQL.

Crear un nuevo archivo, docker-compose.yml, en el directorio raíz y agregue el siguiente código:

versión:'3.9'
servicios:
servidor:
construir:.
puertos:
-'5000:5000'
depende de:
-base de datos
base de datos:
imagen:'postgres'
puertos:
-'4321:5432'
ambiente:
POSTGRES_CONTRASEÑA:'micontraseña123'
POSTGRES_USUARIO:'usuario de prueba'
volúmenes:
-datos:/var/lib/postgresql/datos
volúmenes:
datos:

Este código creará y ejecutará dos contenedores Docker. El primer contenedor, servidor, Docker Compose usa Dockerfile para crear la imagen para este contenedor.

También especifica que el contenedor del servidor depende del base de datos envase. Significado, el servidor El contenedor debe iniciarse después de la base de datos contenedor para conectarse con él.

El segundo contenedor es un contenedor de base de datos PostgreSQL. No necesita especificar un Dockerfile para este contenedor, ya que se creará a partir de la imagen de PostgreSQL en el registro de imágenes de Docker.

Cree las imágenes de Docker

Utilice el comando Compose de Docker para crear las imágenes e iniciar los dos contenedores.

ventana acoplable-componer hasta -d

Debería ver una respuesta similar después de que el proceso se complete con éxito.

Probar la API REST

Ejecute el siguiente comando para probar la API REST que se ejecuta en el contenedor Docker. Debería crear una tabla en la base de datos PostgreSQL.

docker exec docker_node-server-1 npm ejecutar migrar

Debería ver una respuesta similar.

Compartir las imágenes de Docker

El paso final es enviar la imagen de Docker para su aplicación Node.js a Docker Hub. Esto es similar a subir tus proyectos a GitHub.

• Dirigirse a Centro acoplable y regístrese para obtener una cuenta e inicie sesión en el panel de usuario.
• A continuación, haga clic en Crear un repositorio. Proporcione el nombre de su repositorio y establezca su visibilidad en Público o Privado y luego haga clic Crear.
• Para enviar la imagen de Docker de su aplicación a Docker Hub, primero debe iniciar sesión en su cuenta a través de la terminal y luego proporcionar su nombre de usuario y contraseña.

inicio de sesión de la ventana acoplable

• A continuación, actualice el nombre de su imagen de Docker para que coincida con este formato: /. Ejecute el siguiente comando para realizar este cambio:

 etiqueta acoplable /

• Finalmente, inserte su imagen de Docker.

 empuje de la ventana acoplable /< nombre del repositorio>

Uso de Docker en desarrollo

Esta guía solo se refirió a una fracción del potencial que Docker puede ofrecer. Sin embargo, ahora puede usar la tecnología de contenedores de Docker para empaquetar cualquier aplicación y todas sus dependencias como imágenes que se pueden implementar en diferentes entornos de desarrollo, así como de producción como la nube sin ningún tipo de hipo