Comment déployer une application Web Node.js ?
Node.js est un environnement d’exécution JavaScript qui permet d’exécuter du code JavaScript en dehors du navigateur.
Node.js s’appuie sur le moteur JavaScript Chrome V8 et propose un modèle d’E/S non bloquantes, pilotées par les événements, qui le rend très efficace pour la création d’applications côté serveur.
Dans cet article, vous explorerez les avantages et les limites de Node.js pour le développement d’applications côté serveur et les options de déploiement pour les applications Node.js.
De plus, vous allez construire, dockeriser et déployer une application Node.js sur Back4app Containers gratuitement.
Contents
- 1 Avantages de Node.js pour le développement d’applications web
- 2 Limites de Node.js pour le développement d’applications Web
- 3 Déployer une application Web Node.js
- 4 Déployer une application Node.js sur Back4app en utilisant les conteneurs Back4app
- 5 Conclusion
- 6 FAQ
- 7 Comment déployer une application Web Node.js ?
Avantages de Node.js pour le développement d’applications web
Depuis sa sortie en 2009, Node.js est un choix de premier ordre pour la création d’applications web côté serveur. En voici quelques raisons.
Efficacité et évolutivité
Comme indiqué précédemment, Node.js fonctionne sur le moteur V8 de Chrome, qui lui permet d’exécuter du code JavaScript. Ce moteur utilise la compilation Just-in-time (JIT) pour convertir le code JavaScript natif en code machine.
Lors de l’exécution, les composants Turbofan et Crankshaft du V8 analysent le code machine et le recompilent afin d’obtenir les meilleures performances possibles.
En outre, grâce au modèle événementiel de Node.js, il peut exécuter du code en réponse à des événements, tels que l’interaction de l’utilisateur, sans bloquer le fil d’exécution principal de l’application, ce qui en fait un outil idéal pour les applications à fort trafic.
L’architecture modulaire de Node.js et la prise en charge intégrée de la mise en grappe facilitent la mise à l’échelle des applications développées à l’aide de cette technologie. L’architecture modulaire de Node.js vous permet de diviser votre application en composants qui peuvent être mis à l’échelle indépendamment.
Le module cluster vous permet de créer plusieurs instances de votre application sur plusieurs cœurs ou serveurs. Cela permet une mise à l’échelle horizontale, où l’application peut être mise à l’échelle en ajoutant plus de serveurs au cluster.
Courbe d’apprentissage peu profonde
Node.js est basé sur JavaScript, un langage de programmation largement utilisé pour le développement web. L’utilisation de JavaScript dans Node.js a rendu le développement côté serveur avec Node.js plus accessible aux développeurs qui sont déjà familiers avec JavaScript.
Cela réduit la complexité du développement web et rationalise le processus de développement.
Grand écosystème
Node.js dispose d’une communauté importante et active de développeurs qui ont créé un vaste écosystème de modules et de paquets.
Le gestionnaire de paquets Node.js, npm, héberge plus d’un million de paquets que vous pouvez utiliser pour ajouter des fonctionnalités à vos applications.
Ces paquets peuvent aller de petites bibliothèques utilitaires comme lodash à de grands frameworks Nest.js qui peuvent être utilisés pour construire des applications web complexes.
La disponibilité d’un large éventail de modules et de paquets peut réduire de manière significative le temps et les efforts nécessaires au développement d’applications web.
Vous pouvez tirer parti de ces packages pour ajouter à vos applications des fonctionnalités telles que l’authentification, l’intégration de bases de données et le rendu côté serveur.
Limites de Node.js pour le développement d’applications Web
Lorsqu’il s’agit de développer des applications web, Node.js offre de nombreux avantages, tels que des performances efficaces, l’évolutivité et un vaste écosystème de modules et de paquets. Cependant, comme toute technologie, Node.js présente certaines limites. Voici quelques-unes de ces limites.
Grande consommation de mémoire
Node.js utilise un modèle d’E/S non bloquant, ce qui signifie qu’il peut traiter de nombreuses demandes simultanément sans créer de nouveaux threads. Cependant, chaque demande nécessite toujours l’allocation de mémoire pour son traitement.
Cela signifie que les applications Node.js peuvent consommer beaucoup de mémoire, surtout si elles traitent de nombreuses requêtes simultanées. Cela peut être un problème pour les applications fonctionnant sur des systèmes disposant d’une mémoire limitée.
Modèle de programmation asynchrone
Si le modèle de programmation asynchrone de Node.js est un avantage significatif, il peut aussi être une source de complexité pour les développeurs.
La programmation asynchrone exige une réflexion différente sur le déroulement du programme. Ce changement peut représenter un défi pour les développeurs habitués à la programmation synchrone.
En outre, la programmation asynchrone peut conduire à l’enfer des callbacks, une situation dans laquelle le code devient difficile à lire et à maintenir en raison de l’imbrication des callbacks.
Boucle d’événements à un seul fil
Node.js est conçu pour gérer les tâches à forte intensité d’E/S, telles que les communications réseau, les E/S de fichiers et les opérations de base de données.
Cependant, ce n’est peut-être pas le meilleur choix pour les tâches gourmandes en ressources processeur telles que les calculs complexes, le traitement des données ou l’apprentissage automatique.
En effet, Node.js utilise un modèle de boucle d’événements à un seul thread, ce qui signifie qu’il ne peut exécuter qu’une seule tâche à la fois.
Si une tâche prend beaucoup de temps à se terminer, elle peut bloquer la boucle d’événements et empêcher l’application de répondre.
Déployer une application Web Node.js
Il existe plusieurs façons de déployer une application Node.js. Explorons-en quelques-unes.
Services d’hébergement en nuage
Les services d’hébergement en nuage vous permettent de déployer votre application Node.js sur des serveurs gérés par des sociétés comme Amazon Web Services (AWS), Google Cloud Platform (GCP) ou Microsoft Azure.
Ils offrent des avantages tels que l’évolutivité, la disponibilité mondiale, la facilité de déploiement et la tarification à l’usage. En outre, ils s’intègrent à d’autres services en nuage tels que les bases de données et l’équilibrage de charge pour vous aider à créer de meilleures applications.
Il vous suffit de déployer votre application Node.js sur les serveurs du fournisseur de services en nuage pour utiliser les services d’hébergement en nuage. Vous pouvez ensuite accéder à votre application par l’intermédiaire d’un navigateur web ou d’une autre application client.
Voici quelques exemples de services d’hébergement en nuage pour Node.js :
- AWS Elastic Beanstalk
- GCP App Engine
- Microsoft Azure App Service
Ces plateformes facilitent le déploiement, la mise à l’échelle et la gestion de vos applications Node.js sans vous soucier de l’infrastructure sous-jacente.
De plus, ils offrent des fonctionnalités telles que la mise à l’échelle automatique, l’équilibrage de la charge et la surveillance intégrée pour vous aider à assurer le bon fonctionnement de votre application.
Serveurs privés virtuels (VPS)
Les serveurs privés virtuels (VPS) sont des machines virtuelles qui fonctionnent sur des serveurs physiques, ce qui vous permet d’installer et d’exécuter votre application Node.js comme si elle fonctionnait sur un serveur dédié.
Les serveurs privés virtuels vous offrent davantage de contrôle et d’options de personnalisation que l’hébergement partagé, tout en constituant une alternative plus rentable aux serveurs dédiés.
Pour utiliser un hébergement VPS pour votre application Node.js, choisissez un hébergeur proposant des images Node.js préconfigurées ou installez vous-même Node.js et les autres dépendances.
Voici quelques exemples de fournisseurs d’hébergement VPS pour Node.js :
- DigitalOcean
- Linode
- Vultr
Conteneurisation
La conteneurisation est une technique permettant de déployer et d’exécuter des applications dans un environnement conteneurisé qui les isole de l’infrastructure sous-jacente.
Les conteneurs constituent une alternative légère et flexible aux machines virtuelles traditionnelles, ce qui les rend idéaux pour le déploiement d’applications Node.js.
Ils sont portables, ce qui vous permet de créer et de tester des applications sur leurs machines locales, puis de les déployer sur n’importe quelle plateforme prenant en charge la conteneurisation.
Les conteneurs peuvent également être facilement augmentés ou réduits en fonction de la charge de travail, ce qui accroît l’évolutivité. Ils assurent la cohérence entre les différentes plateformes, ce qui facilite la gestion et la maintenance des applications.
Voici quelques exemples de plateformes qui proposent la conteneurisation en tant que service (CaaS) :
- Back4app Containers
- AWS ECS
- Azure ACI
- Google GKE
Déployer une application Node.js sur Back4app en utilisant les conteneurs Back4app
Back4app est une plateforme cloud qui vous permet de créer, gérer et déployer des applications web à l’aide d’une interface utilisateur intuitive ou de leur outil CLI complet. Back4app offre une gamme de services, dont la conteneurisation.
Les conteneurs Back4app éliminent le fossé entre le développement et la production en automatisant les tâches répétitives et en gérant votre infrastructure côté serveur, ce qui vous permet de ne pas avoir à vous soucier de DevOps.
Dans cet article, vous allez construire et déployer une application Node.js simple en utilisant les conteneurs Back4app. L’application Node.js que vous allez construire est une simple librairie API avec le support de la fonctionnalité CRUD (Créer, Lire, Mettre à jour, Supprimer).
Mise en place de l’environnement de développement
Créez un nouveau répertoire de projet et initialisez npm dans le répertoire de projet en exécutant la commande ci-dessous :
mkdir bookstoreapp && cd bookstoreapp && npm init -y
Ensuite, installez les dépendances nécessaires au projet en exécutant la commande ci-dessous :
npm install express dotenv mysql knex
Les dépendances que vous avez installées ci-dessus sont :
- Express.js : Express est un cadre Node.js qui simplifie le processus de développement d’applications Node.js.
- dotenv : dotenv est un paquetage npm que vous pouvez utiliser pour gérer vos variables environnementales.
- MySQL : La dépendance MySQL est le pilote Node.js pour MySQL, que vous utiliserez comme base de données pour cette application.
- Knex : Knex est un générateur de requêtes pour JavaScript. Vous aurez besoin de cette dépendance pour interagir avec votre base de données sans avoir à écrire des requêtes SQL brutes.
Ensuite, créez un fichier routes.js et un fichier index.js dans le répertoire racine de votre projet.
Ensuite, ajoutez le bloc de code ci-dessous à votre fichier index.js :
//index.js
require("dotenv").config();
const express = require("express");
const app = express();
const port = 3000;
const router = require("./routes.js");
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use("/", router);
app.listen(port, () => {
console.log(`App listening at ${port}`);
});
Le bloc de code ci-dessus crée un serveur Express et écoute les requêtes HTTP entrantes sur le port 3000. Il utilise des fonctions intermédiaires pour analyser les données entrantes et associe un routeur au chemin d’accès racine pour traiter les demandes entrantes.
Enfin, il démarre le serveur et affiche un message sur la console indiquant que le serveur est en cours d’exécution et qu’il écoute sur le port spécifié.
Ensuite, ajoutez un script de démarrage à votre fichier package.json. Par exemple :
"start": "node index.js",
Connexion à votre base de données
Knex nécessite un fichier knex contenant des options de configuration pour la connexion à une base de données.
Exécutez la commande ci-dessous pour créer un fichier knex :
knex init
Pour configurer Knex afin qu’il utilise MySQL, remplacez le contenu de votre fichier knexfile.js par le bloc de code ci-dessous :
// Update with your config settings.
require("dotenv").config()
/**
* @type { Object.<string, import("knex").Knex.Config> }
*/
module.exports = {
development: {
client: "mysql",
connection: {
host: process.env.DEV_HOST,
user: process.env.DEV_USER,
password: process.env.DEV_PASSWORD,
database: process.env.DEV_NAME,
},
migrations: {
directory: "./db/migrations",
}
},
production: {
client: "mysql",
connection: {
host: process.env.DB_HOST,
user: process.env.DB_USER,
password: process.env.DB_PASSWORD,
database: process.env.DB_NAME,
},
migrations: {
directory: "./db/migrations",
}
},
};
Ensuite, créez un dossier db dans le répertoire racine de votre projet et créez un fichier db.js.
Ajoutez le bloc de code ci-dessous à votre fichier db.js :
//db.js
const knex = require("knex");
const knexFile = require("../knexfile.js");
const environment = process.env.NODE_ENV || "development";
module.exports = knex(knexFile[environment]);
Le bloc de code ci-dessus définit la variable d’environnement sur la variable d’environnement NODE_ENV ou sur development si NODE_ENV n’est pas défini. Il vous permet ainsi de spécifier différentes configurations pour différents environnements, tels que le développement ou la production.
Création de fichiers de migration
Exécutez la commande ci-dessous pour créer des fichiers de migration pour votre base de données :
knex migrate:make bookstore
La commande ci-dessus crée un fichier de migration dans le chemin de fichier spécifié dans votre knexfile.js (“./db/migrations”).
Ensuite, ouvrez votre fichier de migration et remplacez le code qu’il contient par le bloc de code ci-dessous :
/**
* @param { import("knex").Knex } knex
* @returns { Promise<void> }
*/
exports.up = function (knex) {
return knex.schema.createTable("books", (table) => {
table.increments("id").primary();
table.string("title");
table.string("author");
table.string("genre");
table.timestamps(true, true);
});
};
/**
* @param { import("knex").Knex } knex
* @returns { Promise<void> }
*/
exports.down = function (knex) {
return knex.schema.dropTableIfExists("books");
};
Ensuite, lancez la commande ci-dessous pour exécuter le fichier de migration :
knex migrate:latest
Mise en œuvre du routage
Enfin, ajoutez le bloc de code ci-dessous à votre fichier routes.js :
const express = require("express");
const router = express.Router();
const db = require("./db/db.js");
// GET /books
router.get("/books", async (req, res) => {
try {
const books = await db("books");
res.json(books);
} catch (err) {
console.error(err);
res.status(500).send("Internal Server Error");
}
});
//POST /books/new
router.post("/books/new", async (req, res) => {
try {
const { title, author, genre } = req.body;
const book = await db("books").insert({
title,
author,
genre,
});
res.status(201).json(book);
} catch (err) {
console.error(err);
res.status(500).send("Internal Server Error");
}
});
//PUT /books/:id
router.put("/books/:id", async (req, res) => {
const { id } = req.params;
try {
const { title, author, genre } = req.body;
const book = await db("books").where({ id }).update(
{
title,
author,
genre,
},
["id", "title", "author", "genre"]
);
if (book.length !== 0) {
res.status(201).send(book);
} else {
res.status(404).json({ error: "Book not found" });
}
} catch (err) {
console.error(err);
res.status(500).send("Internal Server Error");
}
});
//DELETE /books/:id
router.delete("/books/:id", async (req, res) => {
const { id } = req.params;
try {
const book = await db("books").where({ id }).del();
if (book !== 0) {
res.status(200).json({ message: "Book deleted" });
} else {
res.status(404).json({ error: "Book not found" });
}
} catch (err) {
console.error(err);
res.status(500).send("Internal Server Error");
}
});
module.exports = router;
Le bloc de code ci-dessus définit plusieurs routes pour traiter les requêtes HTTP, notamment l’obtention de tous les livres, la création d’un nouveau livre, la mise à jour d’un livre existant et la suppression d’un livre.
Création d’un fichier Docker
Un Dockerfile est un fichier qui contient un ensemble d’instructions, écrites dans un format spécifique, sur la façon de construire une image Docker. Une image Docker est un instantané d’un conteneur qui comprend tout ce qui est nécessaire à l’exécution d’une application, comme le code de l’application, le moteur d’exécution, les bibliothèques et les outils système.
Pour exécuter une application Node.js sur les conteneurs Back4app, vous devez créer un fichier Docker contenant les instructions pour construire l’image Docker.
Exécutez la commande ci-dessous pour créer un fichier Docker :
touch Dockerfile
Ensuite, vous devrez choisir une image de base pour votre application Node.js. Une image de base dans Docker est le point de départ de la construction d’une nouvelle image Docker. C’est la base sur laquelle votre image Docker est construite.
Ajoutez le bloc de code ci-dessous à votre fichier Docker pour spécifier votre image de base :
# Specify base image
FROM node:18-alpine
Cette ligne spécifie l’image de base sur laquelle cette image Docker sera construite. Dans ce cas, la version 18 de Node.js fonctionne sur une distribution Linux Alpine.
Ensuite, vous devez spécifier votre répertoire de travail. Toutes les commandes suivantes du fichier Docker seront exécutées par rapport à ce répertoire.
Ajoutez le bloc de code ci-dessous à votre fichier Docker pour spécifier votre répertoire de travail :
# Specify working directory
WORKDIR /app
Ensuite, vous devez copier vos fichiers package.json et package-lock.json du répertoire courant (c’est-à-dire le répertoire contenant le fichier Docker) vers le répertoire de travail(/app).
Ajoutez le bloc de code ci-dessous à votre fichier Docker pour copier les fichiers :
# Copy package.json and package-lock.json
COPY package*.json ./
Ensuite, vous devez exécuter la commande npm install dans le répertoire de travail pour installer les dépendances Node.js listées dans package.json et package-lock.json.
Ajoutez le code ci-dessous à votre fichier Docker pour installer les dépendances :
# Install dependencies
RUN npm install
La commande ci-dessus installera toutes les dépendances listées dans vos fichiers package.json ****et package-lock.json et les stockera dans le dossier node_modules dans le répertoire de travail spécifié.
Ensuite, vous devez copier le code source de votre application dans votre répertoire de travail.
Ajoutez le bloc de code ci-dessous à votre fichier Docker pour copier le code source :
# Copy source code
COPY . .
Ensuite, vous devez exposer un port à la machine hôte. L’exposition d’un port permet au conteneur Docker de recevoir des connexions réseau entrantes sur le port exposé lorsque vous l’exécutez.
Ajoutez le bloc de code ci-dessous à votre fichier Docker pour exposer le port 3000 à la machine hôte :
# Expose port 3000
EXPOSE 3000
Enfin, vous devez spécifier la commande qui doit être exécutée au démarrage du conteneur Docker. Généralement, les applications Node.js sont lancées à l’aide de la commande npm start.
Ajoutez le bloc de code ci-dessous à votre fichier Docker pour spécifier la commande :
# Run the app
CMD ["npm", "start"]
Votre fichier Docker terminé devrait ressembler au bloc de code ci-dessous :
# Specify base image
FROM node:18-alpine
# Specify working directory
WORKDIR /app
# Copy package.json and package-lock.json
COPY package*.json ./
# Install dependencies
RUN npm install
# Copy source code
COPY . .
# Expose port 3000
EXPOSE 3000
# Run the app
CMD ["npm", "start"]
Après avoir créé votre fichier Docker, publiez votre code sur GitHub.
Créer une nouvelle application Back4app
La première étape pour déployer une application Node.js sur Back4app est de créer un compte sur Back4app (si vous n’en avez pas). Vous pouvez en créer un en suivant les étapes ci-dessous.
- Accédez au site web de Back4app.
- Ensuite, cliquez sur le bouton S’inscrire dans le coin supérieur droit de la page d’accueil.
- Enfin, remplissez le formulaire d’inscription et envoyez-le.
Après avoir créé votre compte Back4app, connectez-vous à votre compte Back4app et cliquez sur le bouton NEW APP en haut à droite.
En cliquant sur ce bouton, vous accéderez à une page où vous pourrez choisir “Comment souhaitez-vous créer votre nouvelle application ? Puisque vous déployez en utilisant la conteneurisation, choisissez Conteneurs en tant que service, comme le montre l’image ci-dessous.
Ensuite, connectez votre compte GitHub à votre compte Back4app. Vous pouvez choisir de donner à Back4app l’accès à tous les dépôts de votre compte ou à des dépôts spécifiques.
Choisissez l’application que vous souhaitez déployer, dans ce cas, l’application que vous avez créée dans ce tutoriel, et cliquez sur Sélectionner.
En cliquant sur le bouton de sélection, vous accéderez à une page où vous devrez fournir des informations sur votre application, telles que le nom, la branche, le répertoire racine et les variables d’environnement.
Veillez à renseigner toutes les variables environnementales dont votre application a besoin pour fonctionner. Une fois que vous avez rempli les informations requises, cliquez sur Créer une application, comme le montre l’image ci-dessous.
En cliquant sur le bouton Créer une application, vous lancez le processus de déploiement. Lorsque le processus de déploiement est terminé, une URL permettant d’accéder à l’application déployée est indiquée dans le coin gauche de l’écran, comme le montre l’image ci-dessous.
Si votre processus de déploiement prend beaucoup de temps, vous pouvez vérifier les journaux pour voir si une erreur s’est produite lors du déploiement ou consulter le guide de dépannage de Back4app.
Conclusion
Node.js est un framework populaire qui offre de nombreux avantages, tels que la rapidité des performances, l’évolutivité et la flexibilité. Cependant, il présente également certaines limites, comme sa nature monotâche, qui peut rendre difficile la gestion de charges de travail lourdes.
Malgré ces limites, plusieurs options de déploiement sont disponibles pour les applications Node.js, notamment Back4app, qui fournit une plateforme fiable et conviviale pour l’hébergement et la gestion des applications Node.js.
En créant une application Node.js et en suivant les étapes décrites dans cet article, vous pouvez facilement déployer vos applications Node.js sur Back4app et profiter de ses nombreux avantages.
Toujours intéressé par le déploiement et l’hébergement de Node.js ? Consultez ces deux tutoriels :
FAQ
Comment déployer une application Web Node.js ?
– Configurer votre environnement de développement
– Se connecter à votre base de données
– Créer des fichiers de migration
– Implémenter le routage
– Créer un Dockerfile
– Créer une nouvelle application Back4app
