Docker
Esecuzione di semplice applicazione Node.js

Esecuzione di un'applicazione Node.js di base in un contenitore

L'esempio che ho intenzione di discutere presuppone che tu abbia un'installazione Docker che funziona nel tuo sistema e una conoscenza di base su come lavorare con Node.js. Se sei a conoscenza di come devi lavorare con Docker, dovrebbe essere evidente che il framework Node.js non deve essere installato sul tuo sistema, piuttosto dovremmo usare l' latest versione dell'immagine del node disponibile da Docker. Quindi, se necessario, è possibile scaricare l'immagine in anticipo con il comando comando di docker pull node . (Il comando pulls automaticamente l'ultima versione dell'immagine del node dalla finestra mobile.)

1. Procedere alla creazione di una directory in cui risiedono tutti i file dell'applicazione in uso. Creare un file package.json in questa directory che descrive l'applicazione e le dipendenze. Il tuo file package.json dovrebbe assomigliare a questo:

    {
      "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. Se abbiamo bisogno di lavorare con Node.js di solito creiamo un file server che definisce un'applicazione web. In questo caso utilizziamo il framework Express.js (versione 4.13.3 poi). Un file server.js base sarebbe simile a questo:

    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. Per chi ha familiarità con Docker, ti verrebbe in mente un file Dockerfile . Un Dockerfile è un file di testo che contiene tutti i comandi necessari per creare un'immagine personalizzata che è fatta su misura per la tua applicazione.

Crea un file di testo vuoto chiamato Dockerfile nella directory corrente. Il metodo per crearne uno è semplice in Windows. In Linux, è possibile eseguire il touch Dockerfile nella directory contenente tutti i file necessari per la propria applicazione. Apri il Dockerfile con qualsiasi editor di testo e aggiungi le seguenti linee:

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 istruisce il daemon Docker da quale immagine vogliamo costruire. In questo caso utilizziamo l' latest versione del node immagine Docker ufficiale disponibile da Docker Hub .

• All'interno di questa immagine procediamo a creare una directory di lavoro che contenga tutti i file richiesti e chiediamo al demone di impostare questa directory come directory di lavoro desiderata per la nostra applicazione. Per questo aggiungiamo

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

• Procederemo quindi all'installazione delle dipendenze dell'applicazione spostando prima il file package.json (che specifica le informazioni sull'app incluse le dipendenze) nella /usr/src/my_first_app nell'immagine. Lo facciamo da

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

• Quindi COPY . /usr/src/my_first_app per aggiungere tutti i file dell'applicazione e il codice sorgente alla directory di lavoro nell'immagine.

• Quindi usiamo la direttiva EXPOSE per istruire il daemon a rendere visibile la porta 8080 del contenitore risultante (tramite una mappatura da contenitore a host) poiché l'applicazione si collega alla porta 8080 .

• Nell'ultimo passaggio, chiediamo al daemon di eseguire il comando node server.js all'interno dell'immagine eseguendo il comando di base npm start . Usiamo la direttiva CMD per questo, che accetta i comandi come argomenti.

    CMD [ "npm", "start" ] 
  

4. Creiamo quindi un file .dockerignore nella stessa directory del Dockerfile per impedire che la nostra copia di node_modules e log utilizzati dall'installazione del nostro sistema Node.js vengano copiati sull'immagine Docker. Il file .dockerignore deve avere il seguente contenuto:

    node_modules
    npm-debug.log
   

5. Costruisci la tua immagine

Passare alla directory che contiene il Dockerfile ed eseguire il seguente comando per creare l'immagine Docker. Il flag -t ti consente di taggare la tua immagine in modo che sia più facile da trovare in seguito utilizzando il comando immagini docker:

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

L'immagine verrà ora elencata da Docker. Guarda le immagini usando il comando seguente:

$ docker images

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

6. Esecuzione dell'immagine

Ora possiamo eseguire l'immagine appena creata utilizzando i contenuti dell'applicazione, l'immagine base del node e il Dockerfile . Ora procediamo con la nostra nuova immagine <your username>/node-web-app . Fornendo l' -d al comando di docker run della docker run , il contenitore viene eseguito in modalità indipendente, in modo che il contenitore docker run eseguito in background. Il flag -p reindirizza una porta pubblica a una porta privata all'interno del contenitore. Esegui l'immagine creata in precedenza utilizzando questo comando:

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

7. Stampa l'output della tua app eseguendo la docker ps sul tuo terminale. L'output dovrebbe essere simile a questo.

    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
   

Ottieni l'output dell'applicazione inserendo i docker logs <CONTAINER ID> . In questo caso si tratta dei docker logs 7b701693b294 .

Uscita: in Running on http://localhost:8080

8. docker ps , la mappatura delle porte ottenuta è 0.0.0.0:49160->8080/tcp . Quindi Docker ha mappato la porta 8080 all'interno del contenitore alla porta 49160 sul computer host. Nel browser possiamo ora inserire localhost:49160 .

Possiamo anche chiamare la nostra app 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