TOC

So konfigurieren Sie einen produktionsbereiten Mesosphere-Cluster unter Ubuntu 14.04

Einführung

Mesosphere ist ein System, das eine Reihe von Komponenten kombiniert, um Servercluster und hochverfügbare Bereitstellungen auf einer vorhandenen Betriebssystemschicht effektiv zu verwalten. Im Gegensatz zu Systemen wie CoreOS ist Mesosphere kein spezialisiertes Betriebssystem, sondern eine Reihe von Paketen.

In diesem Handbuch wird beschrieben, wie Sie einen hochverfügbaren Cluster in Mesosphere konfigurieren. In dieser Konfiguration wird ein Failover eingerichtet, falls einer unserer Masterknoten ausfällt, sowie ein Pool von Slave-Servern, um die geplanten Aufgaben zu erledigen.

In diesem Handbuch werden Ubuntu 14.04-Server verwendet.

Voraussetzungen und Ziele

Bevor Sie dieses Handbuch vervollständigen, wird dringend empfohlen, unsere https://www.digitalocean.com/community/tutorials/an-einführung in die Mesosphäre] zu lesen. Dies ist eine gute Möglichkeit, sich mit den Komponenten des Systems vertraut zu machen und zu ermitteln, wofür die einzelnen Einheiten verantwortlich sind.

In diesem Tutorial werden sechs Ubuntu-Server verwendet. Dies entspricht der Empfehlung von Apache Mesos, mindestens drei Master für eine Produktionsumgebung bereitzustellen. Außerdem wird ein Pool von drei Worker- oder Slave-Servern bereitgestellt, denen Arbeit zugewiesen wird, wenn Aufgaben an den Cluster gesendet werden.

Die sechs Server, die wir verwenden werden, verwenden "+ zookeeper +", um den aktuellen Leader der Master-Server zu verfolgen. Die Mesos-Schicht, die darauf aufbaut, bietet verteilte Synchronisation und Ressourcenverwaltung. Es ist für die Verwaltung des Clusters verantwortlich. Marathon, das verteilte Init-System des Clusters, wird verwendet, um Aufgaben zu planen und die Arbeit an die Slave-Server weiterzuleiten.

In diesem Handbuch wird davon ausgegangen, dass unsere Maschinen die folgende Konfiguration haben:

Hostname Function IP Address

master1

Mesos master

192.0.2.1

master2

Mesos master

192.0.2.2

master3

Mesos master

192.0.2.3

slave1

Mesos slave

192.0.2.51

slave2

Mesos slave

192.0.2.52

slave3

Mesos slave

192.0.2.53

Auf jedem dieser Computer sollte Ubuntu 14.04 installiert sein. Sie möchten die grundlegenden Konfigurationselemente vervollständigen, die in unserem Ubuntu 14.04 Einrichtungsanleitung für den Server aufgeführt sind.

Wenn Sie mit den obigen Schritten fertig sind, fahren Sie mit dieser Anleitung fort.

Installieren Sie Mesosphere auf den Servern

Der erste Schritt, um Ihren Cluster zum Laufen zu bringen, ist die Installation der Software. Glücklicherweise unterhält das Mesosphere-Projekt ein Ubuntu-Repository mit aktuellen Paketen, die einfach zu installieren sind.

Fügen Sie Ihren Hosts die Mesosphären-Repositorys hinzu

Führen Sie auf * allen * Hosts (Master und Slaves) die folgenden Schritte aus.

Fügen Sie zunächst das Mesosphere-Repository zu Ihrer Quellenliste hinzu. Bei diesem Vorgang wird der Schlüssel des Mesosphere-Projekts vom Ubuntu-Keyserver heruntergeladen und anschließend die richtige URL für unsere Ubuntu-Version erstellt. Das Projekt bietet dazu eine bequeme Möglichkeit:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv E56151BF
DISTRO=$(lsb_release -is | tr '[:upper:]' '[:lower:]')
CODENAME=$(lsb_release -cs)
echo "deb http://repos.mesosphere.io/${DISTRO} ${CODENAME} main" | sudo tee /etc/apt/sources.list.d/mesosphere.list

Installieren Sie die erforderlichen Komponenten

Nachdem Sie das Mesosphere-Repository zu Ihrem System hinzugefügt haben, müssen Sie Ihren lokalen Paket-Cache aktualisieren, um Zugriff auf die neue Komponente zu erhalten:

sudo apt-get -y update

Als Nächstes müssen Sie die erforderlichen Pakete installieren. Welche Komponenten Sie benötigen, hängt von der Rolle des Hosts ab.

Für Ihre * Master * -Hosts benötigen Sie das Metapaket + mesosphere +. Dies beinhaltet die Anwendungen + zookeeper +, + mesos +, + marathon + und + chronos +:

sudo apt-get install mesosphere

Für Ihre * Slave * -Hosts benötigen Sie nur das + mesos + -Paket, das auch + zookeeper + als Abhängigkeit einsetzt:

sudo apt-get install mesos

Richten Sie die Zookeeper-Verbindungsinformationen für Mesos ein

Das Erste, was wir tun werden, ist, die Verbindungsinformationen Ihres Tierpflegers zu konfigurieren. Dies ist die zugrunde liegende Ebene, auf der sich alle unsere Hosts mit den richtigen Masterservern verbinden können. Es ist also sinnvoll, hier zu beginnen.

Unsere Master-Server werden die einzigen Mitglieder unseres "+ zookeeper " - Clusters sein, aber alle unsere Server benötigen eine gewisse Konfiguration, um mit dem Protokoll kommunizieren zu können. Die Datei, die dies definiert, ist " / etc / mesos / zk +".

Führen Sie auf * allen * Hosts den folgenden Schritt aus. Öffnen Sie die Datei mit Root-Rechten:

sudo nano /etc/mesos/zk

Im Inneren finden Sie die Verbindungs-URL, die standardmäßig für den Zugriff auf eine lokale Instanz festgelegt ist. Es wird so aussehen:

zk://localhost:2181/mesos

Wir müssen dies ändern, um auf unsere drei Master-Server zu verweisen. Ersetzen Sie dazu "+ localhost +" durch die IP-Adresse unseres ersten Mesos-Masterservers. Anschließend können wir nach der Portspezifikation ein Komma einfügen und das Format replizieren, um unseren zweiten und dritten Master zur Liste hinzuzufügen.

In unserem Handbuch haben unsere Master die IP-Adressen "+ 192.0.2.1 ", " 192.168.2.2 " und " 192.168.2.3 +". Unter Verwendung dieser Werte sieht unsere Datei folgendermaßen aus:

zk://:2181,:2181,:2181/mesos

Die Zeile muss mit + zk: // + beginnen und mit + / mesos + enden. Dazwischen werden die IP-Adressen Ihres Masterservers und die Zookeeper-Ports (standardmäßig 2181) angegeben.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Verwenden Sie diesen identischen Eintrag in jedem Ihrer Master und Slaves. Auf diese Weise kann jeder einzelne Server eine Verbindung zu den richtigen Masterservern herstellen, um mit dem Cluster zu kommunizieren.

Konfigurieren Sie die Zookeeper-Konfiguration des Masterservers

Auf Ihren * Master * Servern müssen wir einige zusätzliche + zookeeper + Konfigurationen vornehmen.

Der erste Schritt besteht darin, eine eindeutige ID-Nummer von 1 bis 255 für jeden Ihrer Master-Server zu definieren. Dies wird in der Datei "+ / etc / zookeeper / conf / myid +" gespeichert. Öffne es jetzt:

sudo nano /etc/zookeeper/conf/myid

Löschen Sie alle Informationen in dieser Datei und ersetzen Sie sie durch eine einzelne Zahl von 1 bis 255. Jeder Ihrer Master-Server muss eine eindeutige Nummer haben. Der Einfachheit halber ist es am einfachsten, bei 1 zu beginnen und sich nach oben zu arbeiten. Wir werden 1, 2 und 3 für unseren Führer verwenden.

Unser erster Server wird dies nur in der Datei haben:

1

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Tun Sie dies auf jedem Ihrer Master-Server.

Als nächstes müssen wir die Konfigurationsdatei Ihres Tierpflegers ändern, um unsere Tierpfleger-ID den tatsächlichen Hosts zuzuordnen. Dadurch wird sichergestellt, dass der Dienst jeden Host korrekt aus dem von ihm verwendeten ID-System auflösen kann.

Öffne jetzt die + zookeeper + Konfigurationsdatei:

sudo nano /etc/zookeeper/conf/zoo.cfg

In dieser Datei müssen Sie jede ID einem Host zuordnen. Die Host-Spezifikation enthält zwei Ports, der erste für die Kommunikation mit dem Leiter und der zweite für die Abwicklung von Wahlen, wenn ein neuer Leiter erforderlich ist. Die "+ zookeeper +" - Server werden durch "server" gefolgt von einem Punkt und ihrer ID-Nummer identifiziert.

Für unsere Anleitung verwenden wir die Standardports für jede Funktion und unsere IDs sind 1-3. Unsere Datei sieht folgendermaßen aus:

server.=:2888:3888
server.=:2888:3888
server.=:2888:3888

Fügen Sie die gleichen Zuordnungen in die Konfigurationsdateien Ihrer Master-Server ein. Speichern und schließen Sie jede Datei, wenn Sie fertig sind.

Damit ist unsere + zookeeper + Konfiguration abgeschlossen. Wir können anfangen, uns auf Mesos und Marathon zu konzentrieren.

Konfigurieren Sie Mesos auf den Master-Servern

Als nächstes konfigurieren wir Mesos auf den drei Masterservern. Diese Schritte sollten auf jedem Ihrer Master-Server ausgeführt werden.

Ändern Sie das Quorum entsprechend Ihrer Clustergröße

Erstens müssen wir das Quorum anpassen, das für Entscheidungen erforderlich ist. Hierdurch wird die Anzahl der Hosts bestimmt, die für den Cluster erforderlich sind, damit dieser in einem funktionsfähigen Zustand ist.

Das Quorum sollte so festgelegt werden, dass über 50 Prozent der Master-Mitglieder anwesend sein müssen, um Entscheidungen zu treffen. Wir möchten jedoch auch eine gewisse Fehlertoleranz einbauen, damit der Cluster weiterhin funktioniert, wenn nicht alle unsere Master vorhanden sind.

Wir haben drei Master, daher ist die einzige Einstellung, die diese beiden Anforderungen erfüllt, ein Quorum von zwei. Da für die Erstkonfiguration ein einzelnes Server-Setup vorausgesetzt wird, ist das Quorum derzeit auf eins festgelegt.

Öffnen Sie die Quorum-Konfigurationsdatei:

sudo nano /etc/mesos-master/quorum

Ändern Sie den Wert auf "2":

2

Speichern und schließen Sie die Datei. Wiederholen Sie dies auf jedem Ihrer Master-Server.

Konfigurieren Sie den Hostnamen und die IP-Adresse

Als Nächstes geben wir den Hostnamen und die IP-Adresse für jeden unserer Masterserver an. Wir werden die IP-Adresse für den Hostnamen verwenden, damit unsere Instanzen keine Probleme bei der korrekten Auflösung haben.

Für unsere Master-Server muss die IP-Adresse in diesen Dateien gespeichert werden:

  • / etc / mesos-master / ip

  • / etc / mesos-master / hostname

Fügen Sie zunächst die individuelle IP-Adresse jedes Masterknotens in die Datei "+ / etc / mesos-master / ip +" ein. Denken Sie daran, dies für jeden Server so zu ändern, dass es dem entsprechenden Wert entspricht:

echo  | sudo tee /etc/mesos-master/ip

Jetzt können wir diesen Wert in die Hostnamensdatei kopieren:

sudo cp /etc/mesos-master/ip /etc/mesos-master/hostname

Tun Sie dies auf jedem Ihrer Master-Server.

Konfigurieren Sie Marathon auf den Master-Servern

Nach der Konfiguration von Mesos können wir Marathon, die Clustered-Init-System-Implementierung von Mesosphere, konfigurieren.

Marathon wird auf jedem unserer Master-Hosts ausgeführt, aber nur der führende Master-Server kann tatsächlich Jobs planen. Die anderen Marathon-Instanzen stellen transparente Proxy-Anfragen an den Master-Server.

Zunächst müssen wir den Hostnamen für die Marathon-Instanz jedes Servers erneut festlegen. Auch hier verwenden wir die IP-Adresse, die wir bereits in einer Datei haben. Wir können das an den Speicherort kopieren, den wir brauchen.

Die von uns benötigte Marathon-Konfigurationsverzeichnisstruktur wird jedoch nicht automatisch erstellt. Wir müssen das Verzeichnis erstellen und dann können wir die Datei kopieren über:

sudo mkdir -p /etc/marathon/conf
sudo cp /etc/mesos-master/hostname /etc/marathon/conf

Als nächstes müssen wir die Liste der "+ Zookeeper " - Meister definieren, mit denen Marathon eine Verbindung herstellen wird, um Informationen zu erhalten und eine Planung vorzunehmen. Dies ist die gleiche " zookeeper " - Verbindungszeichenfolge, die wir für Mesos verwendet haben, sodass wir die Datei einfach kopieren können. Wir müssen es in eine Datei mit dem Namen " master +" einfügen:

sudo cp /etc/mesos/zk /etc/marathon/conf/master

Dadurch kann unser Marathon-Service eine Verbindung zum Mesos-Cluster herstellen. Wir möchten jedoch auch, dass Marathon seine eigenen Statusinformationen in + zookeeper + speichert. Dazu verwenden wir die andere Verbindungsdatei "+ zookeeper +" als Basis und ändern nur den Endpunkt.

Kopieren Sie zunächst die Datei in den Speicherort des Marathon-Tierpflegers:

sudo cp /etc/marathon/conf/master /etc/marathon/conf/zk

Öffnen Sie als Nächstes die Datei in Ihrem Editor:

sudo nano /etc/marathon/conf/zk

Der einzige Teil, den wir in dieser Datei ändern müssen, ist der Endpunkt. Wir werden es von "+ / mesos" in "+ / marathon" ändern:

zk://192.0.2.1:2181,192.0.2.2:2181,192.0.2.3:2181/

Dies ist alles, was wir für unsere Marathon-Konfiguration tun müssen.

Konfigurieren Sie Service Init Rules und starten Sie Services neu

Als Nächstes werden wir die Dienste unserer Masterserver neu starten, um die von uns konfigurierten Einstellungen zu verwenden.

Zunächst müssen wir sicherstellen, dass auf unseren Master-Servern nur der Mesos-Master-Prozess und nicht der Slave-Prozess ausgeführt wird. Wir können alle derzeit ausgeführten Slave-Prozesse stoppen (dies kann fehlschlagen, aber das ist in Ordnung, da nur sichergestellt werden soll, dass der Prozess gestoppt wird). Wir können auch sicherstellen, dass der Server den Slave-Prozess beim Booten nicht startet, indem wir eine Überschreibungsdatei erstellen:

sudo stop mesos-slave
echo manual | sudo tee /etc/init/mesos-slave.override

Jetzt müssen wir nur noch + zookeeper + neu starten, um unsere Masterwahlen vorzubereiten. Wir können dann unsere Mesos-Master- und Marathon-Prozesse starten:

sudo restart zookeeper
sudo start mesos-master
sudo start marathon

Besuchen Sie einen Ihrer Master-Server in Ihrem Webbrowser unter Port "+ 5050 +", um einen Überblick über die Einstellungen zu erhalten:

http://:5050

Sie sollten die Hauptoberfläche von Mesos sehen. Je nachdem, ob Sie sich mit dem gewählten Anführer verbunden haben oder nicht, wird Ihnen möglicherweise mitgeteilt, dass Sie zum aktiven Master umgeleitet werden. In beiden Fällen sieht der Bildschirm folgendermaßen aus:

image: https://assets.digitalocean.com/articles/mesos_cluster/mesos_main.png [Mesos-Hauptschnittstelle]

Dies ist eine Ansicht Ihres Clusters. Es gibt nicht viel zu sehen, da keine Slave-Knoten verfügbar sind und keine Aufgaben gestartet wurden.

Wir haben auch Marathon konfiguriert, den langjährigen Task-Controller von Mesosphere. Dies ist auf jedem Ihrer Master am Port "+ 8080 +" verfügbar:

Bild: https://assets.digitalocean.com/articles/mesos_cluster/marathon_main.png [Marathon-Hauptoberfläche]

Sobald wir unsere Slaves eingerichtet haben, werden wir uns kurz mit der Verwendung dieser Schnittstellen befassen.

Konfigurieren Sie die Slave-Server

Nachdem wir unsere Master-Server konfiguriert haben, können wir mit der Konfiguration unserer Slave-Server beginnen.

Wir haben unsere Slaves bereits mit den Verbindungsinformationen unserer Masterserver konfiguriert. Die Slaves selbst führen keine eigenen "+ zookeeper +" - Instanzen aus.

Wir können jeden "+ zookeeper +" - Prozess stoppen, der derzeit auf unseren Slave-Knoten ausgeführt wird, und eine Überschreibungsdatei erstellen, damit diese beim Neustart des Servers nicht automatisch gestartet wird:

sudo stop zookeeper
echo manual | sudo tee /etc/init/zookeeper.override

Als Nächstes möchten wir eine weitere Überschreibungsdatei erstellen, um sicherzustellen, dass der Mesos-Master-Prozess auf unseren Slave-Servern nicht gestartet wird. Wir werden auch sicherstellen, dass es momentan gestoppt ist (dieser Befehl kann fehlschlagen, wenn der Prozess bereits gestoppt ist. Das ist kein Problem):

echo manual | sudo tee /etc/init/mesos-master.override
sudo stop mesos-master

Als nächstes müssen wir die IP-Adresse und den Hostnamen genau wie für unsere Master-Server festlegen. Dazu muss die IP-Adresse jedes Knotens in eine Datei eingetragen werden, diesmal im Verzeichnis "+ / etc / mesos-slave +". Wir werden dies auch als Hostnamen verwenden, um über das Webinterface einfach auf Dienste zugreifen zu können:

echo  | sudo tee /etc/mesos-slave/ip
sudo cp /etc/mesos-slave/ip /etc/mesos-slave/hostname

Verwenden Sie erneut die individuelle IP-Adresse jedes Slave-Servers für den ersten Befehl. Dadurch wird sichergestellt, dass es an die richtige Schnittstelle gebunden wird.

Jetzt haben wir alle Teile an Ort und Stelle, um unsere Mesos-Sklaven zu starten. Wir müssen nur den Dienst einschalten:

sudo start mesos-slave

Tun Sie dies auf jeder Ihrer Slave-Maschinen.

Um festzustellen, ob sich Ihre Slaves erfolgreich in Ihrem Cluster registrieren, kehren Sie zu Ihrem Master-Server an Port "+ 5050 +" zurück:

http://:5050

Sie sollten jetzt die Anzahl der aktiven Slaves bei „3“ in der Benutzeroberfläche sehen:

image: https://assets.digitalocean.com/articles/mesos_cluster/three_slaves.png [Mesos drei Sklaven]

Sie können auch feststellen, dass die verfügbaren Ressourcen in der Benutzeroberfläche aktualisiert wurden, um die Poolressourcen Ihrer Slave-Maschinen widerzuspiegeln:

image: https://assets.digitalocean.com/articles/mesos_cluster/resources.png [Mesos-Ressourcen]

Um zusätzliche Informationen zu jedem Ihrer Slave-Computer zu erhalten, klicken Sie oben in der Benutzeroberfläche auf den Link „Slaves“. Auf diese Weise erhalten Sie einen Überblick über den Ressourcenbeitrag der einzelnen Maschinen sowie Links zu einer Seite für jeden Slave:

image: https://assets.digitalocean.com/articles/mesos_cluster/slaves_page.png [Mesos-Sklavenseite]

Starten von Diensten auf Mesos und Marathon

Marathon ist das Dienstprogramm von Mesosphere zum Planen von Aufgaben mit langer Laufzeit. Man kann sich Marathon leicht als Init-System für einen Mesosphere-Cluster vorstellen, da es das Starten und Stoppen von Diensten, das Planen von Aufgaben und das Wiederherstellen von Anwendungen nach einem Ausfall übernimmt.

Sie können Marathon auf verschiedene Arten Dienste und Aufgaben hinzufügen. Wir werden nur Grundleistungen abdecken. Docker-Container werden in einem zukünftigen Leitfaden behandelt.

Starten eines Dienstes über das Webinterface

Die einfachste Möglichkeit, einen Dienst schnell im Cluster zum Laufen zu bringen, besteht darin, eine Anwendung über die Marathon-Weboberfläche hinzuzufügen.

Besuchen Sie zunächst die Marathon-Weboberfläche auf einem Ihrer Masterserver. Denken Sie daran, die Marathon-Schnittstelle befindet sich an Port "+ 8080 +":

http://:8080

Von hier aus können Sie auf die Schaltfläche "Neue App" in der oberen rechten Ecke klicken. Daraufhin wird eine Überlagerung angezeigt, in der Sie Informationen zu Ihrer neuen Anwendung hinzufügen können:

Bild: https://assets.digitalocean.com/articles/mesos_cluster/marathon_new_app.png [Neue Marathon-App]

Füllen Sie die Felder mit den Anforderungen für Ihre App aus. Die einzigen Pflichtfelder sind:

  • * ID *: Eine eindeutige ID, die vom Benutzer zur Identifizierung eines Prozesses ausgewählt wird. Dies kann alles sein, was Sie möchten, muss aber eindeutig sein.

  • * Befehl *: Dies ist der aktuelle Befehl, der von Marathon ausgeführt wird. Dies ist der Prozess, der überwacht und neu gestartet wird, wenn er fehlschlägt.

Mit diesen Informationen können Sie einen einfachen Dienst einrichten, der nur "Hallo" ausgibt und 10 Sekunden lang inaktiv ist. Wir werden dies "Hallo" nennen:

Bild: https://assets.digitalocean.com/articles/mesos_cluster/simple_app.png [Marathon einfache App]

Wenn Sie zur Benutzeroberfläche zurückkehren, wechselt der Dienst von "Bereitstellen" zu "Ausführen":

image: https://assets.digitalocean.com/articles/mesos_cluster/running.png [Marathon-App wird ausgeführt]

Etwa alle 10 Sekunden wechselt der Messwert für "Tasks / Instances" von "1/1" auf "0/1", wenn die Schlafmenge verstrichen ist und der Dienst beendet wird. Marathon startet die Aufgabe dann automatisch neu. Wir können diesen Prozess in der Mesos-Weboberfläche unter Port + 5050 + deutlicher sehen:

http://:5050

Hier können Sie sehen, wie der Prozess beendet und neu gestartet wird:

image: https://assets.digitalocean.com/articles/mesos_cluster/restart_task.png [Mesos-Neustartaufgabe]

Wenn Sie bei einer der Aufgaben auf „Sandbox“ und dann auf „stdout“ klicken, wird die Ausgabe „Hallo“ angezeigt:

image: https://assets.digitalocean.com/articles/mesos_cluster/output.png [Mesos-Ausgabe]

Starten eines Dienstes über die API

Wir können Services auch über die API von Marathon einreichen. Hierbei wird ein JSON-Objekt übergeben, das alle im Overlay enthaltenen Felder enthält.

Dies ist ein relativ einfacher Vorgang. Wiederum sind die einzigen erforderlichen Felder "+ id " für die Prozesskennung und " cmd +", die den tatsächlich auszuführenden Befehl enthalten.

Wir könnten also eine JSON-Datei mit dem Namen "+ hello.json +" mit folgenden Informationen erstellen:

nano hello.json

Im Inneren würde die Mindestspezifikation folgendermaßen aussehen:

{
   "id": "hello2",
   "cmd": "echo hello; sleep 10"
}

Dieser Service wird gut funktionieren. Wenn wir jedoch den in der Web-Benutzeroberfläche erstellten Service wirklich emulieren möchten, müssen wir einige zusätzliche Felder hinzufügen. Diese wurden in der Web-Benutzeroberfläche als Standard festgelegt und können hier repliziert werden:

{
   "id": "hello2",
   "cmd": "echo hello; sleep 10",
   "mem": 16,
   "cpus": 0.1,
   "instances": 1,
   "disk": 0.0,
   "ports": [0]
}

Speichern und schließen Sie die JSON-Datei, wenn Sie fertig sind.

Als nächstes können wir es mit der Marathon-API einreichen. Das Ziel ist einer der Marathon-Dienste unseres Masters an Port "+ 8080 " und der Endpunkt ist " / v2 / apps ". Die Datennutzlast ist unsere JSON-Datei, die wir in " curl " einlesen können, indem wir das Flag " -d " mit dem Flag " @ +" verwenden, um eine Datei anzugeben.

Der Befehl zum Senden sieht folgendermaßen aus:

curl -i -H 'Content-Type: application/json' [email protected] :8080/v2/apps

Wenn wir uns die Marathon-Oberfläche ansehen, können wir sehen, dass sie erfolgreich hinzugefügt wurde. Es scheint genau die gleichen Eigenschaften zu haben wie unser erster Service:

image: https: //assets.digitalocean.com/articles/mesos_cluster/two_services.png [Marathon two services]

Der neue Dienst kann genauso überwacht und aufgerufen werden wie der erste Dienst.

Fazit

Zu diesem Zeitpunkt sollte ein produktionsfertiger Mesosphere-Cluster eingerichtet und ausgeführt werden. Wir haben an dieser Stelle nur die Grundkonfiguration behandelt, aber Sie sollten in der Lage sein, die Möglichkeiten der Nutzung des Mesosphärensystems zu erkennen.

In zukünftigen Handbüchern wird erläutert, wie Sie Docker-Container in Ihrem Cluster bereitstellen und einige der Tools ausführlicher verwenden.

Related