TOC

Infrastructure SaltStack: Configuration de Salt-Cloud pour augmenter les ressources DigitalOcean

introduction

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 dernier guide, nous avons commencé par terminer la configuration initiale de notre serveur maître Salt. Ce serveur devrait maintenant être en cours d’exécution et capable d’émettre des commandes Salt pour lui-même. Dans ce guide, nous étendrons la portée de notre Salt Master en configurant les composants + salt-cloud +. Cela nous permettra de nous connecter à notre compte DigitalOcean pour augmenter les ressources si nécessaire. Nous allons créer des profils qui définissent les propriétés de nos composants individuels et de nos environnements dans leur ensemble.

Conditions préalables

Afin de compléter ce didacticiel, vous devez disposer d’un serveur maître Salt configuré comme indiqué dans le his guide. Nous allons suivre les étapes de ce guide en utilisant le compte d’utilisateur non root sur ce serveur.

Vous aurez également besoin d’accéder à un compte DigitalOcean. Nous allons tirer parti de l’API DigitalOcean via la commande + salt-cloud + pour créer et contrôler les serveurs qui composeront nos différents environnements. Vous devrez créer un jeton d’API à cet effet, que nous couvrirons dans le guide.

Créer la configuration Main Cloud Minion

Nous allons commencer par créer un fichier de configuration sous + / etc / salt / cloud +. Cela sera utilisé comme les options communes pour tous les serveurs que nous allons créer. Créez et ouvrez le fichier maintenant:

sudo nano /etc/salt/cloud

Les seules configurations que nous appliquerons à ce stade sont les options + / etc / salt / minion + qui seront définies sur chacun des serveurs que nous créons. Utilisez la touche + minion: + pour démarrer la structure de cette information:

/ etc / salt / cloud

minion:

Sous cette clé, commencez par spécifier l’adresse IP du serveur maître Salt. C’est le paramètre le plus important car il permet au séide sel de se reconnecter au maître après le provisionnement:

/ etc / salt / cloud

minion:
 master:

Note

Ensuite, nous devons configurer certaines fonctions de la mine. Les sbires de sel peuvent être configurés pour renvoyer les résultats des modules d’exécution de sel vers un référentiel central sur le maître de sel. Ce système permet aux serveurs de sbires de partager des informations importantes avec d’autres sbires.

Nous voulons créer deux fonctions minières. Celles-ci renverront simplement les adresses IP publique et privée du sbire au Salt Master. Les autres sbires peuvent ensuite interroger le maître pour obtenir ces informations afin d’apprendre à se connecter aux homologues:

/ etc / salt / cloud

minion:
 master:
 mine_functions:
   external_ip:
     - mine_function: network.interface_ip
     - eth0
   internal_ip:
     - mine_function: network.interface_ip
     - eth1

Enregistrez et fermez le fichier lorsque vous avez terminé.

Configurer le fournisseur de cloud DigitalOcean

Ensuite, nous allons configurer un fichier de fournisseur de cloud DigitalOcean. Celui-ci contiendra les informations nécessaires pour se connecter à notre compte DigitalOcean ainsi que certains paramètres communs que nous souhaitons utiliser pour les serveurs que nous allons créer.

Commencez par créer un répertoire des informations sur nos fournisseurs:

sudo mkdir -p /etc/salt/cloud.providers.d

À l’intérieur, créez et ouvrez un fichier nommé + do.conf +:

sudo nano /etc/salt/cloud.providers.d/do.conf

A l’intérieur, nous allons créer une autre structure YAML. La clé de niveau supérieur dans la structure sera le nom du fournisseur. Nous allons utiliser "faire" ici. Le + driver + spécifie quel cloud utiliser. Le pilote de DigitalOcean dans Salt s’appelle + digital_ocean +:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean

Ensuite, vous devez accéder à votre compte DigitalOcean et créer un jeton d’API. Vous pouvez accéder à la section API du panneau de configuration en suivant les liens cet lien. Cliquez sur le bouton «Générer un nouveau jeton» dans le coin supérieur droit de la page:

image: https: //assets.digitalocean.com/articles/salt_series_cloud/generate_new_token.png [jeton de l’API de création de DigitalOcean]

Sur la page suivante, entrez un nom descriptif et cliquez sur «Générer un jeton»:

image: https: //assets.digitalocean.com/articles/salt_series_cloud/name_token.png [Jeton de nom DigitalOcean]

Vers le bas de la page suivante, votre nouveau jeton sera affiché:

image: https: //assets.digitalocean.com/articles/salt_series_cloud/new_token.png [Nouveau jeton DigitalOcean]

Copiez cette valeur avant de quitter la page, car elle ne sera plus affichée. Si vous oubliez de le faire, détruisez le jeton et générez-en un nouveau.

De retour dans le fichier de configuration de votre fournisseur, définissez l’option + personal_access_token + sur la valeur du jeton généré que vous avez copié:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean
 personal_access_token:

Ensuite, nous allons spécifier les informations de clés SSH. La commande + salt-cloud + devra se connecter aux serveurs initialement à l’aide de SSH pour pouvoir configurer le séide. Nous allons définir la clé + ssh_key_file + pour qu’elle pointe vers l’emplacement du système de fichiers où nous allons copier notre clé privée SSH sous peu. Vous devez définir le + ssh_key_names + avec le nom ou les noms de la clé SSH que vous avez ajoutée à DigitalOcean:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean
 personal_access_token:
 ssh_key_file: /etc/salt/pki/cloud/do.pem
 ssh_key_names: ,

Nous devons également spécifier le script et les arguments de script afin de pouvoir contrôler la version exacte de Salt qui sera déployée sur les nouveaux minions:

/etc/salt/cloud.providers.d/do.conf

do:
 driver: digital_ocean
 personal_access_token:
 ssh_key_file: /etc/salt/pki/cloud/do.pem
 ssh_key_names: ,
 script: bootstrap-salt
 script_args: -P git

Enregistrez et fermez le fichier lorsque vous avez terminé. Nous pouvons voir que la configuration de notre fournisseur a été récupérée par Salt Mater en tapant:

sudo salt-cloud --list-providers
Outputdo:
   ----------
   digital_ocean:
       ----------

Vous pouvez tester votre clé API en tapant:

sudo salt-cloud --list-locations do

Il devrait vous montrer une liste des régions disponibles pour le déploiement.

Créer le fichier de clé SSH

Avant de poursuivre, nous devons créer le fichier de clé privée SSH que nous avons référencé dans le fichier de fournisseur. Commencez par créer la structure de répertoire nécessaire:

sudo mkdir -p /etc/salt/pki/cloud

Ensuite, créez un fichier nommé + do.pem + dans le répertoire nouvellement créé:

sudo nano /etc/salt/pki/cloud/do.pem

Collez le contenu de votre clé privée associée à l’une des clés DigitalOcean que vous avez spécifiées dans la directive + ssh_key_names + dans le fichier du fournisseur. Vous pouvez généralement obtenir le contenu de votre clé privée en tapant ce qui suit dans votre * ordinateur local *:

cat ~/.ssh/id_rsa

Ça devrait ressembler a quelque chose comme ca:

~ / .ssh / id_rsa sur un ordinateur local

-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA39KuD8htHaIgUGFezpTsW0Y5XtNuoSTwVg/nih1rlVyKQIkJ
UhJRAakJ9ktQjSWdyAQr0i563WU1KYeHMzQuPPOQAK0vTbMjO5StuzqPEVfPPI1n
PIbMeAg9rjX5Lhy/jSOcTwf0E91jTMYuxkZCMCIDTzeVEFLV744APotQktCruJXf
L53cVUedOI1fQTEKGa1xEk92Ja4jm/Fn+4WKqYVTKRd2/vHX/ej8bI9Pomamskvc

. . .

hd4tdQKBgQCD8s2IbXVfGQ8x0D12a5K7sfysdnESF5I5ladEAoWP4wYctuGdlDso
lBl+jlm1di+1gPqBDMdJhic48ExRBVjKfB1adDeiwhzD4zNxFakhBXHjXHj6MBps
Oo/13JyvRs6QRpBolJfVaG1b5CAR+EhAJkxxCxWch8dlwE1gb9jxXw==
-----END RSA PRIVATE KEY-----

Collez-le dans le fichier sous + / etc / salt / pki / cloud / do.pem +, puis enregistrez et fermez le fichier.

Pour que Salt utilise la clé, le fichier et le répertoire qui la contient doivent disposer des autorisations appropriées. Définissez les autorisations en tapant:

sudo chmod 700 /etc/salt/pki/cloud
sudo chmod 600 /etc/salt/pki/cloud/do.pem

Salt peut maintenant lire la clé privée et l’utiliser pour se connecter à de nouveaux serveurs.

Configurer des profils de nuage

Maintenant que le fournisseur DigitalOcean est configuré, nous pouvons créer des profils. Ces profils définissent les propriétés que nous souhaitons utiliser lors de la création de nouvelles instances de serveur. Nous pouvons en configurer autant que nous le voudrions.

Nous allons stocker ces fichiers dans un répertoire + cloud.profiles.d +. Créez ce répertoire maintenant:

sudo mkdir -p /etc/salt/cloud.profiles.d

Pour ce guide, nous utiliserons un fichier séparé pour chacun des environnements que nous allons configurer. Commençons par l’environnement de développement:

sudo nano /etc/salt/cloud.profiles.d/dev-profiles.conf

Chaque profil est spécifié sous un nom de profil de niveau supérieur. Le nom est ce que nous utilisons lorsque nous voulons créer un Droplet en utilisant les détails fournis.

Nous allons commencer par spécifier un profil + base-dev +. Cela contiendra les propriétés de base partagées par toutes nos machines de développement. Pour ce guide, nous spécifions que nous voulons utiliser Ubuntu 14.04 64 bits, sur un droplet de 1 gigaoctet dans la région NYC3. NYC3 est la région dans laquelle notre maître Salt est déployé, ce qui nous permettra d’utiliser le réseau privé pour communiquer en cas de besoin. Dans cet esprit, nous allons activer les réseaux privés (cela sera utilisé dans notre configuration!) Ainsi que IPv6.

Vous pouvez modifier la taille et la région à votre guise à l’aide des informations renvoyées par ces commandes:

sudo salt-cloud --list-locations do
sudo salt-cloud --list-sizes do

Dans la sortie renvoyée, le «slug» associé à la taille et à l’emplacement que vous souhaitez utiliser est le nom que vous devez utiliser dans votre configuration.

En utilisant les informations de Droplet que nous avons décrites ci-dessus, notre + base-dev + ressemblera à ceci:

/etc/salt/cloud.profiles.d/dev-profiles.conf

base-dev:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

Ce profil fournit la plupart des détails dont nous avons besoin, mais nous souhaitons également inclure des grains de sel personnalisés sur nos sbires. Celles-ci seront utilisées pour cibler des machines spécifiques en fonction du rôle qu’elles jouent dans l’infrastructure et l’environnement dont elles font partie.

Nous pouvons le faire en "étendant" le profil de base. L’extension vous permet de spécifier un nouveau profil qui héritera des caractéristiques d’un profil existant et vous permettra d’ajouter de nouvelles valeurs. Cependant, l’héritage est plutôt pointilleux et ne permettra qu’une seule extension (aucune extension). De plus, les éléments de liste (comme nos grains) remplaceront les données précédentes au lieu de les ajouter (raison pour laquelle nous ne pouvions pas spécifier notre environnement dans la base, même s’il est partagé par tous les serveurs de l’environnement).

Le profil spécifique au serveur Web est assez simple. Il utilise tous les attributs originaux et ajoute les deux grains spécifiés. Nous utilisons le rôle «serveur Web». Nous comparerons cela tout au long du tutoriel. L’environnement de développement sera indiqué par la valeur «dev»:

/etc/salt/cloud.profiles.d/dev-profiles.conf

base-dev:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

dev-web:
 extends: base-dev
 minion:
   grains:
     role: webserver
     env: dev

Notre profil de base de données fonctionnera presque de la même manière. Nous allons simplement utiliser le rôle "dbserver" au lieu de "webserver" et utiliser l’ID de profil + dev-db +:

/etc/salt/cloud.profiles.d/dev-profiles.conf

base-dev:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

dev-web:
 extends: base-dev
 minion:
   grains:
     role: webserver
     env: dev

dev-db:
 extends: base-dev
 minion:
   grains:
     role: dbserver
     env: dev

Enregistrez et fermez le fichier lorsque vous avez terminé.

Nous allons créer un fichier similaire pour notre environnement de transfert. Créez le fichier en tapant:

sudo nano /etc/salt/cloud.profiles.d/stage-profiles.conf

Le profil + base-stage + est exactement le même que le profil + base-dev +. Les profils étendus correspondent également étroitement aux définitions précédentes, ne modifiant que l’environnement et les noms. Nous ajoutons également un profil étendu à notre équilibreur de charge, car il s’agit d’un type de serveur qui n’existe pas dans notre environnement de développement:

/etc/salt/cloud.profiles.d/stage-profiles.conf

base-stage:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

stage-web:
 extends: base-stage
 minion:
   grains:
     role: webserver
     env: stage

stage-db:
 extends: base-stage
 minion:
   grains:
     role: dbserver
     env: stage

stage-lb:
 extends: base-stage
 minion:
   grains:
     role: lbserver
     env: stage

Enregistrez et fermez le fichier lorsque vous avez terminé.

Enfin, créons les profils de production:

sudo nano /etc/salt/cloud.profiles.d/prod-profiles.conf

Les profils de production sont presque totalement identiques aux profils de transfert. Nous venons de changer chaque instance de la chaîne "stage" avec "prod":

/etc/salt/cloud.profiles.d/prod-profiles.conf

base-prod:
 provider: do
 image: ubuntu-14-04-x64
 size: 1gb
 location: nyc3
 private_networking: True
 ipv6: True

prod-web:
 extends: base-prod
 minion:
   grains:
     role: webserver
     env: prod

prod-db:
 extends: base-prod
 minion:
   grains:
     role: dbserver
     env: prod

prod-lb:
 extends: base-prod
 minion:
   grains:
     role: lbserver
     env: prod

Enregistrez et fermez le fichier lorsque vous avez terminé.

Vérifiez que vos profils sont bien enregistrés en tapant:

sudo salt-cloud --list-profiles do

Vous devriez voir une liste de tous les profils que vous avez configurés.

Créer des cartes d’environnement

Nous avons maintenant des profils qui définissent exactement comment créer les serveurs individuels dont nous avons besoin. Nous pouvons facilement les utiliser pour créer les serveurs dont nous avons besoin, un à la fois.

Cependant, + salt-cloud + peut également exploiter des fichiers de configuration supplémentaires appelés «cartes». Les cartes vous permettent de référencer les profils que nous avons créés afin de définir l’infrastructure complète que vous souhaitez créer. Vous fournissez les noms des serveurs que vous souhaitez créer pour chaque type de profil.

Créez un répertoire contenant les fichiers de carte nommés + cloud.maps.d +:

sudo mkdir -p /etc/salt/cloud.maps.d

Commençons par définir notre environnement de développement. Créez et ouvrez un fichier nommé + dev-environment.map + dans ce répertoire:

sudo nano /etc/salt/cloud.maps.d/dev-environment.map

Si vous vous souvenez de la previous article où les environnements que nous allons configurer ont été décrits, notre environnement de développement n’aura deux serveurs: un serveur Web et un serveur de base de données. Sachant cela, notre fichier de carte de développement devrait ressembler à ceci:

/etc/salt/cloud.maps.d/dev-environment.map

dev-web:
 - dev-web

dev-db:
 - dev-db

L’élément de niveau supérieur indique le profil utilisé pour provisionner la ressource. La liste située sous le nom du profil (indiquée par un tiret) indique les noms des serveurs à lancer.

Cet exemple définit un serveur Web appelé «dev-web» et un serveur de base de données appelé «dev-db». Ces deux serveurs peuvent être créés simultanément en faisant pointer + salt-cloud + sur ce fichier. Enregistrez et fermez le fichier lorsque vous avez terminé.

Ensuite, créons la carte de l’environnement de transfert:

sudo nano /etc/salt/cloud.maps.d/stage-environment.map

Notre environnement de transfert comprend deux serveurs Web, deux serveurs de base de données et un équilibreur de charge. Nous numéroterons nos serveurs redondants pour les distinguer. Notre carte devrait ressembler à ceci:

/etc/salt/cloud.maps.d/stage-environment.map

stage-web:
 - stage-www1
 - stage-www2

stage-db:
 - stage-db1
 - stage-db2

stage-lb:
 - stage-lb

Ce fichier aura la capacité de provisionner cinq serveurs au total. Enregistrez et fermez le fichier lorsque vous avez terminé.

Enfin, nous pouvons créer notre fichier de carte d’environnement de production en tapant:

sudo nano /etc/salt/cloud.maps.d/prod-environment.map

Ce sera assez similaire à notre carte d’environnement de transfert (avec les exceptions évidentes des noms de serveur et des profils utilisés). La production aura un équilibreur de charge supplémentaire afin que le basculement puisse être configuré:

/etc/salt/cloud.maps.d/prod-environment.map

prod-web:
 - prod-www1
 - prod-www2

prod-db:
 - prod-db1
 - prod-db2

prod-lb:
 - prod-lb1
 - prod-lb2

Les serveurs nus nécessaires à notre environnement de production peuvent être mis en service avec ce fichier. Enregistrez et fermez-le lorsque vous avez terminé.

Mise à disposition de l’environnement de test

Maintenant que nos fichiers de carte ont été créés, nous pouvons facilement créer tout ou partie de nos environnements.

Avant de pouvoir le faire, nous devons télécharger le script Salt Bootstrap sur notre serveur maître. Le maître va se connecter au séide, télécharger le script et l’exécuter afin de démarrer les séides sur les serveurs que nous créons.

Téléchargez le script de démarrage en tapant:

sudo salt-cloud -u

Cette commande doit être exécutée de temps à autre afin de vous assurer que vous utilisez la dernière version du script d’amorçage.

Une fois le script d’amorçage téléchargé, vous pouvez créer n’importe quel environnement à l’aide de la commande + salt-cloud +. Nous allons tester cela avec l’environnement de développement car il montre le processus avec le moins de ressources.

Nous allons passer l’indicateur + -P + afin de dire + salt-cloud + de créer les serveurs en parallèle. Sans cela, Salt attendrait qu’un serveur ait terminé l’amorçage avant de commencer à travailler sur le serveur suivant. Nous devrons utiliser l’indicateur + -m + et le diriger vers la carte d’environnement que nous souhaitons utiliser.

La commande complète ressemble à ceci:

sudo salt-cloud -P -m /etc/salt/cloud.maps.d/dev-environment.map

Vous serez invité à confirmer la création des deux serveurs définis dans ce fichier:

Output[INFO    ] salt-cloud starting
[INFO    ] Applying map from '/etc/salt/cloud.maps.d/dev-environment.map'.
[INFO    ] Starting new HTTPS connection (1): api.digitalocean.com
The following virtual machines are set to be created:
 dev-db
 dev-web

Proceed? [N/y]

Tapez "Y" pour créer les serveurs.

Une fois les serveurs créés, vous pouvez vérifier la connexion Salt en tapant:

sudo salt '*' test.ping

Vous devriez obtenir une réponse de votre maître sel et des deux nouvelles machines de développement. Au cours du processus de provisionnement, Salt Master a généré et accepté les clés des nouveaux serveurs avant de les placer sur les machines minion. De ce fait, nous n’avons pas besoin d’utiliser + salt-key + pour accepter chacune des nouvelles clés. Les nouveaux serveurs doivent répondre immédiatement:

Outputdev-db:
   True
sm:
   True
dev-web:
   True

Vous pouvez utiliser le fichier de carte pour émettre des commandes + salt-cloud + aux serveurs définis en tant que groupe. Si vous ne prévoyez pas d’utiliser les machines de développement pour le moment, n’hésitez pas à les détruire à nouveau en tapant:

sudo salt-cloud -d -m /etc/salt/cloud.maps.d/dev-environment.map

Cela détruira les serveurs via l’API et supprimera les clés de sbire du magasin.

Vous pouvez également détruire des machines individuelles par leur nom:

sudo salt-cloud -d dev-db

Si vous le faites, la prochaine fois que vous créerez avec le fichier map, + salt-cloud + ne créera que les serveurs qui ne sont pas déjà présents:

sudo salt-cloud -P -m /etc/salt/cloud.maps.d/dev-environment.map
Output[INFO    ] salt-cloud starting
[INFO    ] Applying map from '/etc/salt/cloud.maps.d/dev-environment.map'.
[INFO    ] Starting new HTTPS connection (1): api.digitalocean.com
[WARNING ] u'dev-web' already exists, removing from the create map.
The following virtual machines already exist:
 dev-web
The following virtual machines are set to be created:
 dev-db

Proceed? [N/y]

N’hésitez pas à tester vos autres fichiers de carte à ce stade pour vous assurer qu’ils peuvent provisionner correctement les serveurs nécessaires aux environnements que nous allons configurer.

Conclusion

À ce stade, votre serveur maître Salt doit être parfaitement capable de générer des ressources à l’aide du fournisseur de cloud DigitalOcean. Nous avons créé des profils pour les caractéristiques de nos machines individuelles et établi des cartes pour décrire facilement les serveurs individuels dont nous avons besoin pour chaque configuration.

Dans le next guide de cette série, nous allons commencer notre plongée dans la gestion de la configuration de Salt. capacités en configurant une configuration Nginx reproductible.

Related