Construire et dockeriser une application Node.js sans état avec l’aide de Kinsta — Smashing Magazine

Dans cet article, nous allons essayer de créer une application Node.js sans état et de la dockeriser, rendant notre environnement de développement propre et efficace. En cours de route, nous explorerons les avantages de l’hébergement de conteneurs sur des plates-formes telles que Kinsta, qui offre un environnement d’hébergement géré tout en prenant en charge les conteneurs Docker, ainsi que l’hébergement d’applications et de bases de données, permettant aux utilisateurs de déployer et de faire évoluer leurs applications avec plus de flexibilité et de facilité. .

Construire une application Node.js

Si vous débutez dans le codage, Node.js est une plate-forme construite sur le moteur JavaScript de Chrome qui permet aux développeurs de créer des applications côté serveur à l’aide de JavaScript. Il est populaire pour sa légèreté, ses performances efficaces et ses capacités asynchrones.

Les applications sans état ne stockent aucune information sur la session de l’utilisateur, offrant un moyen propre et efficace de gérer vos applications. Explorons comment créer une application Node.js de cette façon.

Étape 1 – Initialiser le projet Node.js

Tout d’abord, créez un nouveau répertoire et accédez-y :

mkdir smashing-app && cd smashing-app

Ensuite, initialisez un nouveau projet Node.js :

npm init -y

Étape 2 : Installer Express

Express est un cadre d’application Web Node.js minimal et flexible qui fournit un ensemble robuste de fonctionnalités pour les applications Web et mobiles. Installez Express avec la commande suivante :

npm install express

Étape 3 – Créez votre application sans état

Créez un nouveau fichier appelé « app.js » et ajoutez le code suivant :

const express = require("express");
const app = express();
const port = process.env.PORT || 3000;
app.get("/", (req, res) => {
  res.send("Welcome to our smashing stateless Node.js app!");
});
app.listen(port, () => {
  console.log(`Smashing app listening at http://localhost:${port}`);
});

Explorons un peu cela. Voici ce que fait chaque ligne :

• const express = require("express");
  Cette ligne importe le framework Express.js dans votre code, le rendant disponible pour utilisation.
• const app = express();
  Cette ligne crée une instance du framework Express.js appelée app. Cette instance d’application est l’endroit où nous définissons nos routes et configurations de serveur.
• const port = process.env.PORT || 3000;
  Cette ligne définit le numéro de port du serveur. Recherche un numéro de port défini dans une variable d’environnement appelée PORT. Si cette variable n’est pas définie, la valeur par défaut est le port 3000.
• app.get("/", (req, res) => {}
  Cette ligne définit une route vers le serveur lorsqu’une requête GET est faite à l’URL racine (« / »).
• res.send("Welcome to our smashing stateless Node.js app!");
  Cette ligne envoie la chaîne « Bienvenue dans notre application Node.js sans état ! » en réponse à la requête GET adressée à l’URL racine.
• app.listen(port, () => {})
  Cette ligne démarre le serveur et écoute sur le numéro de port spécifié ci-dessus.

Exécutez maintenant l’application avec :

node app.js

Votre application Node.js s’exécute maintenant sur http://localhost:3000.

Architecture sans état

L’architecture sans état signifie que le serveur ne stocke aucune information sur la session de l’utilisateur, ce qui présente plusieurs avantages :

• évolutivité
  Les applications sans état peuvent facilement évoluer en ajoutant plus d’instances sans se soucier des données de session.
• Simplicité
  Sans données de session à gérer, la logique d’application devient plus simple et plus facile à maintenir.
• Tolérance aux pannes
  Les applications sans état peuvent récupérer rapidement après des échecs car il n’y a pas d’état de session à perdre ou à récupérer.

Ok, nous avons donc notre serveur Node.js exécuté localement, mais comment pouvons-nous le conditionner pour que tout le monde puisse l’exécuter ? Même les personnes qui n’ont pas installé Node.js et l’exécutent sur n’importe quelle plate-forme ? C’est là qu’intervient Docker.

Dockérisation de l’application

Docker est un outil qui aide les développeurs à créer, expédier et exécuter des applications dans un environnement conteneurisé. Il simplifie le processus de déploiement d’applications sur différentes plateformes et environnements.

Étape 1 : Installer Docker

Tout d’abord, assurez-vous que Docker est installé sur votre machine. Vous pouvez le télécharger ici.

Étape 2 : Créer un Dockerfile

Créez un nouveau fichier appelé Dockerfile dans votre répertoire de projet et ajoutez le code suivant :

FROM node:18-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
ENV PORT=3000
CMD [ "node", "app.js" ]

Encore une fois, regardons ce que cela fait un peu plus en détail :

• FROM node:18-alpine
  Cette ligne spécifie l’image de base pour cette image Docker. Dans ce cas, il s’agit de l’image officielle Node.js Docker basée sur la distribution Alpine Linux. Cela donne Node.js au conteneur Docker, qui est comme une « machine virtuelle » mais plus léger et plus efficace.
• WORKDIR /usr/src/app
  Cette ligne définit le répertoire de travail dans le conteneur Docker sur /usr/src/app.
• COPY . .
  Cette ligne copie tous les fichiers du répertoire local vers le répertoire de travail dans le conteneur Docker.
• RUN npm install
  Cette ligne installe les dépendances spécifiées dans le package.json archive.
• ENV PORT=3000
  En utilisant cette directive, nous rendons l’application plus configurable en utilisant la variable d’environnement PORT. Cette approche offre de la flexibilité et permet aux hébergeurs comme Kinsta de connecter de manière transparente l’application à leur infrastructure.
• CMD [ "node", "app.js" ]
  Cette ligne spécifie la commande à exécuter au démarrage du conteneur Docker. Dans ce cas, exécutez la commande node avec app.js comme argument, ce qui lancera l’application Node.js.

Ainsi, ce Dockerfile crée une image Docker qui configure un répertoire de travail, installe les dépendances, copie tous les fichiers dans le conteneur, expose le port 3000 et exécute l’application Node.js avec la commande node.

Étape 3 : Créer et exécuter le conteneur Docker

Maintenant, construisons ceci et exécutons-le localement pour nous assurer que tout fonctionne correctement.

docker build -t smashing-app

Lorsque cela réussit, nous exécuterons le conteneur :

docker run -p 3000:3000 smashing-app

Analysons cela parce que -p 3000:3000 les choses peuvent sembler confuses. C’est ce qui se passe :

1. docker run est une commande utilisée pour exécuter un conteneur Docker.
2. -p 3000:3000 est une option qui mappe le port 3000 dans un conteneur docker à mettre en communication 3000 sur la machine hôte. Cela signifie que le port du conteneur 3000 sera accessible depuis la machine hôte sur le port 3000. Le premier numéro de port est le numéro de port de la machine hôte (la nôtre) et le deuxième numéro de port est le numéro de port du conteneur.
3. nous pouvons avoir un port 1234 sur notre machine affectée au port 3000 dans le récipient puis localhost:1234 indiquera container:3000 et nous continuerons à avoir accès à l’application.
4. smashing-app est le nom de l’image Docker sur laquelle le conteneur est basé, celle que nous venons de créer.

Votre application Dockerized Node.js devrait maintenant s’exécuter sur http://localhost:3000.

Lors de l’exécution du conteneur Docker, nous pouvons également transmettre une valeur PORT personnalisée en tant que variable d’environnement :

docker run -p 8080:5713 -d -e PORT=5713 smashing-app

Cette commande mappe le port de conteneur 5713 sur le port hôte 8080 et définit la variable d’environnement PORT sur 5713 dans le conteneur.

L’utilisation de la variable d’environnement PORT dans le Dockerfile permet une plus grande flexibilité et adaptabilité lors du déploiement de votre application Node.js sur plusieurs fournisseurs d’hébergement, y compris Kinsta.

Autres avantages impressionnants de la dockerisation d’une application Node.js

Dockeriser une application Node.js apporte plusieurs avantages aux développeurs et au cycle de vie global de l’application. Voici quelques avantages clés supplémentaires avec des exemples de code :

Gestion simplifiée des dépendances

Docker vous permet d’encapsuler toutes les dépendances dans le conteneur lui-même, ce qui facilite la gestion et le partage entre les membres de l’équipe. Par exemple, supposons que vous disposiez d’un fichier package.json avec une version spécifique d’un package :

{
  "dependencies": {
    "lodash": "4.17.21"
  }
}

En l’incluant dans votre Dockerfile, la version spécifique de lodash est automatiquement installée et empaquetée dans votre conteneur, garantissant un comportement cohérent dans tous les environnements.

Contrôle facile de la version des applications

Docker vous permet de baliser et de versionner vos images d’application, ce qui facilite le retour aux versions précédentes ou le déploiement de différentes versions côte à côte. Par exemple, si vous souhaitez créer une nouvelle version de votre application, vous pouvez la taguer avec la commande suivante :

docker build -t smashing-app:v2 .

Vous pouvez ensuite exécuter plusieurs versions de votre application simultanément :

docker run -p 3000:3000 -d smashing-app:v1

docker run -p 3001:3000 -d smashing-app:v2

Variables d’environnement

Docker facilite la gestion des variables d’environnement, qui peuvent être transmises à votre application Node.js pour modifier son comportement en fonction de l’environnement (développement, staging, production). Par exemple, dans votre fichier app.js :

const express = require('express');
const app = express();
const port = process.env.PORT || 3000;
const env = process.env.NODE_ENV || 'development';
app.get('/', (req, res) => {
  res.send(`Welcome to our smashing stateless Node.js app running in ${env} mode!`);
});
app.listen(port, () => {
  console.log(`Smashing app listening at http://localhost:${port}`);
});

Dans votre Dockerfile, vous pouvez configurer le NODE_ENV variable:

FROM node:18-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
ENV NODE_ENV=production
CMD [ "node", "app.js" ]

Ou vous pouvez le transmettre lors de l’exécution du conteneur :

docker run -p 3000:3000 -d -e NODE_ENV=production smashing-app

Le TL ; DR de ceci est que grâce à Dockerizing les applications de nœud, nous pouvons éliminer toute une classe de problèmes « ça marche sur ma machine » tout en augmentant la réutilisabilité, la testabilité et la portabilité de nos applications Node.js. 🎉

Hébergement de conteneurs avec Kinsta

Maintenant que nous avons dockerisé notre application Node.js sans état, vous vous demandez peut-être où l’héberger. Kinsta est largement connu pour son hébergement d’applications et de bases de données. Explorons comment nous ferions cela avec Kinsta étape par étape.

1. Connectez-vous ou créez votre compte Kinsta.
2. À partir de là, vous devriez être sur votre tableau.
3. À l’aide de la barre latérale, accédez à Applications.
   

   

4. À partir de là, vous devriez pouvoir ajouter un service de type application.
5. Une fois que vous avez ajouté une application, vous serez invité à connecter votre compte GitHub à Kinsta afin que Kinsta puisse déployer automatiquement votre application lorsque des mises à jour lui seront envoyées.
6. Vous pouvez maintenant choisir le référentiel contenant le code que vous souhaitez déployer, ainsi que définir certains détails de base tels que le nom de l’application et les variables d’environnement.
   

   

7. Ensuite, nous spécifions l’environnement de construction de notre application. C’est ici que nous spécifions l’emplacement du Dockerfile dans notre référentiel que nous venons de créer.
8. Enfin, nous allouons des ressources informatiques pour notre conteneur, entrons nos informations de paiement, et nous sommes prêts à partir !

Kinsta va maintenant créer et déployer notre application et nous fournir un lien public sécurisé où elle sera accessible. Notre application est déjà publiée sur le web !

conclusion

Dans ce didacticiel, nous créons une application Node.js et la dockerisons, ce qui facilite son déploiement dans plusieurs environnements. Nous explorons également les avantages de l’architecture sans état et mentionnons quelques excellentes options pour l’hébergement de conteneurs, comme Kinsta.

(Oui oui)