Comment créer un livre de jeu anible dans Ubuntu

ANSIBLE est un puissant outil d'automatisation et de gestion à distance qui vous permet d'administrer toutes vos machines distantes. ANNIBLE est multiplateforme et peut fonctionner sur la plupart des machines sans exigences pour un logiciel supplémentaire. ANIBLE offre également la sécurité en utilisant SSH et Python sur des machines distantes pour exécuter des tâches spécifiées.

Il prend en charge deux méthodes pour gérer les machines à distance: les commandes ad hoc et les manuels anibles. Les commandes ad hoc sont des commandes brutes que vous pouvez exécuter dans le terminal pour effectuer une tâche dans une seule instance.

Les PlayBooks anibles, en revanche, sont des fichiers écrits dans la langue YAML. Ils contiennent un seul ou un ensemble de tâches exécutées sur la machine distante. En raison de la nature stricte de YAML, les manuels anibles nécessitent une attention particulière dans la syntaxe générale.

Ce didacticiel vous guidera à travers les bases de l'écriture de lecteurs de jeu et d'exécution des commandes sur des machines distantes. Pour les illustrations de ce guide, nous configurerons un livre play simple qui installe et configure Apache Webserver.

NOTE: Ce tutoriel n'a pas le but de vous apprendre ANMIBLE. Tout ce qu'il fait est de vous fournir des conseils et des lignes directrices pour écrire un livre de jeu anible.

Conditions préalables

Pour obtenir la valeur maximale de ce guide, nous vous recommandons de suivre. Voici les choses dont vous avez besoin.

• Ubuntu ou une distribution basée sur Debian - c'est la machine que nous utilisons pour nous connecter aux machines distantes à l'aide de SSH.
• Une machine distante à contrôler avec ANSIBLE - nous vous recommandons d'obtenir un système Linux tel que Debian Server.

Une fois que vous avez satisfait aux deux exigences ci-dessus, nous pouvons commencer.

Comment installer ANSIBLE sur Debian / Ubuntu

La toute première étape consiste à nous assurer que nous avons installé et en cours d'exécution sur notre machine locale. J'utiliserai Ubuntu pour ce tutoriel.

Étape 1
Commencez par mettre à jour votre système à l'aide des commandes ci-dessous:

Mise à jour Sudo apt-get
Sudo apt-get Dist-grade -y -y

Étape 2
Ensuite, utilisez les commandes ci-dessous pour installer ANSIBLE sur Ubuntu.

sudo apt installer logiciel-properties-commun
sudo add-att-repository --yes - update ppa: anible / anible
sudo apt installer anible -y

Maintenant que nous l'avons installé sur votre machine locale, nous pouvons procéder pour le configurer.

Comment configurer l'inventaire anible

Pour gérer les serveurs distants en utilisant ANSIBLE, vous devez en parler ANNIBLE. Nous le faisons en créant un fichier d'inventaire contenant les adresses IP ou les noms d'hôte des machines distantes.

Par défaut, le fichier d'inventaire de l'hôte est dans / etc / anible / hosts.

Pour savoir comment créer un fichier d'inventaire d'hôte personnalisé dans Ansible, considérez l'un de nos tutoriels.

Modifiez le fichier / etc / anible / hosts et ajoutez l'adresse IP de votre machine distante comme indiqué ci-dessous:

Dans l'exemple d'inventaire ci-dessus, nous créons un groupe de serveurs (LinuxHint) que nous gérerons dans ce tutoriel. Vous pouvez avoir d'autres groupes tels que les serveurs Web, Database_Servers, etc.

Comment configurer la paire de clés SSH

ANIBLE utilise SSH pour se connecter dans les machines distantes spécifiées et exécute les tâches définies dans le playbook. Par conséquent, pour minimiser l'interaction et créer un flux de travail entièrement automatisé, il est préférable de créer une paire SSH pour se connecter à la machine distante.

Étape 1
La première étape consiste à générer une paire de clés SSH utilise l'outil SSH-Keygen. Utilisez la commande comme:

ssh-keygen

Cela vous demandera de manière interactive de générer une paire de clés SSH. Pour simplifier, acceptez les valeurs par défaut et n'ajoutez pas de phrase secrète.

La sortie est ci-dessous:

Étape 2
Ensuite, nous devons copier la touche SSH sur les machines distantes à l'aide de l'outil SSH-Copy-ID. Utilisez la commande comme:

ssh-copy-id -i ~ /.ssh / id_rsa.Utilisateur de pub @ Remote_ip

La sortie est comme indiqué ci-dessous:

Pour en savoir plus sur la façon d'utiliser la commande SSH-Copy-ID, utilisez ceci: utilisez la commande SSH Copy ID.

Comment écrire un livre de jeu anible

Comme je l'ai mentionné plus tôt, les manuels ANSIBLE utilisent YAML, et donc, vous devez observer des conventions syntaxiques strictes.

Si vous ne savez pas comment écrire des fichiers YAML, considérez le tutoriel dans ce lien: Lisez les valeurs des fichiers YAML

Pour rester organisé, créons un répertoire où nous allons stocker tous nos livres de jeu.

CD ~
mkdir anisble-workspace
CD ANSIBLE-WORKSPACE

Maintenant que nous avons créé le répertoire, créons notre premier playbook anible (le fichier devrait se terminer avec .Extension YAML.

Test VIM.yaml

À l'intérieur du fichier yaml, ajoutez le contenu suivant.

---
- hôtes: tout
devenir vrai
devenu_method: sudo
Tâches:
- Nom: "Afficher les interfaces réseau"
Commande: ifconfig
Registre: détails
- Nom: «Obtenez les détails des interfaces»
déboguer:
MSG: "Détails.stdout "

Enregistrez le fichier et exécutez-le sur le serveur à l'aide de la commande:

Test de livre de jeu anible.yaml

La commande publiera les informations sur les interfaces réseau sur les machines distantes comme indiqué dans l'image ci-dessous:

Bien que la sortie ne soit pas jolie et ne fournit pas le moyen le plus efficace de recueillir des informations de réseau en utilisant Ansible, il illustre bien comment nous pouvons utiliser ANMIBLE pour exécuter des commandes sur des hôtes distants.

Comment enregistrer les variables dans les manuels ANSIBL

Pour créer une variable dans un livre de jeu ANSIBLE, nous utilisons le mot clé du registre suivi du nom de la variable. Vous pouvez également utiliser le nom de la variable comme clé et définir sa valeur en utilisant la notation du colon.

Par exemple, deux façons d'enregistrer une variable dans Ansible.

Registre: variable1
variable2: valeur

Avec la variable définie, vous l'utilisez en appelant son nom à l'intérieur d'un ensemble de deux accolades bouclées comme:

'Appeler la variable variable1 à l'intérieur d'une chaîne'
variable2

Privilège Escalade dans ANMIBLE

ANIBLE vous permet également de mettre à niveau les privilèges d'un utilisateur en utilisant le devenir. La méthode CELA.

Dans notre premier manuel de jeu, nous avons mis le devenu à True et définissons la méthode d'escalade des privilèges en tant que sudo.

APT à l'intérieur des manuels

ANIBLE nous fournit des moyens de gérer les packages APT dans le système basé sur Debian. En utilisant cette méthode, vous pouvez mettre à jour, installer et désinstaller les packages à l'aide du playbook Ansible.

Considérez la mise à jour.Fichier YAML montré ci-dessous:

---
- hôtes: tout
devenir: oui
devenu_method: sudo
Tâches:
- Nom: "Mettre à jour le cache et la mise à jour complète du système"
apte:
Update_cache: true
cache_valid_time: 3600
force_apt_get: vrai

Les playbooks ci-dessus mettent à jour le cache du référentiel. Cela correspond à une commande brute comme:

Mise à jour Sudo apt-get

Cela peut être incroyablement utile lors de l'installation de logiciels tels que Apache, Nginx, etc., sur un hôte distant.

Exemple de cas d'utilisation

Cette section créera un playbook qui installe un serveur Web Apache sur le système Debian et effectue une configuration de base.

Ce playbook montre divers morceaux mobiles d'ANSIBLE et fournira un bon exemple de la fonction de playbooks ANSIBLE.

Commencez par créer le fichier YAML.

vim config_apache.yaml

À l'intérieur du Yaml, entrez le livre de jeu suivant.

---
- hôtes: tout
devenir vrai
devenu_method: sudo
Tâches:
- Nom: "Mettre à jour les packages et la mise à niveau"
apte:
Update_cache: true
mise à niveau: dist
force_apt_get: vrai
- Nom: "Installer le serveur Apache"
apte:
Nom: apache2
État: dernier
- Nom: "Créer la racine du document"
déposer:
Chemin: "/ var / www / html"
État: répertoire
propriétaire: "www-data"
Mode: 0755
- Nom: "Activer Apache sur le pare-feu"
UFW:
Règle: autoriser
Port: 80
Proto: TCP
- Nom: "Redémarrer le service apache2"
service:
Nom: apache2
État: redémarré

Enregistrez le fichier et exécutez-le sur le serveur distant à l'aide de la commande:

anible-playbook --user = "ubuntu" config_apache.yaml

Après une exécution réussie, vous verrez sur la sortie comme indiqué.

Confirmez que le serveur s'exécute à l'aide de Curl comme:

Curl 192.168.0.13

Vous devez obtenir le code source Apache par défaut (extrait illustré ci-dessous).

Et avec cela, nous avons conclu ce tutoriel.

Conclusion

Il est bon de noter que la fonctionnalité de l'écriture de playbooks dépendra fortement des tâches que vous devez effectuer. Cependant, j'espère que ce tutoriel vous a donné quelques directives et conseils pour créer l'un des vôtres.

Happy Automation!