Node.js

Node.js est une plateforme logicielle open-source qui permet d'exécuter du code JavaScript côté serveur. Il utilise le moteur JavaScript V8 de Google Chrome pour exécuter le code, ce qui le rend extrêmement performant. Node.js est largement utilisé pour développer des applications web en temps réel, des API REST, des outils de ligne de commande et bien plus encore.

Pour illustrer une application Node.js, prenons l'exemple disponible sur ce lien. Cette application est une simple application web qui utilise le framework Express.js pour servir des pages web statiques et gérer les routes.

Dockerfile

Un Dockerfile est un fichier texte sans format qui contient toutes les instructions commandées par l'utilisateur pour créer une image Docker. En d'autres termes, les Dockerfiles sont comme des scripts shell automatisés qui contiennent des commandes pour assembler une image Docker qui peut ensuite être utilisée pour créer des conteneurs Docker.

Les Dockerfiles commencent généralement par définir une image de base à partir de laquelle ils construisent. Cela est généralement une image de système d'exploitation qui est ensuite modifiée pour inclure des dépendances supplémentaires et des configurations nécessaires pour l'application que vous essayez de contenir.

Par exemple, si vous avez une application Node.js, votre Dockerfile commencera probablement par une image de base qui a Node.js installé.

Les Dockerfiles utilisent une série de commandes pour définir et créer l'image Docker. Certaines des commandes les plus courantes incluent :

• FROM : Définit l'image de base à partir de laquelle vous construisez
• RUN : Exécute une commande, utile pour installer des packages sur l'image
• COPY et ADD : Copie des fichiers de votre système de fichiers local dans l'image Docker
• WORKDIR : Définit le répertoire de travail pour les instructions suivantes
• CMD : Fournit des valeurs par défaut qui peuvent être exécutées lors de l'exécution de l'image Docker

Voici un exemple de Dockerfile optimisé pour une application Node.js :

# Définir une variable d'argument pour spécifier la version de Node.js à utiliser
ARG NODE_VERSION=12.2.0-slim

# Utiliser l'image Node.js spécifiée par la variable d'argument
FROM node:$NODE_VERSION AS builder
ARG NPM_ARGS
ENV NPM_ARGS=${NPM_ARGS}

# Create user, <http://redhatgov.io/workshops/security_containers/exercise1.2/>
# Créer un nouvel utilisateur et un nouveau groupe pour exécuter notre application
# C'est une bonne pratique pour la sécurité, car cela évite d'exécuter l'application en tant que root
RUN groupadd -r nodejs -g 433 && \\
    useradd -u 431 -r -g nodejs -s /sbin/nologin -c "Docker image user" nodejs

# Créer un répertoire pour l'application et on change la propriété de ce répertoire à notre nouvel utilisateur
RUN mkdir /home/nodejs && \\
    chown -R nodejs:nodejs /home/nodejs

# Changer l'utilisateur courant à notre nouvel utilisateur
USER nodejs

# Créer et définir un répertoire pour l'application
WORKDIR /home/nodejs

# Copier le package.json et le package-lock-json
COPY --chown=nodejs:nodejs package*.json ./

# Installer les dépendances
RUN npm install --only=production

# Copier le reste du code de l'application
COPY --chown=nodejs:nodejs . .

# Construire l'application
RUN npm run build

# Créer une nouvelle image à partir de l'image de base Node.js
FROM node:$NODE_VERSION

WORKDIR /home/nodejs

# Copier les dépendances et le code construit depuis l'image builder
COPY --from=builder --chown=nodejs:nodejs /home/nodejs .

# Exposer le port sur lequel l'application va s'exécuter
EXPOSE 8080

# Définir la commande pour démarrer l'application
CMD ["npm", "start"]

• L’instruction ARG NODE_VERSION définit une variable NODE_VERSION qui est utilisée pour spécifier la version de l'image Node.js à utiliser. Dans cet exemple, nous utilisons la version 12.2.0-slim.
• FROM définit l'image de base à utiliser pour les étapes suivantes. Dans cet exemple, nous utilisons l'image Node.js spécifiée par la variable NODE_VERSION.
• L'instruction AS dans FROM node:$NODE_VERSION AS builder est utilisée pour nommer une étape de construction. Dans ce cas, l'étape de construction est nommée builder. Cette étape est utilisée pour construire l'application et ses dépendances. En nommant cette étape, vous pouvez réutiliser les résultats de cette étape dans des étapes ultérieures. Par exemple, vous pouvez copier les fichiers de cette étape dans une autre étape avec l'instruction COPY --from=builder.
• Les instructions ARG et ENV sont utilisées pour définir des variables d'environnement qui peuvent être utilisées dans les instructions suivantes.
• COPY copie les fichiers package.json et package-lock.json dans notre image. Ces fichiers sont nécessaires pour installer les dépendances de notre application.
• L'option --chown=nodejs:nodejs dans l'instruction COPY est utilisée pour changer la propriété des fichiers copiés. Dans ce cas, les fichiers sont copiés avec l'utilisateur nodejs et le groupe nodejs comme propriétaires. C'est une bonne pratique pour la sécurité, car cela évite que les fichiers soient copiés avec l'utilisateur root comme propriétaire, ce qui pourrait présenter des risques de sécurité.