Développement d'applications NodeJS basées sur Docker_node.js

À propos de cette application Node

Cette application contient un fichier package.json, server.js et un fichier .gitignore, qui sont suffisamment simples pour être utilisés du bout des doigts.

.gitignore

node_modules/*

package.json

{
 "name": "docker-dev",
 "version": "0.1.0",
 "description": "Docker Dev",
 "dependencies": {
  "connect-redis": "~1.4.5",
  "express": "~3.3.3",
  "hiredis": "~0.1.15",
  "redis": "~0.8.4"
 }
}

serveur.js

var express = require('express'),
 app = express(),
 redis = require('redis'),
 RedisStore = require('connect-redis')(express),
 server = require('http').createServer(app);

app.configure(function() {
 app.use(express.cookieParser('keyboard-cat'));
 app.use(express.session({
  store: new RedisStore({
   host: process.env.REDIS_HOST || 'localhost',
   port: process.env.REDIS_PORT || 6379,
   db: process.env.REDIS_DB || 0
  }),
  cookie: {
   expires: false,
   maxAge: 30 * 24 * 60 * 60 * 1000
  }
 }));
});

app.get('/', function(req, res) {
 res.json({
 status: "ok"
 });
});

var port = process.env.HTTP_PORT || 3000;
server.listen(port);
console.log('Listening on port ' + port);

server.js extraira toutes les dépendances et démarrera une application spécifique. Cette application spécifique est configurée pour stocker les informations de session dans Redis et exposer un point de terminaison de requête, qui renverra un statut JSON dans le message de réponse.

Une chose à noter est que les informations de connexion pour Redis peuvent être remplacées à l'aide de variables d'environnement - cela s'avérera utile plus tard lors de la migration de l'environnement de développement dev vers l'environnement de production prod.

Fichier Docker

Pour les besoins de développement, nous laisserons Redis et Node s'exécuter dans le même conteneur. Pour ce faire, nous utiliserons un Dockerfile pour configurer ce conteneur.

Fichier Docker

FROM dockerfile/ubuntu

MAINTAINER Abhinav Ajgaonkar <abhinav316@gmail.com>

# Install Redis
RUN  \
 apt-get -y -qq install python redis-server

# Install Node
RUN  \
 cd /opt && \
 wget http://nodejs.org/dist/v0.10.28/node-v0.10.28-linux-x64.tar.gz && \
 tar -xzf node-v0.10.28-linux-x64.tar.gz && \
 mv node-v0.10.28-linux-x64 node && \
 cd /usr/local/bin && \
 ln -s /opt/node/bin/* . && \
 rm -f /opt/node-v0.10.28-linux-x64.tar.gz

# Set the working directory
WORKDIR  /src

CMD ["/bin/bash"]

Comprenons-le ligne par ligne,

À PARTIR du fichier docker/ubuntu
Cette fois, dites à Docker d'utiliser l'image dockerfile/ubuntu fournie par Docker Inc. comme image de base pour la construction.

COURIR
apt-get -y -qq installer python redis-server
L'image de base ne contient absolument rien - nous devons donc utiliser apt-get pour obtenir tout ce dont nous avons besoin pour faire fonctionner l'application. Cela installe Python et le serveur Redis est requis car nous y stockerons les informations de session. et la nécessité de python est l'extension C requise par npm qui peut être construite en tant que module de nœud Redis.

RUN \
 cd /opt && \
 wget http://nodejs.org/dist/v0.10.28/node-v0.10.28-linux-x64.tar.gz && \
 tar -xzf node-v0.10.28-linux-x64.tar.gz && \
 mv node-v0.10.28-linux-x64 node && \
 cd /usr/local/bin && \
 ln -s /opt/node/bin/* . && \
 rm -f /opt/node-v0.10.28-linux-x64.tar.gz

Cela téléchargera et extraira les binaires NodeJS 64 bits.

WORKDIR /src

Cette phrase indiquera à Docker qu'une fois le conteneur démarré, avant d'exécuter la chose spécifiée par l'attribut CMD, faites un cd /src.

CMD ["/bin/bash"]

En guise d'étape finale, exécutez /bin/bash.

Créer et exécuter le conteneur

Maintenant que le fichier Docker est écrit, créons une image Docker.

docker build -t sqldump/docker-dev:0.1 .

Une fois l'image construite, nous pouvons exécuter un conteneur en utilisant l'instruction suivante :

docker run -i -t --rm \
      -p 3000:3000 \
      -v `pwd`:/src \
      sqldump/docker-dev:0.1

Jetons un coup d'œil à ce qui se passe dans la commande docker run.

-i démarrera le conteneur en mode interactif (contre -d en mode détaché). Cela signifie qu'une fois la session interactive terminée, le conteneur se fermera.

-t attribuera un pseudo-tty.

--rm supprimera le conteneur et son système de fichiers à la sortie.

-p 3000:3000 transférera le port 3000 de l'hôte vers le port 3000 du conteneur.

-v `pwd`:/src
Cette phrase montera le répertoire de travail actuel sur /src dans le conteneur sur l'hôte (par exemple, notre fichier de projet. Nous monterons le répertoire actuel en tant que volume au lieu d'utiliser la commande ADD dans le Dockerfile, nous ferons donc toutes les modifications apportées). dans l'éditeur de texte sont immédiatement visibles dans le conteneur.

sqldump/docker-dev:0.1 est le nom et la version de l'image Docker à exécuter – c'est le même nom et la même version que nous avons utilisés pour créer l'image Docker.

Puisque le Dockerfile spécifie CMD ["/bin/bash"], dès que le conteneur sera démarré, nous nous connecterons à un environnement shell bash si la commande docker run est exécutée avec succès, elle ressemblera à ce qui suit. :

Commencer le développement

Maintenant que le conteneur est en cours d'exécution, avant de commencer à écrire du code, nous devrons régler certaines choses standard non liées à Docker. Tout d'abord, utilisez l'instruction suivante pour démarrer le serveur Redis dans le conteneur :

service redis-server start

Ensuite, installez les dépendances du projet et nodemon observera les modifications dans le fichier du projet et redémarrera le serveur le cas échéant.

npm install
npm install -g nodemon

Enfin, démarrez le serveur à l'aide de la commande suivante :

nodemon server.js

Maintenant, si vous accédez à http://localhost:3000 dans votre navigateur, vous devriez voir quelque chose comme ceci :

Ajoutons un autre point de terminaison à Server.js pour simuler le processus de développement :

app.get('/hello/:name', function(req, res) {
 res.json({
  hello: req.params.name
 });
});

Vous verrez que nodemon a détecté les modifications que vous avez apportées et redémarré le serveur :

Maintenant, si vous naviguez dans votre navigateur jusqu'à http://localhost:3000/hello/world, vous verrez la réponse suivante :

Environnement de production

L'état actuel du conteneur est loin d'être publié en tant que produit. Les données dans Redis ne resteront plus persistantes lors des redémarrages du conteneur. Par exemple, si vous redémarrez le conteneur, toutes les données de session seront effacées. Cela se produit lorsque vous détruisez le conteneur et en démarrez un nouveau, ce qui n'est évidemment pas ce que vous voulez. Je parlerai de cette problématique dans la deuxième partie du contenu de la productisation.