TOC

Bereitstellen einer Node.js- und MongoDB-Anwendung mit Rancher unter Ubuntu 16.04

Einführung

Rancher ist eine selbst gehostete Open Source-Plattform, mit der Container in der Produktion ausgeführt und problemlos verwaltet werden können. Als Docker-Image funktioniert ein Rancher-Server auf jedem Linux-Host, auf dem Docker verfügbar ist.

Einige der Hauptmerkmale, die Rancher zu einer attraktiven Lösung machen, sind:

  • * Hostübergreifendes Netzwerk *: Alle zu Rancher hinzugefügten Server sind miteinander verbunden, um eine sichere Kommunikation zwischen Containern zu ermöglichen.

  • * Lastausgleich *: Ein Lastausgleichsdienst ist enthalten, um Arbeitslasten zwischen Containern oder sogar über mehrere Clouds zu verteilen.

  • * Diensterkennung *: Rancher enthält ein internes DNS-System, mit dem Container und Dienste anhand ihres Namens identifiziert werden können, damit sie in anderen Diensten im Netzwerk verwendet werden können.

  • * Infrastrukturverwaltung *: Mit Rancher können Sie von jedem Cloud-Anbieter aus Computerressourcen hinzufügen, überwachen und verwalten.

  • * Orchestrierungs-Engines *: Rancher ist die einzige Container-Management-Plattform, die die gängigsten Container-Orchestrierungs-Frameworks unterstützt, darunter Cattle, Swarm, Kubernetes und Mesos. Wenn Ihre Infrastruktur bereits mit einem dieser Frameworks funktioniert, können Sie Rancher problemlos verwenden.

  • * Open Source *: Rancher ist kostenlos, offen und transparent. Sie haben die absolute Kontrolle über Ihre Infrastruktur.

In diesem Handbuch erstellen Sie einen Rancher-Cluster für die Bereitstellung einer Anwendung mit Lastenausgleich http://nodejs.org [Node.js] und Unterstützung für die Datenspeicherung unter https://www.mongodb.org [MongoDB].

Am Ende dieses Lernprogramms stehen Ihnen vier Instanzen einer einfachen Node.js-Anwendung mit Lastenausgleich und ein MongoDB-Server mit einem separaten Datencontainer für die dauerhafte Speicherung zur Verfügung.

Voraussetzungen

  • Ein 1 GB Ubuntu 16.04 Droplet mit installiertem Rancher. Mit Rancher erstellen wir sechs zusätzliche Droplets mit jeweils 1 GB RAM. Befolgen Sie die Schritte 1 und 2 von https://www.digitalocean.com/community/tutorials/how-to-manage-multi-node-deployments-with-rancher-and-docker-machine-on-ubuntu-16-04 [ So verwalten Sie Ihre Multi-Node-Bereitstellungen mit Rancher und Docker Machine unter Ubuntu 16.04], um Ihr erstes Droplet mit Rancher einzurichten.

  • Eine Node.js-Anwendung, die MongoDB zur Datenspeicherung verwendet. Dieses Tutorial bietet ein einfaches Beispiel mit der Bibliothek Hapi.js, die Sie verwenden können, wenn Sie noch keine eigene Anwendung haben. Sie finden diese Beispielanwendung unter this Github repository. Wir werden sie in Schritt 1 ausführlich untersuchen.

  • Git ist auf Ihrem lokalen Computer installiert, sodass Sie die Beispielanwendung klonen können. Befolgen Sie die official Git installation documentation, wenn Sie diese Voraussetzung erfüllen müssen.

  • Docker ist auf Ihrem lokalen Computer installiert, sodass Sie das von uns bereitgestellte Anwendungsimage erstellen können. Sie können dazu der offiziellen Dokumentation folgen.

  • Ein Konto unter Docker Hub, einer kostenlosen und öffentlichen Registrierung für Docker-Images. Hier hosten wir unseren Anwendungscode, damit wir ihn mit Rancher auf mehreren Hosts bereitstellen können. Sie benötigen Ihren Docker Hub-Benutzernamen, um die Schritte in diesem Lernprogramm auszuführen.

  • Ein DigitalOcean-Zugriffstoken mit Lese- und Schreibzugriff, das Sie auf der Seite Applications & API erstellen können. Kopieren Sie dieses Token, da Sie es in Rancher eingeben müssen, um zusätzliche Hosts zu erstellen.

Sie sollten auch Grundkenntnisse über Docker concepts wie Container, Images und Dockerfiles haben. Weitere Informationen zur Verwendung von Docker finden Sie unter Installation und Verwendung von Docker unter Ubuntu 16.04 .

Schritt 1 - Erkunden der Node.js-Anwendung

In diesem Lernprogramm wird eine einfache Node.js-Anwendung verwendet, die auf dem Hapi.js-Framework basiert und eine Nachricht empfängt, aufzeichnet und alle zuvor gesendeten Nachrichten auflistet. Lassen Sie uns untersuchen, wie die Anwendung funktioniert und wie sie Konfigurationswerte empfängt, damit wir diese Werte mit Docker festlegen können, wenn wir unser Image erstellen.

Sie bereiten die Anwendung und das Docker-Image auf Ihrem lokalen Entwicklungscomputer und nicht auf einem Server vor.

Klonen Sie die Beispielanwendung mit dem folgenden Befehl auf Ihren lokalen Computer:

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

Navigieren Sie dann in das Projektverzeichnis:

cd hapi-example

Schauen wir uns die Hauptdatei der Anwendung an: "+ server.js". Es enthält die MongoDB-Verbindung und den Code zum Initialisieren des Servers. Öffnen Sie diese Datei in Ihrem lokalen Texteditor und Sie sehen den folgenden Inhalt:

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);
 });
});

Der Code für die Routen ist als Hapi.js-Plugin gekapselt, um Platz in diesem Lernprogramm zu sparen. Wenn Sie jedoch neugierig sind, können Sie in der Datei "+ routes.js +" nachsehen.

Die kritischen Teile der Datei "+ server.js" lauten wie folgt:

server.js

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

Dabei wird das Paket + dotenv + Node.js verwendet, um unsere Umgebungsvariablen aus einer + .env + - Datei zu laden. Sie können die Dokumentation für das Paket "+ dotenv +" unter Github repository lesen, wenn Sie daran interessiert sind, wie es funktioniert. Wir speichern die Variablen in dieser Datei nur für den Entwicklungsprozess. Es ist einfacher, als die Variablen manuell in das Terminal zu schreiben. In der Produktion werden wir die Variablen über Rancher von Docker beziehen.

Als nächstes setzen wir den Port für den Server mithilfe einer Umgebungsvariablen namens "+ PORT " mit einem Fallback-Wert von " 3000 +", falls die Variable nicht definiert ist:

server.js

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

Port + 3000 + ist eine gängige Konvention für Node.js-Anwendungen. Dieser Wert kann bei Bedarf geändert werden. Die einzige Voraussetzung ist, dass es http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xml über + 1023 + und unter `65535 liegt `].

Schließlich stellen wir vor dem Laden der Routen und dem Starten des Servers eine Verbindung zum MongoDB-Server mithilfe einer Umgebungsvariablen namens "+ MONGO_HOST +" her:

server.js

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

Dieser Umgebungswert wird über Rancher mit dem Hostnamen des MongoDB-Servers definiert, sobald wir die MongoDB-Container erstellen. Der Wert "++" ist der Name der Datenbank, zu der eine Verbindung hergestellt werden soll. Er wird automatisch eingerichtet, wenn er nicht vorhanden ist.

Nachdem Sie einige Hintergrundinformationen zu den Suchvorgängen der App und zur Konfiguration von Port und Datenbankverbindung erhalten haben, bringen wir Docker in das Bild.

Schritt 2 - Erstellen des Docker-Images

Rancher verwendet Docker-Images, um Anwendungen auf Servern bereitzustellen. Erstellen wir daher ein Docker-Image für unsere Anwendung. Um ein Docker-Image für unsere App zu erstellen, benötigen wir eine Datei mit dem Namen "+ Dockerfile +", die eine Reihe von Schritten enthält, die Docker beim Erstellen des Images befolgt. Diese Datei ist bereits in dem Anwendungsrepository enthalten, das Sie geklont haben. Schauen wir uns den Inhalt an, um zu verstehen, wie es funktioniert. Öffnen Sie es in Ihrem Texteditor und Sie sehen den folgenden Code:

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"]

Schauen wir uns jeden Schritt im Detail an. Zuerst sehen wir diese Zeile:

Dockerfile

FROM node:6

In dieser Zeile wird angegeben, dass unser Image auf dem official Node.js-Image von Docker Hub basiert. Seit unserer App wählen wir Version 6 von Node.js aus nutzt einige ES6-Funktionen, die nur in dieser Version oder höher verfügbar sind. Es wird empfohlen, eine bestimmte Version auszuwählen, anstatt nur die * neueste * Version in der Produktion zu verwenden, um Änderungen zu vermeiden, die Ihre App beschädigen könnten.

Nach dieser Zeile richten wir unser Arbeitsverzeichnis ein:

Dockerfile

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

Zuerst führen wir den Befehl + mkdir aus, um ein neues Verzeichnis mit dem Namen` + / usr / api _` zu erstellen, in dem sich unsere Anwendung befindet. Das + -p + Flag bedeutet, dass + mkdir + nach Bedarf Zwischenverzeichnisse erstellt. Dann kopieren wir den Inhalt des Bildes in dieses Verzeichnis. Dann legen wir dieses neue Verzeichnis als unser Arbeitsverzeichnis fest, damit nachfolgende Befehle von diesem Verzeichnis ausgeführt werden.

In der nächsten Zeile wird der Befehl "+ npm +" ausgeführt und die Produktionsabhängigkeiten für unsere App installiert.

Dockerfile

RUN npm install --production

Als nächstes sehen wir diese beiden Zeilen:

Dockerfile

ENV PORT 3000
EXPOSE  $PORT

Die erste Zeile definiert eine Umgebungsvariable mit dem Namen "+ PORT ", die unsere Anwendung für ihren Überwachungsport verwendet. Für den Fall, dass diese Variable nicht definiert ist, setzen wir " 3000 +" als Standardwert. Dann legen wir diesen Port frei, damit wir von außerhalb des Containers darauf zugreifen können. Die Verwendung einer Umgebungsvariablen erleichtert das Ändern, ohne dass der Anwendungscode neu geschrieben werden muss. Denken Sie daran, dass unsere Anwendung diese Umgebungsvariablen verwendet.

Der letzte Schritt in unserer Docker-Datei führt unseren Node.js-Server mit dem Befehl + npm start + aus:

Dockerfile

CMD ["npm", "start"]

Um das Docker-Image unserer Anwendung aus dieser Datei zu erstellen, vergewissern Sie sich, dass Sie sich im Ordner "+ hapi-example +" Ihres Terminals befinden, und führen Sie den folgenden Befehl aus:

docker build -t / .

Dieser Befehl erzeugt ein Docker-Image mit unserem + Dockerfile +. Beachten Sie den Punkt am Ende des Befehls. Dies gibt den Pfad zu der Docker-Datei an, die sich im aktuellen Ordner befindet. Das "+ -t " - Flag legt ein Tag für unser Bild fest und wir verwenden " / +" für das Tag. Dies ist eine Bezeichnung, die wir auf das Bild anwenden, damit wir daraus Containerinstanzen erstellen können. Wir verwenden den Docker Hub-Benutzernamen als Präfix, da wir uns darauf vorbereiten, dieses Image nach dem Testen zu veröffentlichen, und das lokale Tag des Docker-Images muss mit dem Repository-Namen in Docker Hub übereinstimmen.

Testen wir nun das Image, das wir gerade erstellt haben, damit wir sicher sein können, dass alles wie erwartet funktioniert. Wie Sie bereits gesehen haben, basiert unsere Anwendung auf MongoDB. Erstellen wir also einen MongoDB-Container, mit dem unsere App ihre Daten speichern kann. Führen Sie den folgenden Befehl aus, um einen MongoDB-Container basierend auf dem offiziellen MongoDB Docker-Image zu erstellen und zu starten:

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

Wir weisen dem Container einen temporären Namen mit der Option "+ - name " zu. Diesen Namen verwenden wir, um den Server zu stoppen, wenn der Test der Anwendung abgeschlossen ist. Wir binden auch den Host-Port " 27017 " an den vom Container bereitgestellten Port, damit wir testen können, ob MongoDB mit unserem lokalen Webbrowser ausgeführt wird. Zuletzt geben wir das Bild an, das wir verwenden möchten. Es ist eine gute Idee, die gleiche Version von MongoDB zu verwenden, mit der die Anwendung entwickelt wurde, um sicherzustellen, dass alles wie erwartet funktioniert. In diesem Fall geben wir die Version " 3 +" an.

Nachdem Sie diesen Befehl ausgeführt haben, rufen Sie in Ihrem Browser "+ http: // localhost: 27017 " auf und Sie sehen die Meldung: " Sie versuchen anscheinend, über HTTP auf MongoDB über den nativen Treiberport zuzugreifen." MongoDB läuft.

Führen Sie nun Ihren Anwendungscontainer aus und verknüpfen Sie ihn mit dem MongoDB-Container, indem Sie diesen Befehl ausführen:

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

Dieser Befehl ähnelt dem Befehl, den wir zum Starten des MongoDB-Containers verwendet haben, aber dieses Mal verwenden wir unser Anwendungsimage ("+ / ") und ordnen den Port " 3000 " unseres Hosts dem vom Container offengelegten Port zu. Dies ist derselbe Port, den wir bei der Erstellung der ` Dockerfile ` verwendet haben. Außerdem fügen wir eine Umgebungsvariable mit dem Namen " MONGO_HOST " hinzu, die den Namen unseres MongoDB-Containers angibt, der von unserer Anwendung zum Herstellen einer Verbindung zum Datenbankserver verwendet wird. Mit dem Parameter " - link +" können wir den Namen des Datenbankcontainers als Host innerhalb des Containers unserer Anwendung verwenden.

Testen Sie die Anwendung, nachdem Sie den Befehl ausgeführt haben, indem Sie in Ihrem Browser "+ http: // localhost: 3000 +" aufrufen. Es sollte eine leere Seite * ohne Fehler * angezeigt werden.

Nachdem wir bewiesen haben, dass das Docker-Image lokal funktioniert, stoppen wir und löschen unsere lokalen Container. Beachten Sie, dass das Löschen eines Containers nicht mit dem Löschen eines Bildes identisch ist. Unser Image bleibt intakt, sodass wir den Container später neu erstellen oder das Image an Rancher senden können. Dies ist das, was wir tun werden, nachdem wir unsere lokale Umgebung aufgeräumt haben.

Stoppen Sie zunächst den Datenbankcontainer unter Verwendung des zuvor definierten Namens:

docker stop

Nachdem der Container angehalten wurde, können Sie ihn von Ihrem Computer löschen, da Sie ihn nicht mehr benötigen:

docker rm

Wiederholen Sie die gleichen Schritte für Ihren Anwendungscontainer. Erst anhalten, dann entfernen.

docker stop  && docker rm

Veröffentlichen wir nun das Arbeitsbild, damit wir es mit Rancher verwenden können.

Schritt 3 - Laden Sie das Image in Docker Hub hoch

Um Container mit Rancher bereitzustellen, benötigen wir Zugriff auf eine Docker-Registrierung, in der wir ein Repository zum Speichern unseres Docker-Images erstellen können. Wir verwenden Docker Hub, die offizielle Registrierung für Docker. Docker Hub kann kostenlos für öffentliche Repositorys verwendet werden.

Melden Sie sich mit Ihrem Benutzernamen und Passwort bei Docker Hub an. Sobald Sie angemeldet sind, klicken Sie auf die Schaltfläche * Repository erstellen * auf der rechten Seite des Bildschirms. Füllen Sie die Felder wie folgt aus:

  • * Name (erforderlich) *: Der Name Ihres Repositorys, in diesem Fall "++".

  • * Beschreibung *: Eine kurze Beschreibung, um Ihr Bild in Zukunft schnell zu identifizieren.

  • * Vollständige Beschreibung *: Sie können hier ein Abschriften-Dokument als Referenz für Ihr Bild hinzufügen, aber da unsere Anwendung ziemlich einfach ist, können Sie dieses Feld leer lassen.

  • * Sichtbarkeit *: Sie können Ihre Bilder als privat festlegen, wo nur Sie Zugriff darauf haben, oder als öffentlich, wo jeder Ihr Bild verwenden kann. Erstellen Sie für dieses Lernprogramm ein öffentliches Repository.

Nachdem alle erforderlichen Felder ausgefüllt wurden, klicken Sie auf die Schaltfläche * Erstellen *. Wenn der Vorgang abgeschlossen ist, werden Sie zu Ihrer neuen Repository-Site weitergeleitet.

Um Ihr Docker-Image hochzuladen, müssen Sie sich über den Befehl + docker + bei Docker Hub anmelden. Führen Sie in Ihrem Terminal den folgenden Befehl aus:

docker login

Sie werden aufgefordert, Ihren Benutzernamen und Ihr Passwort einzugeben. Wie bei den meisten CLI-Tools wird Ihr Kennwort bei der Eingabe nicht angezeigt.

Sobald Sie angemeldet sind, laden Sie das Image mit dem folgenden Befehl in Docker Hub hoch, wodurch alle Dateien in das Repository hochgeladen werden:

docker push /

Das Übertragen eines Bilds kann abhängig von Ihrer lokalen Internetverbindung einige Minuten dauern. Sobald das Bild erfolgreich veröffentlicht wurde, können wir unsere Hosts mit Rancher einrichten.

Schritt 4 - Erstellen und Beschriften der Hostserver in Rancher

Verwenden wir Rancher, um alle Hosts zu erstellen, die wir für die Bereitstellung unserer Services benötigen. Für die Node.js-Anwendung benötigen wir zwei, eine für den MongoDB-Server und eine für den Lastenausgleich. All dies erledigen wir in der Rancher-Benutzeroberfläche mithilfe der DigitalOcean-API.

Rufen Sie in Ihrem Browser die Rancher-Oberfläche auf, indem Sie "+ http: // +" aufrufen, und führen Sie die folgenden Schritte aus, um die vier Hosts zu erstellen, die wir benötigen:

  1. Gehen Sie zu * Infrastruktur> Hosts * und klicken Sie oben auf der Seite auf die Schaltfläche * Host hinzufügen *.

  2. Wählen Sie als Host-Provider * DigitalOcean *.

  3. Fügen Sie das von Ihnen generierte DigitalOcean Application Token in das Feld * Access Token * ein und klicken Sie auf * Next: Configure Droplet *.

  4. Vergeben Sie einen Namen. Geben Sie "+" ein, wodurch automatisch Namen von " host1 " bis " host4 +" generiert werden.

  5. Bewegen Sie den Schieberegler * Quantity * auf * 4 * Hosts.

  6. Verwenden Sie für * Image * den Standardwert * Ubuntu 16.04.1 x64 *.

  7. Verwenden Sie für * Größe * den Standardwert * 1 GB RAM, 30 GB Festplatte, 1 vCPU *.

  8. Sie können das Feld * SSH-Benutzer * als * root * belassen.

  9. Klicken Sie auf die Schaltfläche * Erstellen * und warten Sie einige Minuten, während die Server erstellt und Rancher hinzugefügt werden.

Sobald Rancher alle Hosts erstellt hat, fügen wir jedem von ihnen eine Bezeichnung hinzu, um den Typ zu klassifizieren und zu organisieren, wo die einzelnen Komponenten abgelegt werden sollen. Durch die Kennzeichnung von Hosts können wir unsere Server auch je nach Typ skalieren. Wenn wir beispielsweise eine zu große Nachfrage nach unserer Anwendung haben, können wir die Anzahl der Server dieses Typs erhöhen und Rancher stellt automatisch die entsprechenden Docker-Container für uns bereit. Die Labels, die wir erstellen werden, sind: + loadbalancer,` + application` und + database.

Erstellen wir das erste Label, "+ loadbalancer +".

  1. Gehen Sie zu * Infrastruktur> Hosts * und wählen Sie den ersten Host aus, ++.

  2. Klicken Sie auf die Schaltfläche * Optionen * (das Symbol mit den drei vertikalen Punkten oben auf der Seite) und wählen Sie die Option * Bearbeiten *.

  3. Klicken Sie auf die Schaltfläche * + Add Label * und geben Sie in die Eingabe * Key * das Wort + type + und in die Eingabe * Value * + loadbalancer + ein.

  4. Klicken Sie auf die Schaltfläche * Speichern *.

Beschriften Sie als Nächstes die Anwendungshosts. Wiederholen Sie den vorherigen Vorgang mit den nächsten beiden Hosts, verwenden Sie diesmal jedoch "+ application +" in der Eingabe "* Value *".

Wiederholen Sie den Vorgang für den letzten Host erneut, verwenden Sie jedoch "+ database +" in der Eingabe "* Value *".

Alle vier Hosts sollten nun mit Labels versehen sein. Richten wir also die Services ein. Wir beginnen mit der Datenbank.

Schritt 5 - Bereitstellung des MongoDB-Servers

Wir werden das offizielle MongoDB Docker-Image auf Docker Hub verwenden, um unseren Datenbankserver bereitzustellen. Der MongoDB-Container verfügt auch über einen sidekick -Container, in dem alle unsere Daten gespeichert werden. Beide Container werden auf dem Host mit der Bezeichnung "+ database" bereitgestellt.

Führen Sie dazu die folgenden Schritte in der Rancher-Benutzeroberfläche aus:

  1. Wählen Sie das Menü * Stacks *, wählen Sie die Option * User * und klicken Sie dann auf die Schaltfläche * Define a Service *.

  2. Stellen Sie auf der Seite * Add Service * sicher, dass der Schieberegler * Scale * auf * Run 1 container * gesetzt ist.

  3. Verwenden Sie für den Namen des Dienstes "++".

  4. Geben Sie für das Bild "+ mongo: 3 +" ein.

  5. Klicken Sie im oberen Bereich auf die Schaltfläche * Sidekick-Container hinzufügen *.

  6. Nennen Sie diesen neuen Container "++". Dieser Container wird als Volume zum Speichern der MongoDB-Daten verwendet.

  7. Da dieser Container nur für Daten verwendet wird, verwenden Sie das Image "+ busybox +".

  8. Schalten Sie auf der Registerkarte * Command * die Option * Autorestart * auf * Never (Start Once) * (Nie (Einmal starten) * (Nie (Einmal starten)), da dieser Container nur zum Speichern verwendet wird.

  9. Wechseln Sie zur Registerkarte * Volumes * und fügen Sie ein neues Volume hinzu, indem Sie auf die Schaltfläche * Add Volume * klicken. Geben Sie "+ / data / db +" in das angezeigte Textfeld ein. Dies ist der Standardpfad, in dem MongoDB Daten speichert.

  10. Wechseln Sie zur Registerkarte * Scheduling *, klicken Sie auf die Schaltfläche * Add Schedule Rule * und geben Sie die folgenden Parameter ein: + Der Host muss eine Hostbezeichnung vom Typ = database + haben. Verwenden Sie die Dropdown-Listen, um diese Regel zu erstellen.

  11. Klicken Sie auf die Registerkarte * MongoDB * -Dienst, blättern Sie zur Registerkarte * Befehl * und vergewissern Sie sich, dass die Option * Autorestart * auf * Immer * gesetzt ist.

  12. Wechseln Sie zur Registerkarte * Volumes * und wählen Sie * Data * in der Option * Volumes From * aus.

  13. Wechseln Sie zur Registerkarte * Scheduling * und fügen Sie eine neue Scheduling-Regel mit den folgenden Parametern hinzu: + Der Host muss eine Host-Bezeichnung vom Typ = database + haben

  14. Klicken Sie zum Schluss unten auf die Schaltfläche * Erstellen * und warten Sie einige Minuten, bis der Dienst aktiviert ist.

Jetzt konfigurieren wir den Anwendungsdienst.

Schritt 6 - Bereitstellen der Node.js-Anwendung

Wir werden einen ähnlichen Ansatz verwenden, um die zuvor vorbereitete Node.js-Anwendung bereitzustellen. Das in Docker Hub gespeicherte Image wird auf den Hosts mit der Bezeichnung "+ application" oder "bereitgestellt und mit dem MongoDB-Service verknüpft, um Daten zu speichern und auf diese zuzugreifen. Gehen Sie in der Rancher-Benutzeroberfläche folgendermaßen vor:

  1. Wählen Sie das Menü * Stacks *, wählen Sie die Option * User * und klicken Sie dann auf die Schaltfläche * Add Service * im Stapel * Default *.

  2. Wählen Sie im Abschnitt * Scale * die Option * Immer eine Instanz dieses Containers auf jedem Host ausführen *.

  3. Der Name, den wir für diesen Dienst verwenden werden, ist "++".

  4. Für das Image verwenden wir das Image, das wir in Docker Hub bereitgestellt haben. Geben Sie "+ / +" ein.

  5. Klicken Sie auf die Schaltfläche * Service Links *, wählen Sie * Destination Service * und wählen Sie * MongoDB *. Wählen Sie dann * Als Name * und geben Sie "+ db " ein, damit unser " NodeJS +" - Dienst unter diesem Namen auf den MongoDB-Dienst zugreifen kann.

  6. Klicken Sie auf der Registerkarte * Befehl * unten auf der Seite auf die Schaltfläche * Umgebungsvariable hinzufügen *, und fügen Sie eine Variable mit dem Namen "+ MONGO_HOST " und dem Wert " db +" hinzu, die dem Namen des Zieldienstes entspricht, den wir in verwendet haben vorheriger Schritt. Denken Sie daran, dass unsere Anwendung diese Umgebungsvariable verwendet, um den Datenbankserver zu lokalisieren.

  7. Wechseln Sie zur Registerkarte * Scheduling *, klicken Sie auf die Schaltfläche * Add Scheduling Rule * und erstellen Sie mithilfe der Dropdown-Listen eine Regel, die besagt: "+ Der Host muss eine Hostbezeichnung vom Typ = application +" haben.

  8. Klicken Sie abschließend auf * Erstellen * und warten Sie, bis Rancher den Dienst eingerichtet hat.

In Kürze werden Sie feststellen, dass der neue "+ NodeJS " - Dienst zwei Container gestartet hat. Wählen Sie das Menü "Infrastruktur" und klicken Sie auf "Hosts". Daraufhin wird auf beiden Hosts mit der Bezeichnung " application +" dieser neue Dienst ausgeführt. Da es mehrere gibt, richten wir einen Lastenausgleich ein, damit wir beide Hosts effektiv nutzen können.

Schritt 7 - Bereitstellen des Lastenausgleichs

Unser Load Balancer wird mit unseren + NodeJS + - Diensten verknüpft, um die Arbeitslast zwischen allen Containern auf den Anwendungshosts zu verteilen.

  1. Um den Load Balancer zu erstellen, wählen Sie das Menü * Stacks * und anschließend die Option * User *. Klicken Sie dieses Mal auf den Pfeil neben der Schaltfläche "Dienst hinzufügen" und wählen Sie "Load Balancer hinzufügen" aus der Dropdown-Liste aus.

  2. Geben Sie als * Name * + LoadBalancer + ein.

  3. Setzen Sie im Abschnitt * Port Rules * den * Request Host Port * (das erste Portfeld) auf + 80 + und den * Target Port * (das zweite) auf + 3000 + + NodeJS + Container werden verfügbar gemacht.

  4. Wählen Sie in der Option * Target Service * den Dienst * NodeJS * aus, den wir kürzlich erstellt haben.

  5. Klicken Sie auf der Registerkarte * Scheduling * unten auf der Seite auf die Schaltfläche * Add Scheduling Rule * und erstellen Sie eine Regel mit der Aufschrift "+ Der Host muss eine Hostbezeichnung vom Typ = Loadbalancer +" haben.

  6. Klicken Sie abschließend auf "Erstellen" und warten Sie, während Rancher den Dienst aktiviert.

Jedes Mal, wenn wir einen Service erstellt haben, haben wir die von uns erstellten Labels verwendet, um zu bestimmen, wie der Service bereitgestellt wird. Dies macht die Verwaltung zusätzlicher Hosts in Zukunft einfach. Lassen Sie uns nun sicherstellen, dass die Dinge funktionieren.

Schritt 8 - Testen der Anwendung

Zum Testen unserer Anwendung benötigen wir die Adresse des Load Balancer-Hosts. Wählen Sie den * LoadBalancer * -Dienst aus, und die IP-Adresse wird auf der Registerkarte * Ports * angezeigt.

Führen Sie den folgenden Befehl in einem Terminal aus, um zu testen, ob unsere Anwendung funktioniert:

curl

Dieser Befehl sendet eine GET-Anforderung an den Server. Sie erhalten eine Antwort mit einem leeren Array ("+ [] +"), da unsere Datenbank leer ist.

Führen Sie den folgenden Befehl aus, um der Datenbank eine Nachricht hinzuzufügen und sicherzustellen, dass die Anwendung Daten speichern kann:

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

Dieser Befehl sendet eine POST-Anfrage an den Server mit einem JSON-Objekt, das einen + message + - Schlüssel mit dem Wert von enthält. Nach dem Senden der Anfrage sollten Sie dieselbe Nachricht erhalten, die Sie als Antwort gesendet haben, zusammen mit einer + _id + von MongoDB. Dies bedeutet, dass die Verbindung zum MongoDB-Server funktioniert und die Anwendung Ihre Daten gespeichert hat.

Wenn Sie nun überprüfen möchten, ob die Anwendung ordnungsgemäß funktioniert, führen Sie den ersten Befehl erneut aus, und Sie sollten die Meldung erhalten, die Sie im vorherigen Schritt hinzugefügt haben.

curl

Die Ausgabe sieht folgendermaßen aus:

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"}

Zu diesem Zeitpunkt sind zwei Anwendungsserver, eine Datenbank und ein Lastenausgleich konfiguriert und einsatzbereit. Schauen wir uns an, wie Sie unsere Services skalieren, um mehr Verkehr zu bewältigen.

Schritt 9 - Skalieren der Node.js-Server

Wenn Ihre Anwendung einen hohen Bedarf hat und Ihre Server die Last nicht mehr bewältigen können, können Sie die Anzahl der Node.js-Server erhöhen. Die Last wird dann automatisch zwischen den Containern auf die Anwendungshosts verteilt. Führen Sie die folgenden Schritte aus, um Ihre Anwendung zu skalieren:

  1. Gehen Sie zur Seite * Infrastruktur> Hosts * und klicken Sie auf die Schaltfläche * Host hinzufügen *.

  2. Fügen Sie Ihr DigitalOcean * Access Token * in das gleichnamige Feld ein.

  3. Verwenden Sie "+ host5 " als Namen für den ersten neuen Host, da der letzte von uns erstellte Host " host4 " war. Da wir zwei neue Hosts erstellen, benennt Rancher den nächsten automatisch mit " host6 +".

  4. Wählen Sie die gewünschte Menge aus. In diesem Fall werden wir * 2 * weitere Hosts hinzufügen.

  5. Verwenden Sie für * Image * den Standardwert * Ubuntu 16.04.1 x64 *.

  6. Verwenden Sie für * Größe * den Standardwert * 1 GB RAM, 30 GB Festplatte, 1 vCPU *.

  7. Klicken Sie auf die Schaltfläche * Add Label * und geben Sie in der Eingabe * Key * "" ein, und geben Sie dann " application +" in die Eingabe * Value * ein.

  8. Klicken Sie auf die Schaltfläche * Erstellen * und warten Sie, während die neuen Hosts aktiviert und Rancher hinzugefügt werden.

Nachdem die neuen Hosts online geschaltet wurden, werden neue Instanzen der Anwendung "+ NodeJS +" konfiguriert und automatisch bereitgestellt, und der Lastenausgleich verteilt die Arbeitslast auf vier Container auf vier Hosts.

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie eine funktionierende Node.js-Anwendung mit Unterstützung für die Datenspeicherung mit MongoDB vorbereiten, bereitstellen und skalieren. Wie Sie sehen, ist der Prozess mit Rancher und seiner GUI ziemlich intuitiv und es ist einfach, eine vollständige Anwendung zu skalieren. Und dank der Planungsfunktionen von Rancher können Sie die Last mühelos bewältigen, wenn Ihre App auf dem Höhepunkt ist.

Related