TOC

Comment configurer un cluster de mésosphère prêt pour la production sur Ubuntu 14.04

introduction

Mesosphere est un système qui combine un certain nombre de composants pour gérer efficacement le clustering de serveurs et les déploiements à haute disponibilité au-dessus d’une couche de système d’exploitation existante. Contrairement à des systèmes tels que CoreOS, Mesosphere n’est pas un système d’exploitation spécialisé, mais un ensemble de packages.

Dans ce guide, nous verrons comment configurer un cluster à haute disponibilité dans Mesosphere. Cette configuration nous établira avec le basculement au cas où l’un de nos nœuds maîtres tomberait en panne, ainsi qu’un pool de serveurs esclaves pour gérer les tâches planifiées.

Nous utiliserons les serveurs Ubuntu 14.04 pour ce guide.

Prérequis et objectifs

Avant de terminer ce guide, il est fortement recommandé de consulter notre introduction to Mesosphere. C’est un bon moyen de vous familiariser avec les composants du système et de vous aider à identifier les responsabilités de chaque unité.

Au cours de ce tutoriel, nous utiliserons six serveurs Ubuntu. Cela répond à la recommandation d’Apache Mesos d’avoir au moins trois maîtres pour un environnement de production. Il fournit également un pool de trois serveurs de travail ou esclaves, auxquels le travail est attribué lorsque des tâches sont envoyées au cluster.

Les six serveurs que nous utiliserons utiliseront + zookeeper + pour garder la trace du leader actuel des serveurs maîtres. La couche Mesos, construite au-dessus de celle-ci, assurera la synchronisation distribuée et la gestion des ressources. Il est responsable de la gestion du cluster. Marathon, le système d’initialisation distribué du cluster, est utilisé pour planifier des tâches et effectuer un travail manuel sur les serveurs esclaves.

Pour les besoins de ce guide, nous supposerons que nos machines ont la configuration suivante:

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

Ubuntu 14.04 doit être installé sur chacune de ces machines. Vous voudrez compléter les éléments de configuration de base répertoriés dans notre Ubuntu 14.04 - Guide de configuration du serveur initial.

Lorsque vous avez terminé les étapes ci-dessus, continuez avec ce guide.

Installer la mésosphère sur les serveurs

La première étape pour que votre cluster soit opérationnel consiste à installer le logiciel. Heureusement, le projet Mesosphere maintient un référentiel Ubuntu avec des paquetages à jour faciles à installer.

Ajouter les référentiels de la mésosphère à vos hôtes

Sur * tous * les hôtes (maîtres et esclaves), procédez comme suit.

Tout d’abord, ajoutez le référentiel Mesosphere à votre liste de sources. Ce processus implique le téléchargement de la clé du projet Mesosphere à partir du serveur de clés Ubuntu, puis la création de l’URL correcte pour notre version Ubuntu. Le projet fournit un moyen pratique de le faire:

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

Installer les composants nécessaires

Une fois le référentiel Mesosphere ajouté à votre système, vous devez mettre à jour votre cache de package local pour pouvoir accéder au nouveau composant:

sudo apt-get -y update

Ensuite, vous devez installer les packages nécessaires. Les composants dont vous avez besoin dépendent du rôle de l’hôte.

Pour vos hôtes * maîtres *, vous avez besoin du méta-paquet + mesosphere +. Cela inclut les applications + zookeeper +, + mesos +, + marathon + et + chronos +:

sudo apt-get install mesosphere

Pour vos hôtes * esclaves *, vous n’avez besoin que du paquet + mesos +, qui ajoute également + zookeeper + en tant que dépendance:

sudo apt-get install mesos

Configurer les informations de connexion Zookeeper pour Mesos

La première chose à faire est de configurer les informations de connexion + zookeeper. C’est la couche sous-jacente qui permet à tous nos hôtes de se connecter aux serveurs maîtres appropriés. Il est donc logique de commencer ici.

Nos serveurs maîtres seront les seuls membres de notre cluster + zookeeper +, mais tous nos serveurs auront besoin d’une configuration pour pouvoir communiquer en utilisant le protocole. Le fichier qui définit ceci est + / etc / mesos / zk +.

Sur * tous * de vos hôtes, effectuez l’étape suivante. Ouvrez le fichier avec les privilèges root:

sudo nano /etc/mesos/zk

À l’intérieur, vous constaterez que l’URL de connexion est définie par défaut pour accéder à une instance locale. Il ressemblera à ceci:

zk://localhost:2181/mesos

Nous devons modifier cela pour qu’il pointe vers nos trois serveurs maîtres. Ceci est fait en remplaçant + localhost + par l’adresse IP de notre premier serveur maître Mesos. Nous pouvons ensuite ajouter une virgule après la spécification du port et répliquer le format pour ajouter nos deuxième et troisième maîtres à la liste.

Pour notre guide, nos maîtres ont des adresses IP de «+ 192.0.2.1 », « 192.168.2.2 » et « 192.168.2.3 +». En utilisant ces valeurs, notre fichier ressemblera à ceci:

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

La ligne doit commencer par + zk: // + et se terminer par + / mesos +. Entre les deux, les adresses IP et les ports + zookeeper + de votre serveur maître (+ 2181 + par défaut) sont spécifiés.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Utilisez cette entrée identique dans chacun de vos maîtres et esclaves. Cela aidera chaque serveur individuel à se connecter aux serveurs maîtres appropriés pour communiquer avec le cluster.

Configurer la configuration du serveur Zookeeper des serveurs maîtres

Sur vos serveurs * maîtres *, nous devrons faire une configuration supplémentaire + zookeeper +.

La première étape consiste à définir un numéro d’identification unique, compris entre 1 et 255, pour chacun de vos serveurs maîtres. Ceci est conservé dans le fichier + / etc / zookeeper / conf / myid +. Ouvrez-le maintenant:

sudo nano /etc/zookeeper/conf/myid

Supprimez toutes les informations de ce fichier et remplacez-le par un seul numéro, compris entre 1 et 255. Chacun de vos serveurs maîtres doit avoir un numéro unique. Par souci de simplicité, il est plus facile de commencer à 1 et de progresser. Nous utiliserons 1, 2 et 3 pour notre guide.

Notre premier serveur aura juste cela dans le fichier:

1

Enregistrez et fermez le fichier lorsque vous avez terminé. Faites cela sur chacun de vos serveurs maîtres.

Ensuite, nous devons modifier votre fichier de configuration + zookeeper pour mapper notre ID` + zookeeper` aux hôtes actuels. Cela garantira que le service peut résoudre correctement chaque hôte à partir du système ID utilisé.

Ouvrez le fichier de configuration + zookeeper + maintenant:

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

Dans ce fichier, vous devez mapper chaque ID sur un hôte. La spécification de l’hôte comprendra deux ports, le premier pour la communication avec le chef et le second pour la gestion des élections lorsqu’un nouveau chef est requis. Les serveurs + zookeeper + sont identifiés par «serveur» suivi d’un point et de leur numéro d’identification.

Pour notre guide, nous utiliserons les ports par défaut pour chaque fonction et nos identifiants sont 1 à 3. Notre fichier ressemblera à ceci:

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

Ajoutez ces mêmes mappages dans chacun des fichiers de configuration de vos serveurs maîtres. Enregistrez et fermez chaque fichier lorsque vous avez terminé.

Avec cela, notre configuration + zookeeper + est terminée. Nous pouvons commencer à nous concentrer sur Mesos et Marathon.

Configurer les Mesos sur les serveurs maîtres

Ensuite, nous allons configurer Mesos sur les trois serveurs maîtres. Ces étapes doivent être effectuées sur chacun de vos serveurs maîtres.

Modifier le quorum pour refléter la taille de votre cluster

Premièrement, nous devons ajuster le quorum nécessaire pour prendre des décisions. Cela déterminera le nombre d’hôtes nécessaires au bon fonctionnement du cluster.

Le quorum doit être défini de manière à ce que plus de 50% des membres principaux soient présents pour prendre des décisions. Cependant, nous souhaitons également intégrer une certaine tolérance aux pannes afin que, si tous nos maîtres ne soient pas présents, le cluster puisse toujours fonctionner.

Nous avons trois maîtres, donc le seul paramètre qui satisfait à ces deux exigences est un quorum de deux. Étant donné que la configuration initiale suppose une configuration à serveur unique, le quorum est actuellement défini sur un.

Ouvrez le fichier de configuration du quorum:

sudo nano /etc/mesos-master/quorum

Changez la valeur en "2":

2

Enregistrez et fermez le fichier. Répétez cette opération sur chacun de vos serveurs maîtres.

Configurez le nom d’hôte et l’adresse IP

Ensuite, nous allons spécifier le nom d’hôte et l’adresse IP de chacun de nos serveurs maîtres. Nous allons utiliser l’adresse IP pour le nom d’hôte afin que nos instances n’aient pas de problèmes à résoudre correctement.

Pour nos serveurs maîtres, l’adresse IP doit être placée dans ces fichiers:

  • / etc / mesos-master / ip

  • / etc / mesos-master / hostname

Tout d’abord, ajoutez l’adresse IP individuelle de chaque nœud maître dans le fichier + / etc / mesos-master / ip +. N’oubliez pas de changer cela pour chaque serveur afin qu’il corresponde à la valeur appropriée:

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

Maintenant, nous pouvons copier cette valeur dans le fichier de nom d’hôte:

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

Faites cela sur chacun de vos serveurs maîtres.

Configurer Marathon sur les serveurs maîtres

Maintenant que Mesos est configuré, nous pouvons configurer Marathon, l’implémentation du système init en cluster de Mesosphere.

Marathon fonctionnera sur chacun de nos hôtes maîtres, mais seul le principal serveur maître sera en mesure de planifier les travaux. Les autres instances de Marathon adresseront de manière transparente les requêtes au serveur maître.

Tout d’abord, nous devons redéfinir le nom d’hôte pour chaque instance Marathon de chaque serveur. Encore une fois, nous allons utiliser l’adresse IP, que nous avons déjà dans un fichier. Nous pouvons copier cela à l’emplacement du fichier dont nous avons besoin.

Cependant, la structure de répertoire de configuration Marathon dont nous avons besoin n’est pas créée automatiquement. Nous devrons créer le répertoire et ensuite copier le fichier par dessus:

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

Ensuite, nous devons définir la liste des maîtres + zookeeper + auxquels Marathon se connectera pour des informations et la planification. Il s’agit de la même chaîne de connexion + zookeeper + que celle que nous utilisions pour Mesos. Nous pouvons donc simplement copier le fichier. Nous devons le placer dans un fichier nommé + master +:

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

Cela permettra à notre service Marathon de se connecter au cluster Mesos. Cependant, nous voulons également que Marathon stocke ses propres informations d’état dans + zookeeper +. Pour cela, nous utiliserons l’autre fichier de connexion + zookeeper + comme base, et nous ne ferons que modifier le noeud final.

Commencez par copier le fichier à l’emplacement du gardien de zoo Marathon:

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

Ensuite, ouvrez le fichier dans votre éditeur:

sudo nano /etc/marathon/conf/zk

La seule partie que nous devons modifier dans ce fichier est le noeud final. Nous allons le changer de + / mesos en` + / marathon`:

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

C’est tout ce que nous devons faire pour notre configuration Marathon.

Configurer les règles d’initialisation de service et redémarrer les services

Nous allons ensuite redémarrer les services de nos serveurs maîtres pour utiliser les paramètres que nous avons configurés.

Tout d’abord, nous devons nous assurer que nos serveurs maîtres exécutent uniquement le processus maître Mesos et non le processus esclave. Nous pouvons arrêter tous les processus esclaves en cours d’exécution (cela peut échouer, mais cela n’est pas grave car il s’agit simplement d’assurer l’arrêt du processus). Nous pouvons également nous assurer que le serveur ne démarre pas le processus esclave au démarrage en créant un fichier de remplacement:

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

Maintenant, tout ce que nous avons à faire est de redémarrer + zookeeper +, ce qui établira nos élections principales. Nous pouvons ensuite démarrer nos processus de maître Mesos et Marathon:

sudo restart zookeeper
sudo start mesos-master
sudo start marathon

Pour avoir un aperçu de ce que vous venez de configurer, visitez l’un de vos serveurs maîtres dans votre navigateur Web sur le port + 5050 +:

http://:5050

Vous devriez voir l’interface principale de Mesos. On vous dira peut-être que vous êtes redirigé vers le maître actif, selon que vous soyez connecté ou non au chef élu. Dans tous les cas, l’écran ressemblera à ceci:

image: https: //assets.digitalocean.com/articles/mesos_cluster/mesos_main.png [interface principale de Mesos]

Ceci est une vue de votre cluster actuellement. Il n’y a pas grand chose à voir car il n’y a pas de nœuds esclaves disponibles et aucune tâche démarrée.

Nous avons également configuré Marathon, le contrôleur de tâches de longue durée de Mesosphere. Ce sera disponible au port + 8080 + sur n’importe lequel de vos maîtres:

image: https: //assets.digitalocean.com/articles/mesos_cluster/marathon_main.png [interface principale de Marathon]

Nous verrons brièvement comment utiliser ces interfaces une fois que nous aurons configuré nos esclaves.

Configurer les serveurs esclaves

Maintenant que nos serveurs maîtres sont configurés, nous pouvons commencer à configurer nos serveurs esclaves.

Nous avons déjà configuré nos esclaves avec les informations de connexion + zookeeper + de nos serveurs maîtres. Les esclaves eux-mêmes ne gèrent pas leurs propres instances + zookeeper +.

Nous pouvons arrêter tout processus + zookeeper + en cours d’exécution sur nos nœuds esclaves et créer un fichier de substitution afin qu’il ne démarre pas automatiquement au redémarrage du serveur:

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

Ensuite, nous voulons créer un autre fichier de remplacement pour nous assurer que le processus maître Mesos ne démarre pas sur nos serveurs esclaves. Nous allons également nous assurer qu’il est actuellement arrêté (cette commande peut échouer si le processus est déjà arrêté. Ce n’est pas un problème):

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

Ensuite, nous devons définir l’adresse IP et le nom d’hôte, comme nous l’avons fait pour nos serveurs maîtres. Cela implique de mettre l’adresse IP de chaque nœud dans un fichier, cette fois dans le répertoire + / etc / mesos-slave +. Nous allons également utiliser ce nom d’hôte pour faciliter l’accès aux services via l’interface Web:

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

De nouveau, utilisez l’adresse IP individuelle de chaque serveur esclave pour la première commande. Cela garantira qu’il est lié à la bonne interface.

Maintenant, nous avons toutes les pièces en place pour commencer nos esclaves Mesos. Nous devons juste activer le service:

sudo start mesos-slave

Faites cela sur chacune de vos machines esclaves.

Pour savoir si vos esclaves s’enregistrent correctement dans votre cluster, retournez sur l’un de vos serveurs maîtres au port + 5050 +:

http://:5050

Vous devriez voir le nombre d’esclaves actifs à “3” maintenant dans l’interface:

image: https: //assets.digitalocean.com/articles/mesos_cluster/three_slaves.png [Mesos trois esclaves]

Vous pouvez également voir que les ressources disponibles dans l’interface ont été mises à jour pour refléter les ressources en pool de vos machines esclaves:

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

Pour obtenir des informations supplémentaires sur chacune de vos machines esclaves, vous pouvez cliquer sur le lien «Esclaves» en haut de l’interface. Cela vous donnera un aperçu de la contribution de chaque machine aux ressources, ainsi que des liens vers une page pour chaque esclave:

image: https: //assets.digitalocean.com/articles/mesos_cluster/slaves_page.png [Page de Mesos Slaves]

Début des services sur Mesos et Marathon

Marathon est l’utilitaire de Mesosphere pour la planification de tâches de longue durée. Il est facile de penser à Marathon en tant que système d’initialisation pour un cluster Mesosphere, car il gère le démarrage et l’arrêt des services, la planification des tâches et la vérification de la réactivité des applications.

Vous pouvez ajouter des services et des tâches à Marathon de différentes manières. Nous ne couvrirons que les services de base. Les conteneurs Docker seront traités dans un futur guide.

Démarrage d’un service via l’interface Web

Le moyen le plus simple de faire fonctionner rapidement un service sur le cluster consiste à ajouter une application via l’interface Web de Marathon.

Tout d’abord, visitez l’interface Web Marathon sur l’un de vos serveurs maîtres. N’oubliez pas que l’interface Marathon est sur le port + 8080 +:

http://:8080

De là, vous pouvez cliquer sur le bouton «Nouvelle application» dans le coin supérieur droit. Cela fera apparaître une superposition où vous pouvez ajouter des informations sur votre nouvelle application:

image: https: //assets.digitalocean.com/articles/mesos_cluster/marathon_new_app.png [nouvelle application Marathon]

Remplissez les champs avec les exigences de votre application. Les seuls champs obligatoires sont:

  • * ID *: ID unique sélectionné par l’utilisateur pour identifier un processus. Cela peut être ce que vous voulez, mais doit être unique.

  • * Commande *: Il s’agit de la commande réelle qui sera exécutée par Marathon. C’est le processus qui sera surveillé et redémarré s’il échoue.

En utilisant ces informations, vous pouvez configurer un service simple qui imprime simplement «bonjour» et dort pendant 10 secondes. Nous appellerons cela «bonjour»:

image: https: //assets.digitalocean.com/articles/mesos_cluster/simple_app.png [Application simple Marathon]

Lorsque vous revenez à l’interface, le service passera de «Déploiement» à «En cours d’exécution»:

image: https: //assets.digitalocean.com/articles/mesos_cluster/running.png [Application Marathon en cours d’exécution]

Toutes les 10 secondes environ, la lecture «Tâches / Instances» passera de «1/1» à «0/1» à mesure que la quantité de sommeil passe et que le service s’arrête. Marathon redémarre ensuite automatiquement la tâche. Nous pouvons voir ce processus plus clairement dans l’interface Web Mesos sur le port + 5050 +:

http://:5050

Ici, vous pouvez voir le processus se terminer et être redémarré:

image: https: //assets.digitalocean.com/articles/mesos_cluster/restart_task.png [Tâche de redémarrage de Mesos]

Si vous cliquez sur "Sandbox" puis sur "stdout" pour l’une des tâches, vous pouvez voir la sortie "hello" en cours de production:

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

Démarrer un service via l’API

Nous pouvons également soumettre des services via l’API de Marathon. Cela implique de transmettre un objet JSON contenant tous les champs contenus dans la superposition.

C’est un processus relativement simple. De nouveau, les seuls champs obligatoires sont + id + pour l’identificateur de processus et + cmd + qui contient la commande à exécuter.

Nous pourrions donc créer un fichier JSON appelé + hello.json + avec ces informations:

nano hello.json

À l’intérieur, la spécification minimale nue ressemblerait à ceci:

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

Ce service fonctionnera parfaitement. Cependant, si nous voulons vraiment émuler le service que nous avons créé dans l’interface utilisateur Web, nous devons ajouter des champs supplémentaires. Celles-ci ont été configurées par défaut dans l’interface Web et nous pouvons les répliquer ici:

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

Enregistrez et fermez le fichier JSON lorsque vous avez terminé.

Ensuite, nous pouvons le soumettre en utilisant l’API Marathon. La cible est l’un des services de notre maître Marathon au port + 8080 + et le point final est + / v2 / apps +. La charge de données est notre fichier JSON, que nous pouvons lire dans + curl + en utilisant l’indicateur + -d + avec l’indicateur + @ + pour indiquer un fichier.

La commande à soumettre ressemblera à ceci:

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

Si nous regardons l’interface Marathon, nous pouvons voir qu’elle a été ajoutée avec succès. Il semble avoir exactement les mêmes propriétés que notre premier service:

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

Le nouveau service peut être surveillé et accédé exactement de la même manière que le premier service.

Conclusion

À ce stade, vous devriez avoir un cluster de mésosphère prêt à la production opérationnel. Nous avons seulement couvert la configuration de base à ce stade, mais vous devriez être capable de voir les possibilités de tirer parti du système Mésosphère.

Dans les prochains guides, nous verrons comment déployer des conteneurs Docker sur votre cluster et comment utiliser certains outils plus en profondeur.

Related