Infrastructure SaltStack: Création d’états Salt pour Equilibreurs de charge HAProxy

SaltStack, ou Salt, est un puissant système d’exécution à distance et de gestion de la configuration qui permet de gérer facilement l’infrastructure de manière structurée et reproductible. Dans cette série, nous présenterons une méthode de gestion de vos environnements de développement, de transfert et de production à partir d’un déploiement de Salt. Nous utiliserons le système d’état de Salt pour écrire et appliquer des actions répétables. Cela nous permettra de détruire n’importe lequel de nos environnements, en sachant que nous pourrons facilement les remettre en ligne dans un état identique ultérieurement.

Dans notre previous guide, nous avons créé un état Salt pour nos serveurs Web qui ont installé et Nginx configuré. Dans ce guide, nous allons configurer les états de l’équilibreur de charge placé devant nos serveurs Web dans nos environnements de transfert et de production. Nos répartiteurs de charge doivent être configurés avec les adresses du serveur Web afin de transmettre correctement le trafic.

Commençons.

Nos équilibreurs de charge utiliseront HAProxy pour répartir le trafic de notre application entre tous les serveurs Web disponibles dans l’environnement. Comme avec le fichier d’état Nginx, nous allons créer un répertoire pour cet état dans le répertoire + / srv / salt +:

Nous allons utiliser le nom + init.sls + pour notre fichier d’état principal dans ce répertoire afin de pouvoir faire référence à l’état par le nom du répertoire:

A l’intérieur, nous pouvons utiliser le même modèle que nous avons utilisé pour Nginx afin d’installer le paquet + haproxy + et de s’assurer qu’il fonctionne. Nous veillerons à ce que le service soit rechargé lorsqu’il y aura des modifications dans le package ou dans le fichier + / etc / default / haproxy + ou dans le fichier + / etc / haproxy / haproxy.cfg +. Encore une fois, soyez très prudent avec l’espacement pour éviter les erreurs YAML:

/srv/salt/haproxy/init.sls

Nous devons gérer les deux fichiers surveillés par le service + haproxy +. Nous pouvons créer des états pour chacun.

Le fichier + / etc / haproxy / haproxy.cfg + sera un modèle. Ce fichier devra extraire des informations sur l’environnement afin de renseigner sa liste de serveurs Web auxquels transmettre le trafic. Nos serveurs Web n’auront pas les mêmes adresses IP chaque fois qu’ils seront créés. Nous devrons créer dynamiquement la liste chaque fois que cet état est appliqué.

Le fichier + / etc / default / haproxy + est juste un fichier normal. Nous le gérons parce que nous voulons nous assurer que HAProxy est démarré au démarrage. Ce n’est pas une information dynamique, il n’est donc pas nécessaire d’en faire un modèle:

/srv/salt/haproxy/init.sls

C’est tout ce dont nous avons besoin pour le fichier d’état lui-même. Enregistrez et fermez le fichier lorsque vous avez terminé.

Nous allons utiliser la même technique que celle utilisée avec Nginx pour obtenir les fichiers HAProxy de base dont nous avons besoin. Nous allons installer le paquet sur un serveur, puis demander au serveur de transférer les fichiers vers le maître.

Utilisons le serveur + stage-lb + car ce sera de toute façon la cible finale de ce paquet. Si vos machines intermédiaires ne sont pas encore opérationnelles, tapez:

Une fois que vos serveurs sont disponibles, vous pouvez installer le package + haproxy + sur le serveur + stage-lb + en tapant:

Une fois l’installation terminée, nous pouvons dire au séide de transmettre les deux fichiers nécessaires au serveur maître:

Les parties pertinentes du système de fichiers minion seront recréées dans le répertoire + / var / cache / salt / master / minions // fichiers +. Dans ce cas, l’ID de séide est + stage-lb +. Copiez la structure de fichier minion complète dans notre répertoire d’état HAProxy:

Nous pouvons voir la structure du fichier en tapant:

Maintenant que nous avons les fichiers du séide, nous pouvons détruire le serveur d’équilibrage de charge:

Nous pouvons ensuite recréer le serveur en arrière-plan afin de disposer ultérieurement d’une page vierge pour effectuer notre test final et notre confirmation. Ciblez votre serveur maître Salt avec cette commande, car il a accès aux fichiers de cloud pertinents:

Pendant la reconstruction du serveur, nous pouvons continuer et apporter les modifications nécessaires aux fichiers HAProxy que nous gérons.

Nous pouvons commencer avec le fichier + / etc / default / haproxy +. Dans notre répertoire d’état HAProxy sur le maître Salt, déplacez-vous vers le répertoire qui contient le fichier par défaut:

Copiez le fichier dans + haproxy.orig + afin que nous puissions conserver le fichier tel qu’il était empaqueté à l’origine:

Maintenant, ouvrez le fichier pour le modifier:

Changez + ENABLED + en «1». Ceci indiquera au système d’initialisation d’Ubuntu, Upstart, de démarrer le service HAProxy au démarrage du serveur:

/ srv / salt / haproxy / fichiers / etc / default / haproxy

C’est le seul changement que nous devons faire. Enregistrez et fermez le fichier.

Ensuite, travaillons sur le fichier de configuration principal de HAProxy. Déplacez-vous dans le répertoire approprié sur le serveur maître Salt:

Encore une fois, copions la configuration pour sauvegarder son état original:

Ensuite, renommez le fichier pour indiquer qu’il s’agit d’un fichier de modèle Jinja:

Ouvrez le fichier de modèle dans votre éditeur de texte:

En haut du fichier, nous pouvons commencer par définir une variable Jinja. Nous devons saisir l’environnement dans lequel fonctionne l’équilibreur de charge à l’aide de la fonction d’exécution + network.interface_ip +. Nous l’utiliserons plus tard pour remplir la liste de serveurs avec les serveurs Web du même environnement:

/srv/salt/haproxy/files/etc/haproxy/haproxy.cfg.jinja

Passez à la section «Défauts» du fichier. Nous devons changer + mode en« tcp »et la première` + option` en «tcplog»:

/srv/salt/haproxy/files/etc/haproxy/haproxy.cfg.jinja

Au bas du fichier, nous devons créer notre configuration réelle. Nous devons créer une section «frontend» qui décrira comment HAProxy acceptera les connexions. Nous appellerons cette section «www».

Nous voulons lier cela à l’adresse IP publique du serveur. Nous pouvons saisir cela en utilisant la fonction de module d’exécution + network.interface_ip + avec l’argument + eth0 +. Les demandes Web arriveront au port 80. Nous pouvons spécifier le backend par défaut à passer avec l’option + default_backend +. Nous appellerons notre backend + nginx_pool +:

/srv/salt/haproxy/files/etc/haproxy/haproxy.cfg.jinja

Ensuite, nous devons ajouter le backend + nginx_pool +. Nous allons utiliser le modèle conventionnel d’équilibrage à tour de rôle et régler le mode sur «tcp» à nouveau.

Ensuite, nous devons renseigner la liste des serveurs Web principaux de notre environnement. Nous pouvons le faire en utilisant une boucle «for» dans Jinja. Nous pouvons utiliser la fonction de module d’exécution + mine.get + pour obtenir la valeur de la fonction de mine + internal_ip +. Nous allons associer le rôle de serveur Web et l’environnement. Le + ~ env + caténera la valeur de la variable + env + que nous avons définie précédemment avec la chaîne de correspondance qui le précède.

Les résultats de cette recherche seront stockés dans les variables + server + et + addr + pour chaque itération de la boucle. Dans la boucle, nous allons ajouter les détails du serveur en utilisant ces variables de boucle. Le résultat final ressemble à ceci:

/srv/salt/haproxy/files/etc/haproxy/haproxy.cfg.jinja

Enregistrez et fermez le fichier lorsque vous avez terminé.

Notre état d’équilibrage de charge est assez basique, mais complet. Nous pouvons maintenant passer à le tester.

Tout d’abord, utilisons + state.show_sls + pour afficher le classement des fichiers:

Nous pouvons dire par la séquence dans les différentes valeurs «order» de la sortie que le package sera installé, que le service sera démarré, puis les deux fichiers seront appliqués. C’est ce à quoi nous nous attendions. Les modifications de fichier déclencheront un rechargement du service en raison du paramètre «surveillance» que nous avons configuré.

Ensuite, nous pouvons faire un essai complet de l’application State. Cela interceptera certaines erreurs (mais pas toutes) qui entraîneraient l’échec de l’état lors de l’exécution:

Vérifiez que tous les états seraient passés. Indépendamment du nombre d’échecs en bas ou de la sortie, faites défiler vers le haut et regardez la ligne «Commentaire» pour chacun des états. Parfois, cela inclura des informations supplémentaires sur des problèmes potentiels, même si le test a été qualifié de réussi.

Après avoir résolu les problèmes survenus lors des commandes de test, vous pouvez appliquer votre état à vos serveurs d’équilibrage de charge. Assurez-vous que les serveurs Web Nginx principaux sont en cours d’exécution et configurés avant d’appliquer l’état:

Lorsque vos serveurs Web sont en cours d’exécution, appliquez l’état + haproxy +:

Vous devriez maintenant pouvoir accéder à l’un de vos deux serveurs Web principaux via l’adresse IP publique de votre équilibreur de charge. Vous pouvez afficher l’adresse IP publique de votre équilibreur de charge avec cette commande:

Si vous utilisez le navigateur, cela ressemblera à ceci:

image: https: //assets.digitalocean.com/articles/saltstack_haproxy/example_page.png [page de l’équilibreur de charge]

Il est plus facile de voir le trafic de transfert de l’équilibreur de charge entre les serveurs principaux avec + curl +:

Si vous tapez à nouveau la commande plusieurs fois, il devrait permuter entre vos deux serveurs:

Comme vous pouvez le constater, le serveur qui traite la demande a changé, ce qui signifie que notre équilibreur de charge fonctionne correctement.

À ce stade, nous avons un état HAProxy fonctionnel qui peut être appliqué à nos machines d’équilibrage de charge. Cela peut être utilisé pour diviser le trafic entrant de notre application entre tous les serveurs Nginx principaux. Nous pouvons facilement détruire nos équilibreurs de charge, puis les reconstruire en fonction des serveurs Web disponibles.

Dans le next guide, nous allons nous concentrer sur la mise en place de MySQL. système de base de données. Ceci sera utilisé pour stocker des données d’application dans nos différents environnements.