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

Dans cet article, nous allons essayer de créer une application Node.js sans état et de la dockeriser, ce qui rendra notre environnement de développement propre et efficace. En cours de route, nous explorerons les avantages de l’hébergement de conteneurs sur des plateformes comme 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é.

Créer une application Node.js

Si vous êtes novice en matière de code, Node.js est une plate-forme basée 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 manière.

É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 nommé « 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 le code, le rendant disponible à l’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. Il 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 pour 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 superbe 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é précédemment.

Maintenant, lancez 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 horizontalement 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 des échecs car il n’y a pas d’état de session à perdre ou à récupérer.

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

Dockeriser 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 nommé 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 à l’intérieur du 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 déposer.
• 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 l’application à leur infrastructure de manière transparente.
• CMD [ "node", "app.js" ]
  Cette ligne spécifie la commande à exécuter au démarrage du conteneur Docker. Dans ce cas, il exécute la commande node avec app.js comme argument, ce qui démarrera 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

Construisons maintenant 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

Décomposons cela parce que -p 3000:3000 chose peut sembler déroutante. Voici 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 le 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 au port 3000. Le premier numéro de port est le numéro de port de la machine hôte (le 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 mappée au port 3000 sur le récipient, puis localhost:1234 indiquera container:3000 et nous aurons toujours 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 construire.

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 5713 du conteneur sur le port 8080 de l’hôte et définit la variable d’environnement PORT sur 5713 à l’intérieur du conteneur.

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

Plus d’avantages frappants de Dockerizing 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 ayez 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 regroupée dans votre conteneur, garantissant un comportement cohérent dans tous les environnements.

Gestion facile des versions d’applications

Docker vous permet de baliser et de versionner vos images d’application, ce qui simplifie le retour aux versions précédentes ou le déploiement de différentes versions en parallèle. Par exemple, si vous souhaitez créer une nouvelle version de votre application, vous pouvez la baliser à l’aide de 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 définir 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 node apps, nous pouvons éliminer toute une classe de problèmes de «fonctionnement sur ma machine» tout en améliorant la réutilisabilité, la testabilité et la portabilité de nos applications Node.js. 🎉

Hébergement de conteneurs avec Kinsta

Maintenant que notre application Node.js sans état est dockerisée, 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 inscrivez-vous à votre compte Kinsta.
2. À partir de là, vous devriez être dans votre tableau de bord.
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 dépôt contenant le code que vous souhaitez déployer, ainsi que définir quelques détails de base comme 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 repo 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 construire et déployer notre application, et nous fournir un lien public et sécurisé à partir duquel elle est accessible. Notre application est maintenant publiée sur le web !

Conclusion

Dans ce didacticiel, nous avons créé une application Node.js et l’avons dockerisée, ce qui facilite son déploiement dans divers environnements. Nous avons également exploré les avantages de l’architecture sans état et abordé quelques excellents choix pour l’hébergement de conteneurs, comme Kinsta.

(yk, il)