Docker
Ejecutando la aplicación Node.js simple

Ejecutar una aplicación Node.js básica dentro de un contenedor

El ejemplo que voy a discutir asume que tienes una instalación de Docker que funciona en tu sistema y una comprensión básica de cómo trabajar con Node.js. Si sabe cómo debe trabajar con Docker, debería ser evidente que el marco Node.js no necesita estar instalado en su sistema, sino que estaríamos usando la latest versión de la imagen de node disponible en Docker. Por lo tanto, si es necesario, puede descargar la imagen de antemano con el comando docker pull node . (El comando pulls automáticamente la última versión de la imagen del node desde la ventana acoplable).

1. Proceda a hacer un directorio donde residan todos sus archivos de aplicación de trabajo. Cree un archivo package.json en este directorio que describa su aplicación, así como las dependencias. El archivo package.json debería tener este aspecto:

    {
      "name": "docker_web_app",
      "version": "1.0.0",
      "description": "Node.js on Docker",
      "author": "First Last <[email protected]>",
      "main": "server.js",
      "scripts": {
        "start": "node server.js"
      },
      "dependencies": {
        "express": "^4.13.3"
      }
    }
   

2. Si necesitamos trabajar con Node.js, generalmente creamos un archivo de server que define una aplicación web. En este caso, utilizamos el framework Express.js (versión 4.13.3 adelante). Un archivo server.js básico se vería así:

    var express = require('express');
    var PORT = 8080;
    var app = express();
    app.get('/', function (req, res) {
      res.send('Hello world\n');
    });
    
    app.listen(PORT);
    console.log('Running on http://localhost:' + PORT);
   

3. Para aquellos familiarizados con Docker, Dockerfile encontrado un Dockerfile . Un Dockerfile es un archivo de texto que contiene todos los comandos necesarios para crear una imagen personalizada que se adapte a su aplicación.

Cree un archivo de texto vacío llamado Dockerfile en el directorio actual. El método para crear uno es sencillo en Windows. En Linux, es posible que desee ejecutar touch Dockerfile en el directorio que contiene todos los archivos necesarios para su aplicación. Abra el Dockerfile con cualquier editor de texto y agregue las siguientes líneas:

FROM node:latest
RUN mkdir -p /usr/src/my_first_app
WORKDIR /usr/src/my_first_app
COPY package.json /usr/src/my_first_app/
RUN npm install
COPY . /usr/src/my_first_app
EXPOSE 8080

• FROM node:latest instruye al demonio Docker desde qué imagen queremos construir. En este caso, utilizamos la latest versión del node imagen oficial de Docker disponible en Docker Hub .

• Dentro de esta imagen, procedemos a crear un directorio de trabajo que contiene todos los archivos necesarios y le indicamos al demonio que establezca este directorio como el directorio de trabajo deseado para nuestra aplicación. Para esto sumamos

    RUN mkdir -p /usr/src/my_first_app
    WORKDIR /usr/src/my_first_app
  

• Luego procedemos a instalar las dependencias de la aplicación moviendo primero el archivo package.json (que especifica la información de la aplicación, incluidas las dependencias) al directorio de trabajo /usr/src/my_first_app en la imagen. Hacemos esto por

    COPY package.json /usr/src/my_first_app/
    RUN npm install 
  

• Luego COPY . /usr/src/my_first_app para agregar todos los archivos de la aplicación y el código fuente al directorio de trabajo en la imagen.

• Luego, usamos la directiva EXPOSE para indicar al demonio que haga visible el puerto 8080 del contenedor resultante (a través de una asignación de contenedor a host), ya que la aplicación se enlaza con el puerto 8080 .

• En el último paso, le indicamos al demonio que ejecute el comando node server.js dentro de la imagen ejecutando el comando de npm start básico. Usamos la directiva CMD para esto, que toma los comandos como argumentos.

    CMD [ "npm", "start" ] 
  

4. Luego, creamos un archivo .dockerignore en el mismo directorio que Dockerfile para evitar que nuestra copia de node_modules y registros utilizados por nuestra instalación del sistema Node.js se copie en la imagen de Docker. El archivo .dockerignore debe tener el siguiente contenido:

    node_modules
    npm-debug.log
   

5. Construye tu imagen

Navegue hasta el directorio que contiene el Dockerfile y ejecute el siguiente comando para crear la imagen de Docker. La marca -t te permite etiquetar tu imagen para que sea más fácil encontrarla más tarde con el comando de imágenes acoplables:

    $ docker build -t <your username>/node-web-app .

Su imagen ahora será listada por Docker. Ver imágenes usando el siguiente comando:

$ docker images

REPOSITORY                      TAG        ID              CREATED
node                            latest     539c0211cd76    10 minutes ago
<your username>/node-web-app    latest     d64d3505b0d2    1 minute ago

6. Corriendo la imagen

Ahora podemos ejecutar la imagen que acabamos de crear utilizando el contenido de la aplicación, la imagen base del node y el Dockerfile . Ahora procedemos a ejecutar nuestra imagen recién creada <your username>/node-web-app . Al proporcionar el interruptor -d al comando de docker run la docker run ejecuta el contenedor en modo separado, de modo que el contenedor se ejecuta en segundo plano. La bandera -p redirige un puerto público a un puerto privado dentro del contenedor. Ejecuta la imagen que creaste previamente usando este comando:

$ docker run -p 49160:8080 -d <your username>/node-web-app

7. Imprima la salida de su aplicación ejecutando docker ps en su terminal. La salida debe verse algo como esto.

    CONTAINER ID        IMAGE                         COMMAND             CREATED             STATUS              PORTS                     NAMES
    7b701693b294      <your username>/node-web-app   "npm start"         20 minutes ago       Up 48 seconds       0.0.0.0:49160->8080/tcp   loving_goldstine
   

Obtenga la salida de la aplicación ingresando los docker logs <CONTAINER ID> En este caso se trata de docker logs 7b701693b294 .

Salida: Running on http://localhost:8080

8. Desde la salida de la 0.0.0.0:49160->8080/tcp docker ps , la asignación de puertos obtenida es 0.0.0.0:49160->8080/tcp . Por lo tanto, Docker asignó el puerto 8080 dentro del contenedor al puerto 49160 en la máquina host. En el navegador ahora podemos ingresar localhost:49160 .

También podemos llamar a nuestra aplicación usando curl :

$ curl -i localhost:49160

HTTP/1.1 200 OK
X-Powered-By: Express
Content-Type: text/html; charset=utf-8
Content-Length: 12
Date: Sun, 08 Jan 2017 14:00:12 GMT
Connection: keep-alive

Hello world