Comment dockeriser une API REST Node.js

Le processus de déploiement et d'exécution d'applications dans différents environnements peut être fastidieux car il y a un certain nombre de facteurs à prendre en compte comme la configuration des variables d'environnement pour configurer les dépendances nécessaires et les versions spécifiques de différents packages logiciels.

Cependant, en utilisant la technologie de conteneurisation de Docker, vous pouvez déployer des applications dans différents environnements avec un minimum d'effort avec toutes les dépendances nécessaires dans l'image Docker. Cela signifie que vous n'avez pas à vous soucier de faire une configuration. Cela facilite le processus de déploiement et d'exécution des applications dans différents environnements.

Qu'est-ce que Docker?

Docker est une plate-forme de développement qui fournit les outils et l'environnement pour conditionner les applications sous forme d'images portables pouvant être exécutées en tant que composants exécutables autonomes dans des conteneurs.

Ces conteneurs constituent le code de l'application et les dépendances requises pour que l'application s'exécute correctement sur différents environnements d'exécution sans aucun problème.

Avant de commencer, installez Docker sur votre ordinateur local. Vérifiez les prérequis spécifiques à la plate-forme et les instructions d'installation dans la documentation officielle.

Créer une API REST Node.js

Pour commencer, créer un serveur Web Node.js.

Vous pouvez trouver le code de cette application dans son Référentiel GitHub.

Ensuite, installez les packages requis pour ce projet.

npm installer morgan pg knex

Le page package est utilisé pour établir une connexion avec une base de données PostgreSQL. knex, d'autre part, fournit une API simple pour interagir avec PostgreSQL — vous l'utiliserez pour écrire des requêtes SQL.

Enfin, vous utiliserez Morgan, un middleware qui enregistre les requêtes et les réponses HTTP sur la console, pour déboguer et surveiller votre application s'exécutant dans un conteneur Docker.

Enfin, ouvrez le index.js fichier, et ajoutez le code ci-dessous implémente une simple API REST avec trois parcours.

constante exprimer = exiger("exprimer")
constante Morgan = exiger("Morgan")
constante app = express()
constante db = exiger('./db')
constante PORT = processus.env. PORT || 5000
app.use (morgan('dev'))
app.use (express.json())
app.use (express.urlencodé({ étendu: vrai }))
app.get('/', (req, res) => res.send('Bonjour le monde!' ))
app.get('/utilisateurs', asynchrone (req, res) => {
constante utilisateurs = attendre db.select().from('utilisateurs')
 res.json (utilisateurs)
})
app.post('/utilisateurs', asynchrone (req, res) => {
constante utilisateur = attendre db('utilisateurs').insérer({ nom: req.body.name }).returning('*')
 res.json (utilisateur)
})
app.listen (PORT, () => console.enregistrer(`Serveur au PORT :${PORT}`))

Configurer la connexion à la base de données

L'API REST interagira avec l'instance PostgreSQL de Docker, cependant, vous devez d'abord configurer la connexion à la base de données dans votre application. Dans le répertoire racine de votre dossier de projet, créez un db.js fichier et ajoutez le code ci-dessous.

constante knex = exiger('knex')
module.exports = knex({
 client: 'postgres',
 connexion: {
 héberger: 'db',
 utilisateur: 'testUser',
 mot de passe: 'monmotdepasse123',
 base de données: 'testUser',

 },
})

Configurer les fichiers migrate.js et seed.js

Ces deux fichiers permettront de créer une table dans la base de données et de la remplir avec des données de test via l'API. Créer un nouveau dossier, scénarios, dans le répertoire racine de votre projet et ajoutez deux fichiers: migrer.js et graine.js.

Dans le migrer.js fichier, ajoutez le code ci-dessous :

constante db = exiger('../db');
(asynchrone () => {
essayer {
attendre db.schema.dropTableIfExists('utilisateurs')
attendre db.schema.withSchema('public').createTable('utilisateurs', (tableau) => {
 table.incréments()
 table.string('nom')
 })
console.enregistrer('Table d'utilisateurs créée !')
 process.exit(0)
 } attraper (erre) {
console.log (erreur)
 process.exit(1)
 }
})()

Ce code créera un utilisateurs table avec une colonne id auto-incrémentée et une nom colonne dans la base de données.

Ensuite, dans le graine.js fichier, ajoutez le code ci-dessous :

constante db = exiger('../db');
(asynchrone () => {
essayer {
attendre db('utilisateurs').insérer({ nom: 'Tester l'utilisateur1' })
attendre db('utilisateurs').insérer({ nom: 'Tester l'utilisateur2' })
console.enregistrer('Utilisateurs factices ajoutés !')
 process.exit(0)
 } attraper (erre) {
console.log (erreur)
 process.exit(1)
 }
})()

Ce code implémente une fonction asynchrone qui va insérer deux utilisateurs dans la base de données PostgreSQL.

Enfin, ajoutez ces commandes à votre package.json déposer.

"scénarios": {
"commencer": "node index.js",
"émigrer": "node scripts/migrate.js",
"graine": "node scripts/graine.js"
 },

Étant donné que vous n'avez pas de client configuré, pour tester l'API, vous devrez exécuter les deux fichiers en tant que scripts à côté du course npm commande.

Configurer un Dockerfile

Un Dockerfile définit les instructions requises par le moteur Docker pour créer une image Docker. Dans le répertoire racine de votre projet, créez un nouveau fichier et nommez-le, Fichier Docker. Ensuite, ajoutez les instructions suivantes pour créer une image Docker pour l'application Node.js.

DEPUIS nœud:16.3.0-alpin3.13
RÉP TRAVAIL /app
COPIE package*.json ./
COURIR installation npm
COPIE. .
EXPOSER8000
CMD [ "nœud", "index.js" ]

Décomposons-le :

• DEPUIS - Cette instruction définit l'image de base de l'application, qui est l'image Alpine Node.js, une version allégée de l'image Node.js qui se trouve dans le registre Docker.
• RÉP TRAVAIL - ensembles /app répertoire comme répertoire de travail.
• COPIE package*.json./ - demande à Docker de copier tous les fichiers avec ce format de nom de fichier du répertoire actuel vers le /app dossier.
• COURIR - exécute et construit l'image.
• COPIE.. - copie les fichiers sources dans le /app dossier.
• EXPOSER - cela demande à Docker d'exposer un port dans le conteneur à l'environnement externe, dans ce cas, la machine hôte.
• CMD - spécifie la commande à exécuter lors de la création du conteneur Docker à partir de l'image.

Créer le fichier Docker Compose

Pour que l'application Node.js interagisse avec l'instance PostgreSQL de Docker, les deux applications doivent s'exécuter dans des conteneurs Docker au sein du même environnement réseau.

Pour cette raison, vous devez définir et créer à la fois l'image de l'application et l'instance PostgreSQL à l'aide de Docker Composer — un outil qui vous permet de créer et de gérer plusieurs conteneurs Docker.

En termes simples, à l'aide d'un Docker Compose, vous pouvez définir les services qui composent votre application comme une seule unité, dans ce cas, l'API REST Node.js et la base de données PostgreSQL.

Créer un nouveau fichier, docker-compose.yml, dans le répertoire racine et ajoutez le code ci-dessous :

version:'3.9'
prestations de service:
serveur:
construire:.
ports :
-'5000:5000'
dépend de:
-db
bd :
image:'postgres'
ports :
-'4321:5432'
environnement:
POSTGRES_MOT DE PASSE :'monmotdepasse123'
POSTGRES_USER :'testUser'
tomes :
-données :/var/lib/postgresql/données
tomes :
données:

Ce code créera et exécutera deux conteneurs Docker. Le premier conteneur, serveur, Docker Compose utilise le Dockerfile pour créer l'image de ce conteneur.

Il précise également que le conteneur du serveur dépend du db récipient. Sens, le serveur le conteneur doit être démarré après le db conteneur pour s'y connecter.

Le deuxième conteneur est un conteneur de base de données PostgreSQL. Vous n'avez pas besoin de spécifier un Dockerfile pour ce conteneur car il sera créé à partir de l'image PostgreSQL sur le registre d'images de Docker.

Construire les images Docker

Utilisez la commande Docker Compose pour créer les images et démarrer les deux conteneurs.

docker-composer jusqu'à -d

Vous devriez voir une réponse similaire une fois le processus terminé avec succès.

Testez l'API REST

Exécutez la commande ci-dessous pour tester l'API REST exécutée dans le conteneur Docker. Il devrait créer une table dans la base de données PostgreSQL.

docker exec docker_node-server-1 npm run migrate

Vous devriez voir une réponse similaire.

Partage des images Docker

La dernière étape consiste à pousser l'image Docker de votre application Node.js vers Docker Hub. Cela revient à pousser vos projets vers GitHub.

• Dirigez-vous vers Hub Docker et créez un compte et connectez-vous au tableau de bord de l'utilisateur.
• Cliquez ensuite sur Créer un référentiel. Indiquez le nom de votre référentiel et définissez sa visibilité sur Public ou Privé puis cliquez Créer.
• Pour pousser l'image Docker de votre application vers Docker Hub, vous devez d'abord vous connecter à votre compte via le terminal, puis fournir votre nom d'utilisateur et votre mot de passe.

connexion docker

• Ensuite, mettez à jour le nom de votre image Docker pour qu'il corresponde à ce format: /. Exécutez la commande ci-dessous pour effectuer cette modification:

 balise docker /

• Enfin, poussez votre image Docker.

 docker poussée /< nom du dépôt>

Utilisation de Docker dans le développement

Ce guide n'a abordé qu'une fraction du potentiel que Docker peut offrir. Cependant, vous pouvez désormais utiliser la technologie de conteneurisation de Docker pour empaqueter n'importe quelle application et toutes ses dépendances comme images qui peuvent être déployées dans différents développements, ainsi que dans des environnements de production comme le cloud sans aucun le hoquet.