TOC

Comment déployer une application Node.js et MongoDB avec Rancher sur Ubuntu 16.04

introduction

Rancher est une plate-forme complète open source, auto-hébergée, permettant d’exécuter et de gérer facilement des conteneurs en production. En tant qu’image Docker elle-même, un serveur Rancher fonctionnera sur tous les hôtes Linux sur lesquels Docker est disponible.

Voici certaines des principales caractéristiques qui rendent Rancher une solution attrayante:

  • * Mise en réseau multi-hôte *: Tous les serveurs ajoutés à Rancher sont liés, ce qui permet une communication sécurisée entre les conteneurs.

  • * Équilibrage de la charge *: un service d’équilibrage de la charge est inclus pour répartir les charges de travail entre les conteneurs ou même sur plusieurs nuages.

  • * Découverte de services *: Rancher comprend un système DNS interne permettant d’identifier nommément les conteneurs et les services afin de pouvoir les utiliser au sein d’autres services du réseau.

  • * Gestion d’infrastructure *: avec Rancher, vous pouvez ajouter, surveiller et gérer des ressources informatiques à partir de n’importe quel fournisseur de cloud.

  • * Moteurs d’orchestration *: Rancher est la seule plate-forme de gestion de conteneurs qui prend en charge les cadres d’orchestration de conteneurs les plus populaires, notamment Cattle, Swarm, Kubernetes et Mesos. Ainsi, si votre infrastructure fonctionne déjà avec l’un de ces cadres, vous pourrez facilement utiliser Rancher.

  • * Open Source *: Rancher est gratuit, ouvert et transparent. Vous avez le contrôle absolu de votre infrastructure.

Dans ce guide, vous allez créer un cluster Rancher pour déployer une application http://nodejs.org [Node.js] à charge équilibrée, avec prise en charge du stockage de données à l’aide de https://www.mongodb.org [MongoDB].

À la fin de ce didacticiel, vous aurez quatre instances d’une application Node.js simple à équilibrer la charge et un serveur MongoDB avec un conteneur de données séparé pour le stockage persistant.

Conditions préalables

  • Une gouttelette Ubuntu 16.04 de 1 Go avec Rancher installée. Nous utiliserons Rancher pour créer six gouttelettes supplémentaires, chacune avec 1 Go de RAM. Suivez les étapes 1 et 2 de https://www.digitalocean.com/community/tutorials/how-to-manage-multi-node-deployments-with-rancher-and-docker-machine-on-ubuntu-16-04 [ Comment gérer vos déploiements multi-nœuds avec Rancher et Docker Machine sur Ubuntu 16.04] pour configurer votre Droplet initial avec Rancher.

  • Une application Node.js qui utilise MongoDB pour le stockage de données. Ce tutoriel fournit un exemple simple d’utilisation de la bibliothèque Hapi.js que vous pouvez utiliser si votre propre application n’est pas encore prête. Vous trouverez cet exemple d’application dans cette référentiel Github, et nous l’explorerons en détail à l’étape 1.

  • Git est installé sur votre ordinateur local, vous pouvez donc cloner l’exemple d’application. Suivez la official installation documentation de Git si vous devez remplir cette condition préalable.

  • Docker est installé sur votre ordinateur local afin que vous puissiez créer l’image d’application que nous allons déployer. Vous pouvez suivre la documentation officielle pour cela.

  • Un compte sur Docker Hub, qui est un registre gratuit et public des images Docker. C’est ici que nous allons héberger notre code d’application afin de pouvoir le déployer sur plusieurs hôtes à l’aide de Rancher. Vous aurez besoin de votre nom d’utilisateur Docker Hub pour effectuer les étapes de ce didacticiel.

  • Un jeton d’accès DigitalOcean avec un accès en lecture et en écriture, que vous pouvez générer en visitant la page Applications & API. Copiez ce jeton, car vous devrez le saisir dans Rancher pour créer des hôtes supplémentaires.

Vous devez également posséder une connaissance de base des concepts Docker, tels que les conteneurs, les images et les fichiers Docker. Voir Comment installer et utiliser Docker sur Ubuntu 16.04 pour en savoir plus sur l’utilisation de Docker .

Étape 1 - Exploration de l’application Node.js

Pour ce tutoriel, nous allons utiliser une simple application Node.js basée sur la structure Hapi.js qui reçoit un message, l’enregistre et répertorie tous les messages soumis précédemment. Explorons le fonctionnement de l’application et la réception des valeurs de configuration afin de pouvoir définir ces valeurs avec Docker lors de la création de notre image.

Vous allez préparer l’application et l’image Docker sur votre ordinateur de développement local, plutôt que sur un serveur.

Clonez l’application exemple sur votre ordinateur local à l’aide de la commande suivante:

git clone https://github.com/do-community/hapi-example

Puis naviguez dans le répertoire du projet:

cd hapi-example

Regardons le fichier principal de l’application, + server.js. Il contient la connexion MongoDB et le code pour initialiser le serveur. Ouvrez ce fichier dans votre éditeur de texte local et vous verrez le contenu suivant:

server.js

const Hapi = require('hapi');
const mongojs = require('mongojs');

// Loads environment variables
// Used only in development
require('dotenv').config({silent: true});

const server = new Hapi.Server();
server.connection({ port: process.env.PORT || 3000 });

// Connect with the database
server.app.db = mongojs(process.env.MONGO_HOST + '/api');

// Add the routes
server.register(require('./routes'), (err) => {

 if (err) {
   console.error('Failed to load plugin:', err);
 }

 // Start the server
 server.start((err) => {
   if (err) {
     throw err;
   }

   console.log('Server running at:', server.info.uri);
 });
});

Le code des routes est encapsulé en tant que plug-in Hapi.js pour économiser de l’espace dans ce tutoriel, mais si vous êtes curieux, vous pouvez regarder dans le fichier + routes.js +.

Les parties critiques du fichier + server.js sont les suivantes:

server.js

require('dotenv').config({silent: true});

Ceci utilise le package + dotenv + Node.js pour charger nos variables d’environnement à partir d’un fichier + .env +. Vous pouvez consulter la documentation du package + dotenv + dans son référentiel Github si vous souhaitez en savoir plus sur son fonctionnement. Nous enregistrons les variables dans ce fichier uniquement pour le processus de développement; c’est plus facile que d’écrire manuellement les variables dans le terminal. En production, nous allons obtenir les variables de Docker, via Rancher.

Ensuite, nous définissons le port du serveur à l’aide d’une variable d’environnement appelée + PORT +, avec une valeur de repliement égale à + 3000 + `, au cas où la variable ne serait pas définie:

server.js

server.connection({ port: process.env.PORT || 3000 });

Le port + 3000 + est une convention courante pour les applications Node.js. Cette valeur peut être modifiée si nécessaire. la seule exigence est que ce soit above + 1023 + et ci-dessous `65535 `.

Enfin, avant de charger les routes et de démarrer le serveur, nous nous connectons au serveur MongoDB à l’aide d’une variable d’environnement appelée + MONGO_HOST +:

server.js

server.app.db = mongojs(process.env.MONGO_HOST + '');

Cette valeur d’environnement sera définie via Rancher avec le nom d’hôte du serveur MongoDB une fois les conteneurs MongoDB créés. La valeur ++ est le nom de la base de données à laquelle nous allons nous connecter, elle sera automatiquement configurée si elle n’existe pas.

Maintenant que vous avez une idée de ce que l’application recherche et de la configuration de son port et de sa connexion à la base de données, apportons Docker à la scène.

Étape 2 - Construire l’image de Docker

Rancher utilise des images Docker pour déployer des applications sur des serveurs. Nous allons donc créer une image Docker pour notre application. Pour créer une image Docker pour notre application, nous avons besoin d’un fichier appelé + Dockerfile + qui contient une série d’étapes que Docker suivra lors de la création de l’image. Ce fichier est déjà inclus dans le référentiel d’applications que vous avez cloné. Examinons son contenu pour comprendre son fonctionnement. Ouvrez-le dans votre éditeur de texte et vous verrez le code suivant:

Dockerfile

FROM node:6
MAINTAINER James Kolce <[email protected]>

RUN mkdir -p /usr/api
COPY . /usr/api
WORKDIR /usr/api
RUN npm install --production

ENV PORT 3000
EXPOSE  $PORT

CMD ["npm", "start"]

Examinons chaque étape en détail. Tout d’abord, nous voyons cette ligne:

Dockerfile

FROM node:6

Cette ligne déclare que notre image est construite sur l’image official Node.js de Docker Hub et que nous sélectionnons la version 6 de Node.js depuis notre application. utilise certaines fonctionnalités de l’ES6 uniquement disponibles dans cette version ou supérieure. Il est recommandé de choisir une version particulière au lieu d’utiliser la dernière version en production afin d’éviter toute modification qui pourrait endommager votre application.

Après cette ligne, nous configurons notre répertoire de travail:

Dockerfile

RUN mkdir -p /usr/api
COPY . /usr/api
WORKDIR /usr/api

Premièrement, nous lançons la commande + mkdir pour créer un nouveau répertoire appelé` + / usr / api _`, qui hébergera notre application. Le drapeau + -p + signifie que + mkdir + créera des répertoires intermédiaires selon les besoins. Ensuite, nous copions le contenu de l’image dans ce répertoire. Ensuite, nous définissons ce nouveau répertoire comme notre répertoire de travail afin que les commandes suivantes soient exécutées à partir de ce répertoire.

La ligne suivante exécute la commande + npm + et installe les dépendances de production pour notre application.

Dockerfile

RUN npm install --production

Ensuite, nous voyons ces deux lignes:

Dockerfile

ENV PORT 3000
EXPOSE  $PORT

La première ligne définit une variable d’environnement appelée + PORT + que notre application utilisera pour son port d’écoute. Juste au cas où cette variable n’est pas définie, nous définissons + 3000 + comme valeur par défaut. Ensuite, nous exposons ce port afin que nous puissions y accéder depuis l’extérieur du conteneur. L’utilisation d’une variable d’environnement facilite cette modification sans avoir à réécrire notre code d’application. Et rappelez-vous, notre application est conçue pour utiliser ces variables d’environnement.

La dernière étape de notre fichier Docker exécute notre serveur Node.js en exécutant la commande + npm start +:

Dockerfile

CMD ["npm", "start"]

Pour créer l’image Docker de notre application à partir de ce fichier, assurez-vous que vous vous trouvez dans le dossier + hapi-example + de votre terminal et exécutez la commande suivante:

docker build -t / .

Cette commande crée une image Docker en utilisant notre + Dockerfile +. Notez le point à la fin de la commande. Ceci spécifie le chemin d’accès au fichier + Dockerfile +, qui se trouve dans le dossier actuel. L’indicateur + -t + définit une balise pour notre image et nous allons utiliser + / + pour la balise, qui est une étiquette que nous appliquons à l’image afin que nous puissions l’utiliser pour créer des instances de conteneur à partir de cette image. Nous utilisons le nom d’utilisateur Docker Hub comme préfixe, car nous nous préparons à publier cette image une fois que nous l’avons testée, et la balise locale de l’image Docker doit correspondre au nom du référentiel sur Docker Hub.

Maintenant, testons l’image que nous venons de construire pour nous assurer que tout fonctionne comme prévu. Comme vous l’avez vu précédemment, notre application repose sur MongoDB. Nous allons donc créer un conteneur MongoDB que notre application peut utiliser pour stocker ses données. Exécutez la commande suivante pour créer et démarrer un conteneur MongoDB basé sur l’image officielle de MongoDB Docker:

docker run --name  -p 27017:27017 -d mongo:

Nous assignons un nom temporaire au conteneur avec l’option + - name +; nous utiliserons ce nom pour arrêter le serveur lorsque nous aurons terminé de tester l’application. Nous lions également le port hôte + 27017 + au port exposé par le conteneur afin que nous puissions vérifier que MongoDB est en cours d’exécution à l’aide de notre navigateur Web local. Enfin, nous spécifions l’image que nous voulons utiliser. C’est une bonne idée d’utiliser la même version de MongoDB que celle utilisée pour développer l’application afin de s’assurer que tout fonctionne comme prévu. Dans ce cas, nous spécifions la version + 3 +.

Après avoir exécuté cette commande, visitez + http: // localhost: 27017 + dans votre navigateur et le message suivant apparaît: + Il semblerait que vous tentiez d’accéder à MongoDB via HTTP sur le port de pilote natif +, ce qui signifie que MongoDB est en cours d’exécution.

Exécutez maintenant votre conteneur d’application et reliez-le au conteneur MongoDB en exécutant la commande suivante:

docker run --name  -p 3000:3000 -d -e MONGO_HOST= --link  /

Cette commande est similaire à la commande utilisée pour démarrer le conteneur MongoDB, mais cette fois-ci, nous utilisons notre image d’application (+ / +) et mappons le port + 3000 + de notre hôte avec le port exposé par le conteneur. C’est le même port que nous avons utilisé lorsque nous avons créé le + Dockerfile +. En outre, nous ajoutons une variable d’environnement appelée + MONGO_HOST + qui spécifie le nom de notre conteneur MongoDB qui sera utilisé par notre application pour se connecter au serveur de base de données. Le paramètre + - link + nous permet d’utiliser le nom du conteneur de la base de données en tant qu’hôte au sein du conteneur de notre application.

Après avoir exécuté la commande, testez l’application en accédant à la commande + http: // localhost: 3000 + dans votre navigateur. Il devrait montrer une page vide * sans aucune erreur *.

Maintenant que nous avons prouvé que l’image Docker fonctionne localement, arrêtons et supprimons nos conteneurs locaux. Gardez à l’esprit que la suppression d’un conteneur n’est pas la même chose que la suppression d’une image. Notre image va rester intacte afin que nous puissions recréer le conteneur plus tard, ou transmettre l’image à Rancher, ce que nous ferons après avoir nettoyé notre environnement local.

Tout d’abord, arrêtez le conteneur de base de données en utilisant le nom que vous avez défini précédemment:

docker stop

Maintenant que le conteneur est arrêté, vous pouvez le supprimer de votre ordinateur car vous n’en aurez plus besoin:

docker rm

Répétez les mêmes étapes pour votre conteneur d’applications. Arrêtez-le d’abord, puis retirez-le.

docker stop  && docker rm

Maintenant, publions l’image de travail afin que nous puissions l’utiliser avec Rancher.

Étape 3 - Chargement de l’image sur le hub Docker

Pour déployer des conteneurs à l’aide de Rancher, nous avons besoin d’accéder à un Docker registry, où nous pouvons créer un référentiel pour stocker notre image Docker. Nous utiliserons Docker Hub, qui est le registre officiel de Docker. Docker Hub est gratuit pour les référentiels publics.

Connectez-vous à Docker Hub avec votre nom d’utilisateur et votre mot de passe. Une fois connecté, cliquez sur le bouton * Créer un référentiel * sur le côté droit de l’écran. Remplissez les champs comme suit:

  • * Nom (obligatoire) *: Le nom de votre référentiel, dans ce cas, il s’agit de «++».

  • * Description *: Une courte description pour identifier votre image rapidement dans le futur.

  • * Description complète *: Vous pouvez ajouter ici un document de démarques à titre de référence pour votre image, mais comme notre application est assez simple, vous pouvez laisser ce champ vide.

  • * Visibilité *: vous pouvez définir vos images comme étant privées, où seul vous y aurez accès, ou comme publiques, où tout le monde pourra utiliser votre image. Pour ce tutoriel, créez un référentiel public.

Une fois tous les champs obligatoires renseignés, cliquez sur le bouton * Créer *. Une fois le processus terminé, vous serez redirigé vers votre nouveau site de référentiel.

Pour télécharger votre image Docker, vous devez vous connecter à Docker Hub via la commande + docker +. De retour dans votre terminal, exécutez la commande suivante:

docker login

Vous serez invité à entrer votre nom d’utilisateur et votre mot de passe. Comme la plupart des outils CLI, votre mot de passe ne s’affiche pas lors de la saisie.

Une fois connecté, téléchargez l’image sur Docker Hub à l’aide de la commande suivante qui télécharge tous les fichiers dans le référentiel:

docker push /

Pousser une image peut prendre plusieurs minutes en fonction de votre connexion Internet locale. Une fois l’image publiée, nous pouvons configurer nos hôtes à l’aide de Rancher.

Étape 4 - Création et étiquetage des serveurs hôtes dans Rancher

Utilisons Rancher pour créer tous les hôtes dont nous aurons besoin pour déployer nos services. Il nous en faudra deux pour l’application Node.js, un pour le serveur MongoDB et un pour l’équilibreur de charge. Nous ferons tout cela dans l’interface utilisateur de Rancher à l’aide de l’API de DigitalOcean.

Visitez l’interface de votre rancher dans votre navigateur en visitant + http: // + et suivez ces étapes pour créer les quatre hôtes dont nous aurons besoin:

  1. Allez sur * Infrastructure> Hosts * et cliquez sur le bouton * Ajouter un hôte * en haut de la page.

  2. Sélectionnez * DigitalOcean * en tant que fournisseur hôte.

  3. Collez votre jeton d’application DigitalOcean que vous avez généré dans le champ * Jeton d’accès * et cliquez sur * Suivant: Configurer le droplet *.

  4. Attribuer un nom. Entrez ++, qui générera automatiquement les noms de + host1 + à + ​​host4 +.

  5. Déplacez le curseur * Quantité * sur * 4 * hôtes.

  6. Pour * Image *, utilisez la valeur par défaut de * Ubuntu 16.04.1 x64 *.

  7. Pour * Taille *, utilisez la valeur par défaut de * 1 Go de RAM, 30 Go de disque, 1 vCPU *.

  8. Vous pouvez laisser le champ * Utilisateur SSH * en tant que * racine *.

  9. Cliquez sur le bouton * Créer * et attendez quelques minutes pendant que les serveurs sont créés et ajoutés à Rancher.

Une fois que Rancher a fini de créer tous les hôtes, nous ajoutons une étiquette à chacun d’eux pour classifier leur type afin que nous puissions organiser où nous allons placer chacun de nos composants. L’étiquetage des hôtes nous permet également d’échelonner nos serveurs en fonction de leur type. Par exemple, si la demande de notre application est trop importante, nous pouvons augmenter le nombre de serveurs de ce type et Rancher déploiera automatiquement les conteneurs Docker appropriés pour nous. Les étiquettes que nous allons créer un: + loadbalancer,` + application` et + base de données.

Créons la première étiquette, + loadbalancer +.

  1. Allez dans * Infrastructure> Hosts * et sélectionnez le premier hôte, ++.

  2. Cliquez sur le bouton * Options * (l’icône avec trois points verticaux en haut de la page) et sélectionnez l’option * Modifier *.

  3. Cliquez sur le bouton * + Ajouter un libellé * et, dans l’entrée * Clé *, entrez le mot + type, puis entrez` + équilibreur de charge` dans l’entrée * Valeur *.

  4. Cliquez sur le bouton * Enregistrer *.

Ensuite, identifiez les hôtes de l’application. Répétez le processus précédent avec les deux hôtes suivants, mais cette fois-ci utilisez + application + dans l’entrée * Valeur *.

Pour le dernier hôte, répétez le processus mais utilisez + database + dans l’entrée * Value *.

Les quatre hôtes doivent maintenant avoir des étiquettes, configurons donc les services. Nous allons commencer par la base de données.

Étape 5 - Déploiement du serveur MongoDB

Nous allons utiliser l’image officielle MongoDB Docker sur Docker Hub pour déployer notre serveur de base de données. Le conteneur MongoDB aura également un conteneur sidekick pour stocker toutes nos données. Les deux conteneurs seront déployés sur l’hôte étiqueté «+ base de données».

Pour ce faire, procédez comme suit dans l’interface utilisateur de Rancher:

  1. Sélectionnez le menu * Piles *, choisissez l’option * Utilisateur *, puis cliquez sur le bouton * Définir un service *.

  2. Dans la page * Add Service *, assurez-vous que le curseur * Scale * est défini sur * Run 1 container *.

  3. Pour le nom du service, utilisez ++.

  4. Pour l’image, entrez + mongo: 3 +.

  5. Cliquez sur le bouton * Ajouter un conteneur Sidekick * dans la section supérieure.

  6. Nommez ce nouveau conteneur ++. Ce conteneur servira de volume pour stocker les données MongoDB.

  7. Puisque nous allons utiliser ce conteneur pour les données uniquement, utilisez l’image + busybox +.

  8. Dans l’onglet * Command * ci-dessous, réglez l’option * Autorestart * sur * Jamais (Démarrer une fois) *, car nous n’utiliserons ce conteneur que pour le stockage.

  9. Passez à l’onglet * Volumes * et ajoutez un nouveau volume en cliquant sur le bouton * Ajouter un volume *. Entrez + / data / db + dans le champ de texte qui apparaît. Il s’agit du chemin par défaut où MongoDB stocke les données.

  10. Basculez sur l’onglet * Planification *, cliquez sur le bouton * Ajouter une règle de planification * et entrez les paramètres suivants: + L’hôte doit avoir une étiquette d’hôte de type = base de données +. Utilisez les listes déroulantes pour vous aider à créer cette règle.

  11. Cliquez sur l’onglet de service * MongoDB *, puis faites défiler jusqu’à l’onglet * Command * et assurez-vous que l’option * Autorestart * est définie sur * Toujours *.

  12. Passez à l’onglet * Volumes * et sélectionnez * Données * dans l’option * Volumes à partir de *.

  13. Basculez sur l’onglet * Planification * et ajoutez une nouvelle règle de planification avec les paramètres suivants: + L’hôte doit avoir une étiquette d’hôte de type = base de données +

  14. Enfin, cliquez sur le bouton * Créer * en bas et attendez quelques minutes pendant que le service est activé.

Maintenant, configurons le service d’application.

Étape 6 - Déploiement de l’application Node.js

Nous allons utiliser une approche similaire pour déployer l’application Node.js que nous avons précédemment préparée. L’image que nous avons stockée sur Docker Hub sera déployée sur les hôtes nommés + application ou et sera liée au service MongoDB pour stocker et accéder aux données. Alors, suivez ces étapes dans l’interface utilisateur de Rancher:

  1. Sélectionnez le menu * Piles *, choisissez l’option * Utilisateur *, puis cliquez sur le bouton * Ajouter un service * dans la pile * Par défaut *.

  2. Dans la section * Scale *, sélectionnez l’option * Toujours exécuter une instance de ce conteneur sur chaque hôte *.

  3. Le nom que nous allons utiliser pour ce service est ++.

  4. Pour l’image, nous utiliserons celle que nous avons déployée sur Docker Hub. Entrez + / +.

  5. Cliquez sur le bouton * Liens de service *, sélectionnez * Service de destination * et choisissez * MongoDB *. Puis sélectionnez * As name * et entrez + db +, ainsi notre service + NodeJS + peut avoir accès au service MongoDB en utilisant ce nom.

  6. Dans l’onglet * Command * au bas de la page, cliquez sur le bouton * Ajouter une variable d’environnement * et ajoutez une variable nommée + MONGO_HOST + avec la valeur + db +, qui correspond au nom du service de destination utilisé dans le fichier. étape précédente. N’oubliez pas que notre application s’appuie sur cette variable d’environnement pour localiser le serveur de base de données.

  7. Passez à l’onglet * Planification *, cliquez sur le bouton * Ajouter une règle de planification * et utilisez les listes déroulantes pour créer une règle disant + L’hôte doit avoir une étiquette d’hôte de type = application +.

  8. Enfin, cliquez sur * Créer * et attendez que Rancher configure le service.

En peu de temps, vous constaterez que le nouveau service + NodeJS + a lancé deux conteneurs. Sélectionnez le menu * Infrastructure *, cliquez sur * Hôtes * et vous verrez que les deux hôtes intitulés + application + exécutent maintenant ce nouveau service. Comme il y en a plusieurs, configurons un équilibreur de charge pour pouvoir utiliser ces deux hôtes efficacement.

Étape 7 - Déploiement de l’équilibreur de charge

Notre équilibreur de charge va être lié à nos services + NodeJS + pour équilibrer la charge de travail entre tous les conteneurs sur les hôtes de l’application.

  1. Pour créer l’équilibreur de charge, sélectionnez le menu * Piles * et choisissez l’option * Utilisateur *. Cette fois, cliquez sur la flèche en regard du bouton * Ajouter un service * et sélectionnez * Ajouter un équilibreur de charge * dans la liste déroulante.

  2. Pour le * Nom *, entrez + LoadBalancer +.

  3. Dans la section * Règles de port *, définissez le champ * Request Host Port * (premier champ) sur + 80 +, et le * Port cible * (le second) sur + 3000 +, qui est le port notre Les conteneurs + NodeJS + sont exposés.

  4. Dans l’option * Service cible *, sélectionnez * NodeJS *, qui est le service que nous avons récemment créé.

  5. Dans l’onglet * Planification * au bas de la page, cliquez sur le bouton * Ajouter une règle de planification * et créez une règle disant + L’hôte doit avoir une étiquette d’hôte de type = loadbalancer +.

  6. Enfin, cliquez sur * Créer * et attendez que Rancher active le service.

Chaque fois que nous avons créé un service, nous avons utilisé les étiquettes que nous avons créées pour déterminer le mode de déploiement du service. Cela facilite la gestion d’hôtes supplémentaires à l’avenir. Maintenant, assurons-nous que les choses fonctionnent.

Étape 8 - Test de l’application

Pour tester notre application, nous devons obtenir l’adresse de l’hôte de l’équilibreur de charge. Sélectionnez le service * LoadBalancer * et vous verrez l’adresse IP dans l’onglet * Ports *.

Pour vérifier que notre application fonctionne, exécutez la commande suivante dans un terminal:

curl

Cette commande envoie une requête GET au serveur. Vous verrez une réponse contenant un tableau vide (+ [] +) car notre base de données est vide.

Exécutez la commande suivante pour ajouter un message à la base de données et vous assurer que l’application peut enregistrer des données:

curl -i -X POST -H "Content-Type:application/json"  -d '{"message":""}'

Cette commande envoie une demande POST au serveur avec un objet JSON contenant une clé + message + avec la valeur. Après l’envoi de la demande, vous devriez recevoir le même message que vous avez envoyé en réponse, accompagné d’un + _id + de MongoDB. Cela signifie que la connexion avec le serveur MongoDB fonctionne et que l’application a sauvegardé vos données.

Maintenant, pour vérifier que l’application fonctionne correctement, exécutez à nouveau la première commande et vous devriez obtenir le message que vous avez ajouté à l’étape précédente.

curl

La sortie ressemblera à ceci:

HTTP/1.1 200 OK
content-type: application/json; charset=utf-8
cache-control: no-cache
content-length: 61
Date: Wed, 05 Jan 2017 20:07:02 GMT
Connection: keep-alive

{"message":"This is a test","_id":"e64d85579aee7d1000b075a2"}

À ce stade, vous avez maintenant deux serveurs d’applications, une base de données et un équilibreur de charge configuré et prêt à être utilisé. Voyons comment adapter nos services pour gérer davantage de trafic.

Étape 9 - Mise à l’échelle des serveurs Node.js

Lorsque votre application commence à recevoir une demande importante et que vos serveurs ne peuvent pas gérer la charge, vous pouvez augmenter le nombre de serveurs Node.js et la charge sera automatiquement répartie entre les conteneurs sur les hôtes de l’application. Suivez ces étapes pour adapter votre application:

  1. Allez sur la page * Infrastructure> Hosts * et cliquez sur le bouton * Ajouter un hôte *.

  2. Ajoutez votre jeton d’accès * DigitalOcean * dans le champ du même nom.

  3. Utilisez + host5 + comme nom pour le premier nouvel hôte, puisque le dernier hôte que nous avons créé était + host4 +. Étant donné que nous allons créer deux nouveaux hôtes, Rancher nommera automatiquement le suivant comme + host6 +.

  4. Sélectionnez la quantité que vous voulez dans ce cas, nous ajouterons * 2 * plusieurs hôtes.

  5. Pour * Image *, utilisez la valeur par défaut de * Ubuntu 16.04.1 x64 *.

  6. Pour * Taille *, utilisez la valeur par défaut de * 1 Go de RAM, 30 Go de disque, 1 vCPU *.

  7. Cliquez sur le bouton * Ajouter une étiquette * et, dans l’entrée * Key *, entrez + type +, puis entrez + application + dans l’entrée * Valeur *.

  8. Cliquez sur le bouton * Créer * et attendez que les nouveaux hôtes soient activés et ajoutés à Rancher.

Une fois les nouveaux hôtes mis en ligne, ils sont configurés et déployés automatiquement, et l’équilibreur de charge distribue la charge de travail entre quatre conteneurs sur quatre hôtes.

Conclusion

Dans ce tutoriel, vous avez appris à préparer, déployer et mettre à l’échelle une application fonctionnelle Node.js avec prise en charge du stockage de données avec MongoDB. Comme vous pouvez le constater, avec Rancher et son interface graphique, le processus est plutôt intuitif et il est facile de faire évoluer une application complète. Et grâce aux fonctionnalités de planification de Rancher, lorsque votre application sera au premier plan, vous pourrez gérer la charge facilement.

Related