Cómo crear una aplicación Node.js con Docker

  • 403 visualizaciones
  • 15 minuto de lectura
Hadi Bahadori
  • 8 de febrero de 2024
0 acciones
0
0
0
0
0
acciones
0
0
0
0

Introducción

La plataforma Docker permite a los desarrolladores empaquetar y ejecutar aplicaciones como contenedores. Un contenedor es un proceso único que se ejecuta en un sistema operativo compartido y constituye una alternativa más ligera a las máquinas virtuales. Si bien los contenedores no son nuevos, ofrecen ventajas —como el aislamiento de procesos y la estandarización del entorno— que serán cada vez más importantes a medida que más desarrolladores adopten arquitecturas de aplicaciones distribuidas.

Al crear y escalar una aplicación con Docker, el punto de partida suele ser crear una imagen de la aplicación, que luego se puede ejecutar en un contenedor. Esta imagen contiene el código de la aplicación, las bibliotecas, los archivos de configuración, las variables de entorno y el entorno de ejecución. Usar una imagen garantiza que el entorno del contenedor esté estandarizado y contenga solo lo necesario para crear y ejecutar la aplicación.

En este tutorial, crearás una imagen de aplicación para un sitio web estático que utiliza los frameworks Express y Bootstrap. Después, crearás un contenedor con esa imagen y lo subirás a Docker Hub para su uso futuro. Finalmente, extraerás la imagen guardada de tu repositorio de Docker Hub y la compilarás en otro contenedor, demostrando así cómo puedes refactorizar y escalar tu aplicación.

Requisitos previos

  • Un servidor con Ubuntu, con un usuario no root con privilegios de sudo y un firewall habilitado. Para obtener instrucciones sobre cómo configurarlo, seleccione su distribución de esta lista y siga nuestra guía de instalación inicial del servidor.
  • Docker está instalado en su servidor.
  • Node.js y npm instalados.
  • Una cuenta de Docker Hub.

Paso 1 – Instalar las dependencias de su aplicación

Para crear tu imagen, primero debes compilar los archivos de tu aplicación y luego copiarlos en tu contenedor. Estos archivos contienen el contenido estático, el código y las dependencias de tu aplicación.

Primero, crea un directorio para tu proyecto en el directorio personal de tu usuario no root. Llamaremos a nuestro proyecto node_project, pero puedes reemplazarlo por otro:

mkdir node_project

Vaya a este directorio:

cd node_project

Este será el directorio principal del proyecto.

A continuación, crea un archivo package.json con las dependencias de tu proyecto y demás información de identificación. Abre el archivo con nano o tu editor preferido:

nano package.json

Agregue la siguiente información sobre el proyecto, incluyendo su nombre, autor, licencia, punto de entrada y dependencias. Asegúrese de reemplazar la información del autor con su nombre y datos de contacto:

{
"name": "nodejs-image-demo",
"version": "1.0.0",
"description": "nodejs image demo",
"author": "Sammy the Shark <[email protected]>",
"license": "MIT",
"main": "app.js",
"keywords": [
"nodejs",
"bootstrap",
"express"
],
"dependencies": {
"express": "^4.16.4"
}
}

Este archivo contiene el nombre del proyecto, el autor y la licencia de distribución. Npm recomienda que el nombre del proyecto sea breve y descriptivo, y evitar duplicaciones en el registro de npm. En la sección de licencias, se incluye la licencia MIT, que permite el uso y la distribución gratuitos del código del programa. Además, el archivo especifica:

  • “main”: El punto de entrada de la aplicación, app.js. Crearás este archivo más adelante.
  • “Dependencias”: Dependencias del proyecto; en este caso, Express 4.16.4 o superior.

Aunque este archivo no incluye un repositorio, puedes añadir uno siguiendo estas instrucciones para añadir uno a tu archivo package.json. Esta es una buena adición si estás editando tu aplicación. Guarda y cierra el archivo cuando termines de realizar cambios.

Para instalar las dependencias de su proyecto, ejecute el siguiente comando:

npm install

Esto instalará los paquetes que enumeraste en el archivo package.json en el directorio de tu proyecto. Ahora podemos compilar los archivos de la aplicación.

Paso 2 – Crear los archivos del programa

Crearemos un sitio web que proporcione a los usuarios información sobre tiburones. Nuestra aplicación tendrá una entrada principal, app.js, y un directorio de vistas que contiene los recursos fijos del proyecto. La página de destino, index.html, proporcionará a los usuarios información básica y un enlace a una página con información más detallada sobre tiburones, sharks.html. En el directorio de vistas, crearemos tanto la página de destino como sharks.html.

Primero, abra app.js en el directorio principal del proyecto para definir las rutas del proyecto:

nano app.js

La primera parte del archivo crea los objetos de aplicación Express y Router y define el directorio base y el puerto como constantes:

const express = require('express');
const app = express();
const router = express.Router();

const path = __dirname + '/views/';
const port = 8080;

La función "require" carga el módulo Express, que luego usamos para crear los objetos de la aplicación y el enrutador. El objeto enrutador realiza la función de enrutamiento de la aplicación y, a medida que definimos las rutas de los métodos HTTP, las añadimos a este objeto para especificar cómo nuestra aplicación gestiona las solicitudes.

Esta sección del archivo también contiene varias constantes, Camino y Puerto Conjuntos:

  • ruta: define el directorio base que estará debajo del directorio de vistas en el directorio del proyecto actual.
  • Puerto: le indica al programa que escuche y se conecte al puerto 8080.

A continuación, configure las rutas de la aplicación utilizando el objeto enrutador:

...
router.use(function (req,res,next) {
console.log('/' + req.method);
next();
});
router.get('/', function(req,res){
res.sendFile(path + 'index.html');
});
router.get('/sharks', function(req,res){
res.sendFile(path + 'sharks.html');
});

La función router.use carga una función de middleware que registra las solicitudes del enrutador y las reenvía a las rutas de la aplicación. Estas se definen en las siguientes funciones, que especifican que una solicitud GET a la URL del proyecto base debe devolver la página index.html, mientras que una solicitud GET a la ruta /sharks debe devolver sharks.html.

Por último, monte el middleware del enrutador y los activos estáticos de la aplicación e indíquele a la aplicación que escuche en el puerto 8080:

...
app.use(express.static(path));
app.use('/', router);
app.listen(port, function () {
console.log('Example app listening on port 8080!')
})

El archivo app.js terminado se verá así:

const express = require('express');
const app = express();
const router = express.Router();
const path = __dirname + '/views/';
const port = 8080;
router.use(function (req,res,next) {
console.log('/' + req.method);
next();
});
router.get('/', function(req,res){
res.sendFile(path + 'index.html');
});
router.get('/sharks', function(req,res){
res.sendFile(path + 'sharks.html');
});
app.use(express.static(path));
app.use('/', router);
app.listen(port, function () {
console.log('Example app listening on port 8080!')
})

Guarda y cierra el archivo cuando hayas terminado.

A continuación, agreguemos contenido estático a la aplicación. Comience creando el directorio de vistas:

mkdir views

Abra el archivo de la página de destino, index.html:

nano views/index.html

Agregue el siguiente código al archivo, que importa Bootstrap y crea un componente jumbotron con un enlace a la página de información detallada sharks.html:

<!DOCTYPE html>
<html lang="en">
<head>
<title>About Sharks</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link href="css/styles.css" rel="stylesheet">
<link href="https://fonts.googleapis.com/css?family=Merriweather:400,700" rel="stylesheet" type="text/css">
</head>
<body>
<nav class="navbar navbar-dark bg-dark navbar-static-top navbar-expand-md">
<div class="container">
<button type="button" class="navbar-toggler collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false"> <span class="sr-only">Toggle navigation</span>
</button> <a class="navbar-brand" href="#">Everything Sharks</a>
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav mr-auto">
<li class="active nav-item"><a href="/" class="nav-link">Home</a>
</li>
<li class="nav-item"><a href="/sharks" class="nav-link">Sharks</a>
</li>
</ul>
</div>
</div>
</nav>
<div class="jumbotron">
<div class="container">
<h1>Want to Learn About Sharks?</h1>
<p>Are you ready to learn about sharks?</p>
<br>
<p><a class="btn btn-primary btn-lg" href="/sharks" role="button">Get Shark Info</a>
</p>
</div>
</div>
<div class="container">
<div class="row">
<div class="col-lg-6">
<h3>Not all sharks are alike</h3>
<p>Though some are dangerous, sharks generally do not attack humans. Out of the 500 species known to researchers, only 30 have been known to attack humans.
</p>
</div>
<div class="col-lg-6">
<h3>Sharks are ancient</h3>
<p>There is evidence to suggest that sharks lived up to 400 million years ago.
</p>
</div>
</div>
</div>
</body>
</html>

La barra de navegación superior permite a los usuarios navegar entre las páginas de Inicio y Sharks. En el componente navbar-nav, usamos la clase active de Bootstrap para mostrar al usuario la página actual. También hemos especificado rutas para nuestras páginas estáticas que coinciden con las rutas definidas en app.js:

...
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav mr-auto">
<li class="active nav-item"><a href="/" class="nav-link">Home</a>
</li>
<li class="nav-item"><a href="/sharks" class="nav-link">Sharks</a>
</li>
</ul>
</div>
...

Además, hemos creado un enlace a nuestra página de información sobre tiburones en el botón de jumbotrones:

...
<div class="jumbotron">
<div class="container">
<h1>Want to Learn About Sharks?</h1>
<p>Are you ready to learn about sharks?</p>
<br>
<p><a class="btn btn-primary btn-lg" href="/sharks" role="button">Get Shark Info</a>
</p>
</div>
</div>
...

También hay un enlace a una hoja de estilo personalizada en el encabezado:

...
<link href="css/styles.css" rel="stylesheet">
...

Al finalizar este paso, crearemos esta hoja de estilos. Guarde y cierre el archivo al terminar. Al colocar la página de inicio de la aplicación, podemos crear nuestra página de información sobre tiburones llamada sharks.html, que proporcionará a los usuarios interesados más información sobre los tiburones.

Abra el archivo:

nano views/sharks.html

Agregue el siguiente código, que importa Bootstrap y una hoja de estilo personalizada y proporciona a los usuarios información detallada sobre tiburones específicos:

<!DOCTYPE html>
<html lang="en">
<head>
<title>About Sharks</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link href="css/styles.css" rel="stylesheet">
<link href="https://fonts.googleapis.com/css?family=Merriweather:400,700" rel="stylesheet" type="text/css">
</head>
<nav class="navbar navbar-dark bg-dark navbar-static-top navbar-expand-md">
<div class="container">
<button type="button" class="navbar-toggler collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false"> <span class="sr-only">Toggle navigation</span>
</button> <a class="navbar-brand" href="/">Everything Sharks</a>
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav mr-auto">
<li class="nav-item"><a href="/" class="nav-link">Home</a>
</li>
<li class="active nav-item"><a href="/sharks" class="nav-link">Sharks</a>
</li>
</ul>
</div>
</div>
</nav>
<div class="jumbotron text-center">
<h1>Shark Info</h1>
</div>
<div class="container">
<div class="row">
<div class="col-lg-6">
<p>
<div class="caption">Some sharks are known to be dangerous to humans, though many more are not. The sawshark, for example, is not considered a threat to humans.
</div>
<img src="https://assets.digitalocean.com/articles/docker_node_image/sawshark.jpg" alt="Sawshark">
</p>
</div>
<div class="col-lg-6">
<p>
<div class="caption">Other sharks are known to be friendly and welcoming!</div>
<img src="https://assets.digitalocean.com/articles/docker_node_image/sammy.png" alt="Sammy the Shark">
</p>
</div>
</div>
</div>
</html>

Tenga en cuenta que en este archivo volvemos a usar la clase activa para mostrar la página actual. Guarde y cierre el archivo al terminar.

Por último, crea la hoja de estilos CSS personalizada a la que vinculaste en index.html y sharks.html creando primero una carpeta css en el directorio de vistas:

mkdir views/css

Abra la hoja de estilo:

nano views/css/styles.css

Agregue el siguiente código que establece el color y la fuente deseados para nuestras páginas:

.navbar {
margin-bottom: 0;
}
body {
background: #020A1B;
color: #ffffff;
font-family: 'Merriweather', sans-serif;
}
h1,
h2 {
font-weight: bold;
}
p {
font-size: 16px;
color: #ffffff;
}
.jumbotron {
background: #0048CD;
color: white;
text-align: center;
}
.jumbotron p {
color: white;
font-size: 26px;
}
.btn-primary {
color: #fff;
text-color: #000000;
border-color: white;
margin-bottom: 5px;
}
img,
video,
audio {
margin-top: 20px;
max-width: 80%;
}
div.caption: {
float: left;
clear: both;
}

Además de configurar la fuente y el color, este archivo también limita el tamaño de las imágenes con un ancho máximo del 80 %. Esto garantiza que no ocupen más espacio del deseado en la página. Guarde y cierre el archivo al terminar.

Con los archivos del programa instalados y las dependencias del proyecto instaladas, está listo para iniciar el programa.

Si siguió el tutorial de configuración inicial del servidor en los prerrequisitos, tendrá un firewall activo que solo permite el tráfico SSH. Para permitir el tráfico al puerto 8080:

sudo ufw allow 8080

Para iniciar el programa, asegúrese de estar en el directorio raíz de su proyecto:

cd ~/node_project

Inicie la aplicación con node app.js:

node app.js

Dirige tu navegador a http://your_server_ip:8080. Se cargará la siguiente página de destino:


Haz clic en el botón "Obtener información sobre tiburones". Se cargará la siguiente página de información:


Ya tienes una aplicación en funcionamiento. Cuando estés listo, sal del servidor presionando Ctrl+C. Ahora podemos crear un Dockerfile que nos permitirá reconstruir y escalar esta aplicación como deseemos.

Paso 3: Escritura del Dockerfile

Tu Dockerfile especifica qué se incluirá en el contenedor de tu aplicación al ejecutarse. Usar un Dockerfile te permite definir el entorno de tu contenedor y evitar conflictos con dependencias o versiones de tiempo de ejecución.

Al seguir estas pautas para crear contenedores óptimos, hacemos que nuestra imagen sea lo más eficiente posible al minimizar la cantidad de capas de imagen y limitar la funcionalidad de la imagen a un solo propósito: recrear archivos de aplicación y contenido estático.

En el directorio raíz de su proyecto, cree un Dockerfile:

nano Dockerfile

Las imágenes de Docker se crean mediante imágenes en capas sucesivas que se superponen. Nuestro primer paso será agregar la imagen base para nuestra aplicación, que será el punto de partida para compilarla.

Usaremos la imagen node:10-alpine, ya que es la versión LTS recomendada de Node.js al momento de escribir este artículo. La imagen Alpine proviene del proyecto Alpine Linux y nos ayuda a reducir el tamaño de la imagen. Para más información sobre si la imagen Alpine es una buena opción para su proyecto, consulte la explicación completa en la sección "Variantes de imagen" de la página de imágenes de Node de Docker Hub.

Agregue la siguiente directiva FROM para establecer la imagen base de la aplicación:

FROM node:10-alpine

Esta imagen incluye Node.js y npm. Cada Dockerfile debe comenzar con una directiva FROM.

De forma predeterminada, la imagen de Docker Node incluye un usuario de nodo no root, que puede usar para evitar que el contenedor de su aplicación se ejecute como root. Se recomienda evitar ejecutar contenedores como root y limitar las capacidades dentro del contenedor a las necesarias para ejecutar sus procesos. Por lo tanto, usamos el directorio de inicio del usuario de nodo como directorio de trabajo para nuestra aplicación y lo configuramos como nuestro usuario dentro del contenedor. Para obtener más información sobre las prácticas recomendadas al trabajar con la imagen de Docker Node, consulte esta guía de prácticas recomendadas.

Para ajustar los permisos del código de nuestra aplicación en el contenedor, crearemos un subdirectorio "node_modules" en /home/node junto con el directorio de la aplicación. Crear estos directorios garantiza que tengan los permisos necesarios, lo cual será importante al crear módulos de nodo locales en el contenedor con npm install. Además de crear estos directorios, asignamos su propiedad a nuestro usuario de nodo:

...
RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app

Para obtener más información sobre el uso de la integración de instrucciones RUN, lea esta discusión sobre cómo administrar capas de contenedor.

A continuación, configure el directorio de trabajo de la aplicación en /home/node/app:

...
WORKDIR /home/node/app

Si no se configura WORKDIR, Docker creará uno de forma predeterminada, por lo que es una buena idea configurarlo explícitamente.

Luego copie los archivos package.json y package-lock.json (para npm 5+):

...
COPY package*.json ./

Añadir esta directiva COPY antes de ejecutar npm install o copiar el código de la aplicación nos permite aprovechar el mecanismo de caché de Docker. En cada etapa de la compilación, Docker comprueba si una capa se ha almacenado en caché para esa directiva específica. Si modificamos el archivo package.json, esta capa se reconstruirá; si no, esta directiva permite a Docker usar la capa de imagen existente y evitar la reinstalación de los módulos de nodo.

Para garantizar que todos los archivos de la aplicación sean propiedad del usuario del nodo no raíz, incluido el contenido del directorio node_modules, cambie el usuario a node antes de ejecutar npm install:

...
USER node

Después de copiar las dependencias del proyecto y cambiar de usuario, podemos ejecutar npm install:

...
RUN npm install

A continuación, copie el código de su aplicación con los permisos adecuados en el directorio de la aplicación en el contenedor:

...
COPY --chown=node:node . .

Esto garantiza que los archivos de la aplicación sean propiedad del usuario no root.

Por último, configure el puerto 8080 en el contenedor e inicie la aplicación:

...
EXPOSE 8080
CMD [ "node", "app.js" ]

EXPOSE no expone el puerto, sino que sirve para documentar los puertos disponibles para el contenedor en tiempo de ejecución. CMD ejecuta el comando para iniciar la aplicación; en este caso, node app.js. Tenga en cuenta que solo debe haber un comando CMD por Dockerfile. Si incluye más de uno, solo se aplicará el último.

Hay muchas cosas que puedes hacer con un Dockerfile. Para obtener una lista completa de instrucciones, consulta la documentación de referencia de Dockerfiles.

El Dockerfile completo se ve así:

FROM node:10-alpine
RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app
WORKDIR /home/node/app
COPY package*.json ./
USER node
RUN npm install
COPY --chown=node:node . .
EXPOSE 8080
CMD [ "node", "app.js" ]

Guarda y cierra el archivo cuando hayas terminado de editar.

Antes de crear la imagen de la aplicación, agreguemos un archivo .dockerignore. De forma similar a un archivo .gitignore, .dockerignore especifica qué archivos y directorios del directorio del proyecto no deben copiarse en el contenedor.

Abra el archivo .dockerignore:

nano .dockerignore

Dentro del archivo, agregue los módulos del nodo local, los registros npm, el Dockerfile y el archivo .dockerignore:

node_modules
npm-debug.log
Dockerfile
.dockerignore

Si está trabajando con Git, también querrá agregar su directorio .git y el archivo .gitignore.

Guarda y cierra el archivo cuando hayas terminado.

Ya está listo para crear la imagen de su aplicación con el comando docker build. Usar la opción -t con docker build le permite etiquetar la imagen con un nombre fácil de recordar. Como vamos a subir la imagen a Docker Hub, incluyamos nuestro nombre de usuario de Docker Hub en la etiqueta. La etiquetaremos como nodejs-image-demo , pero puede reemplazarla con el nombre que prefiera. Recuerde también reemplazar your_dockerhub_username con su nombre de usuario de Docker Hub:

sudo docker build -t your_dockerhub_username/nodejs-image-demo .

. Especifica que el contexto para la construcción es el directorio actual.

Tomará uno o dos minutos crear la imagen. Una vez completada, revise sus imágenes:

sudo docker images

Obtendrás el siguiente resultado:

Output
REPOSITORY TAG IMAGE ID CREATED SIZE
your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 8 seconds ago 73MB
node 10-alpine f09e7c96b6de 3 weeks ago 70.7MB

Ahora podemos crear un contenedor con esta imagen usando docker run. Añadimos tres comandos con este comando:

  • -p: Esto publicará el puerto en el contenedor y lo asignará a un puerto en nuestro host. Usaremos el puerto 80 en el host, pero si otro proceso se está ejecutando en ese puerto, deberá cambiarlo si es necesario. Para más información sobre cómo funciona, consulte esta explicación sobre la vinculación de puertos en la documentación de Docker.
  • -d: ejecuta este contenedor en segundo plano.
  • --name: Esto nos permite darle al contenedor un nombre memorable.

Para crear el contenedor, ejecute el siguiente comando:

sudo docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

Una vez que su contenedor esté en funcionamiento, puede consultar una lista de sus contenedores en ejecución con docker ps:

sudo docker ps

Obtendrás el siguiente resultado:

Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e50ad27074a7 your_dockerhub_username/nodejs-image-demo "node app.js" 8 seconds ago Up 7 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

Mientras su contenedor se esté ejecutando, ahora puede visitar su aplicación navegando con su navegador a la IP de su servidor sin el puerto:

http://your_server_ip

La página de destino de su aplicación se cargará una vez más.


Ahora que ha creado una imagen para su aplicación, puede enviarla a Docker Hub para usarla en el futuro.

Paso 4 – Usar un repositorio para trabajar con imágenes

Al subir la imagen de tu aplicación a un registro como Docker Hub, la pones a disposición para su uso posterior al crear y escalar contenedores. Te mostraremos cómo hacerlo subiendo la imagen de tu aplicación a un repositorio y luego usándola para recrear tu contenedor.

El primer paso para enviar la imagen es iniciar sesión en la cuenta de Docker Hub que creó en los requisitos previos:

sudo docker login -u your_dockerhub_username

Cuando se te solicite, introduce la contraseña de tu cuenta de Docker Hub. Al iniciar sesión de esta manera, se creará un archivo ~/.docker/config.json en tu directorio de inicio de usuario con tus credenciales de Docker Hub.

Ahora puedes enviar la imagen de la aplicación a Docker Hub usando la etiqueta que creaste anteriormente, your_dockerhub_username/nodejs-image-demo:

sudo docker push your_dockerhub_username/nodejs-image-demo

Probemos la herramienta de registro de imágenes destruyendo nuestro contenedor de aplicación y la imagen actuales y reconstruyéndolos con la imagen en nuestro repositorio.

Primero, enumera tus contenedores en ejecución:

sudo docker ps

Obtendrás el siguiente resultado:

Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e50ad27074a7 your_dockerhub_username/nodejs-image-demo "node app.js" 3 minutes ago Up 3 minutes 0.0.0.0:80->8080/tcp nodejs-image-demo

Detenga el contenedor de la aplicación en ejecución usando el ID de contenedor que aparece en la salida. Asegúrese de reemplazar el ID resaltado a continuación con su propio ID de contenedor:

sudo docker stop e50ad27074a7

Enumere todas sus imágenes con -a:

docker images -a

Obtendrá el siguiente resultado con el nombre de su imagen, your_dockerhub_username/nodejs-image-demo, junto con la imagen del nodo y otras imágenes de su compilación:

Output
REPOSITORY TAG IMAGE ID CREATED SIZE
your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 7 minutes ago 73MB
<none> <none> 2e3267d9ac02 4 minutes ago 72.9MB
<none> <none> 8352b41730b9 4 minutes ago 73MB
<none> <none> 5d58b92823cb 4 minutes ago 73MB
<none> <none> 3f1e35d7062a 4 minutes ago 73MB
<none> <none> 02176311e4d0 4 minutes ago 73MB
<none> <none> 8e84b33edcda 4 minutes ago 70.7MB
<none> <none> 6a5ed70f86f2 4 minutes ago 70.7MB
<none> <none> 776b2637d3c1 4 minutes ago 70.7MB
node 10-alpine f09e7c96b6de 3 weeks ago 70.7MB

Detenga el contenedor y elimine todas las imágenes, incluidas las no utilizadas o las colgadas, con el siguiente comando:

docker system prune -a

Cuando se le solicite al salir que confirme que desea eliminar el contenedor y las imágenes detenidas, escriba Y. Tenga en cuenta que esto también eliminará su caché de compilación.

Has eliminado tanto el contenedor que ejecuta la imagen de tu aplicación como la propia imagen. Para obtener más información sobre cómo eliminar contenedores, imágenes y volúmenes de Docker, consulta Cómo eliminar imágenes, contenedores y volúmenes de Docker.

Con todas las imágenes y contenedores eliminados, ahora puedes extraer la imagen de la aplicación desde Docker Hub:

docker pull your_dockerhub_username/nodejs-image-demo

Enumere sus imágenes una vez más:

docker images

Su salida tendrá una imagen de su aplicación:

Output
REPOSITORY TAG IMAGE ID CREATED SIZE
your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 11 minutes ago 73MB

Ahora puedes reconstruir tu contenedor usando el comando del paso 3:

docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

Enumere sus contenedores en ejecución:

docker ps
Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6bc2f50dff6 your_dockerhub_username/nodejs-image-demo "node app.js" 4 seconds ago Up 3 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

Visita http://your_server_ip una vez más para ver tu aplicación en ejecución.

Resultado

En este tutorial, creaste una aplicación web estática con Express y Bootstrap, así como una imagen de Docker para la aplicación. Usaste esta imagen para crear un contenedor y la subiste a Docker Hub. Desde allí, pudiste destruir la imagen y el contenedor y recrearlos usando tu repositorio de Docker Hub.

En este artículo:
,
Artículo escrito por:
Seguir
Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Artículo anterior
Artículo siguiente
También te puede gustar