Archives mensuelles : décembre 2020

Débuter avec les commandes dans la CLI Kubernetes

Lors d’un précédent article, nous avions découvert les principes de kubernetes et quelques définitions. Il est temps pour nous de débuter dans les commandes kubernetes.

Si vous le souhaitez, vous pouvez retrouver plus de 70 vidéos gratuites dans cette playlist que je mets à votre disposition. Cette formation kubernetes vous permet de découvrir l’outil tranquillement à votre rythme et de bénéficier du code de chacun des tutos pour reproduire cela de votre côté sur votre laptop.

Premier pod et premier run

La couche logique nommée pod qu’apporte k8s est inévitable lorsque vous utilisez cet orchestrateur. Si vous avez pratiqué docker ou un autre conteneur runtime, imaginez un pod comme une couche supérieure. Cette couche dispose de la description des conteneurs qui vont être lancés et de leur environnement.

Nous le verrons plus tard, les objets k8s sont souvent lancés via des manifests. Ces derniers sont des fichiers descriptifs en format yaml. Mais pour débuter souvent on apprend dans un premier temps à lancer ces éléments à partir de la ligne de commande.

Alors comment lancer le plus simplement du monde un pod dans kubernetes ?

Suivant la version de kub qu evous utilisez vous pourrez réaliser un simple « kubectl run » à la manière d’un docker run de cette manière :

kubectl run mycontainer --image busybox

De cette manière nous venons de lancer un pod qui va lancer un conteneur dont l’image source est une busybox. Alors comme pour un run docker, vous pouvez aussi passer des commandes et par exemple vous connecter à un terminal :

kubectl run anothershell -it --image busybox -- sh

Là nous venons de lancer un pod et nous entrons directement dans le conteneur en question avec un shell à notre disposition. Mais nous pouvons également venir nous connecter à un shell d’un conteneur existant. Pour cela et comme pour docker, nous pouvons lancer un kubectl exec :

kubectl exec -ti <monpod> -- sh

Tout cela est assez facile à retenir si vous avez déjà pratiqué un peu de docker.

Comment lister les pods ?

kubectl get pods

Je vous invite à bien retenir la combinaison « kubectl get » qui revient en permanence sur kub. Elle permet de lister les objets d’un type donné.

Si vous êtes sur un cluster kubernetes, il est intéressant d’en revenr aux fondamentaux qu’il faut toujours garder en tête et notamment : kubernetes est un orchestrateur de conteneurs.

Ainsi, je vous invite à faire un :

kubectl get pods -o wide

L’option -o wide permet d’avoir plus d’information et notamment les les noeuds sur lesquels les conteneur ont été déployés. Ainsi poru aller plus loin vous pouvez vous rendre sur le serveur des pods que nous venons de lancer et lancer un simple

docker ps | grep "mycontainer\|another"

Vous devriez retrouver les conteneurs déployés par notre fameuse couche logique qui est le pod.

Vous pouvez aussi supprimer ces pods à l’aide de la commande :

kubectl delete pods <nom_du_pod>

Et un peu plus loin le deployment et le service

Alors maintenant nous allons encore empiler une brique logique sur les pods à savoir le deployement. Un deployment permet de lancer les pods de manière automatisée si on devait le résumer. Le deployment a des capacités étendues.

Ainsi, dans le deployment, nous le verrons plus tard, nous aurons un template de pods. C’est à dire la capcité à lancer et relancer des pods du même type… et même proposer de l’autoscaling de pod en fonction de la sollicitation des ressources ou non.

Alors comment créer un deployment qui va lancer un pod ?

Simplement avec la ligne de commande :

kubectl create deployment monnginx --image nginx

Avec cette ligne nous créons un déploiement de la manière la plus réduite qu’il existe à savoir en spécifiant juste l’image qui servira dans le pod à créer le ou les conteneurs. Dans notre cas, cette image est une nginx.

Je vous invite à lister ce nouvelle object de cette manière :

kubectl get deployment

Vous découvrez donc votre déploiement et si vous lancez un :

kubectl get pods

Vous retrouvez un pod préfixé du nom du déploiement.

Simple non ? Dans la pratique vous le verrez on ne lance presque jamais un pod seul mais vous le ferez par un deployment. Ce dernier apporte aussi de la persistance à votre pod notamment via un autre object créé par le deployment qui se nomme le replicaset. Il a principalement en charge l’existence de vos pods et le respect du bon nombre. Vous pouvez également lister les replicaset

kubectl get replicasets

Et si vous le souhaitez vous pouvez faire le test de supprimer un pod créé par votre deployment.

kubectl delete pods <nom_du_pod>

Que se passe-t-il si vous relisté les pods ensuite ? Kubernetes va recréer le nombre de pods que vous avez demandé de maintenir au deployment.

Alors comment supprimer définitivement les pods ? Simplement en supprimant le pod (il y a d’autres moyens pour d’autres cas de figures).

kubectl delete deployment monginx

Et là kubernetes va supprimer lui même les pods et replicaset.

Voici donc nos premier pas dans un cluster kubernetes réalisés. Si vous souhaitez progresser reportez vous à la playlist de formation kubernetes, c’est gratuit. Vous pouvez aussi retrouver le code pour faire vos tests ici. A bientôt !!

Faire son premier playbook avec ansible

Vous êtes débutant sur ansible ? ou peut être un peu plus avancé mais vous cherchez à vous faire une piqûre de rappel pour remettre les choses en place ? Je vous propose de suivre ma formation ansible en ligne et totalement gratuite via des vidéos youtube mais également à travers les articles de ce blog devops.

Alors depuis quelques vidéos nous avons posé les bases avec :

  • l’inventaire
  • les groupes
  • les hosts
  • l’installation
  • la CLI

Nous allons continuer sur ce chemin pour débuter petit à petit avec cet orchestrateur.

Depuis le temps il est peut être venu le moment de faire quelques actions sur nos serveurs.

A quoi sert le playbook ??

C’est assez simple, dans les définitions et concepts, nous avons vu qu’il y a deux bulles. Avec d’un côté l’inventaire et de l’autre les tasks qui sont des actions individuels que l’on peut rassembler dans des rôles.

Mais comment savoir quelles tâches sont jouées sur quelles machines cibles ?

C’est là qu’intervient le playbook. Il permet de coordonner les deux bulles l’inventaire et les rôles/tasks.

Il s’ait donc ni plus ni moins d’un fichier qui va dire quels groupes ou machines reçoivent quelles actions ? et bien sûr tout cela en format yaml comme la plupart des fichiers dans ansible.

Le playbook minimum resemble à ceci en terme de contenu :

- name: Mon Playbook !!
  hosts: all
  tasks:
  - name: je debug
    debug:
      msg: "{{ var1 }}"

Découvrons un peu plus ce que l’on a écrit :

  • le nom du playbook « mon premier playbook »
  • son périmètre ou ses serveurs cibles, donc notre cas le groupe all (c’est à dire toutes les machines)
  • un bloc permettant de décrire les tasks
  • le nom de la première tâche « je debug »
  • l’appel à un module, en l’occurence « debug »
  • les paramètres passés à ce module « msg » (pour indiquer un message composé d’une variable au format jinja).

On est pas mal pour débuter avec notre playbook.

A côté il ne faut pas oublier d’avoir un inventaire, comme par exemple :

all:
  hosts:
    172.17.0.2:

Comprendre la ligne de commande ansible-playbook ?

Comment lancer le playbook ? Comprendre est peut être un bien grand mot mais au moins savoir un peu ce que l’on fait et ce que l’on peut faire avec ansible et ses playbooks.

Dans ce qui est dessous nous allons parler du binaire ansible-playbook.

Voyons déjà une ligne de commande minimaliste pour lancer ce fichier :

ansible-playbook -i inventory.yml playbook.yml

Très simple non ? bon généralement il y aura souvent un peu plus d’options que cela dans votre terminal.

Voici donc quelques options plus ou moins connues (mais même les moins connues sont intéressantes… le diable se cache dans les détails).

	* -l : réduire le run à certaines machines ou certains groupes de votre inventaire
	* -u : spécifier un user particulier utilisé sur la où les machines distantes
	* -b : become est équivalent à taper sudo devant vos commandes pour élever vos privilèges
	* -k : pour recevoir la demande de saisie du mot de passe pour la connexion ssh
	* -K : le password pour l'élévation de privilège liée au sudo (become)
	* -C : check c'est le dry run... très utile quand on ne connait pas la fréquence des runs ansible
	* -D : diff c'est très utile pour avoir les différences et les modifications de ce que va faire ansible
	* --ask-vault : permet de saisir un password pour déchiffrer les secrets que vous aurez chiffré avec vault
	* --syntax-check : vérfier la syntax
	* --vault-password-file : passer le vault password par un fichier
	* -e : surcharger n'importe quelle variable
	* -f : forks, nombre de parallélisation
	* -t : filtrer sur les tags (--skip-tags)
	* --flush-cache : éviter l'utilisation du cache
	* --step : une tâche à la fois (confirmation via prompt)
	* --start-at-task : commencer à une tâche spécifiquement
	* --list-tags : lister tous les tags rencontrés
	* --list-tasks : liste les tâches qui vont être exécutées

Là on y voit plus clair.

Et maintenant commençons à jouer avec les fichiers grâce au module file.

Débuter avec le module FILE

Créer un fichier, un répertoire, leur affecter des droits, des propriétaires… ce sont des commandes courrantes en linux et généralement on apprend cela en débutant : mkdir, touch, chown, chmod, ln…. Et bien pour ansible c’est un peu pareil.

Le module file peut prendre différents paramètres :

* attribute : définitions des paramètres particuliers d'un fichier : immutabilité etc... cf https://fr.wikipedia.org/wiki/Chattr
* force : pour les liens symboliques (créer même si le fichier source existe pas, la destination existe)
* group/owner : le propriétaire et le groupe du fichier ou du répertoire
* mode : les permissions sous les deux formats : "0755" ou "u=rwx,g=rx,o=rx"
* path : la localisation du fichier ou des répertoires
* recurse : création du chemin intermédiaire si n'existe pas (yes/no), attention cela est valable uniquement pour les répertoires
* src : pour les liens (hard ou symbolique)
* state : le type absent / directory / file / hard / link / touch
		touch > créé le fichier vide
		file > vérifie l'existence et les caractéristiques

Et donc nous voici prêt à écrire notre première task. Par exemple pour créer un répertoire :

- name: créer un répertoire
  file:
    path: /tmp/xavki/
    state: directory
    owner: root

Ici ansible va créer le répertoire xavki dans /tmp car le state est de type directory. Et le propriétaire de ce répertoire sera l’utilistaur root.

Avec l’utilisation du mode récursif :

  - name: création du répertoire /tmp/xavki
    file:
      path: /tmp/xavki/1/2/3/4
      recurse: yes
      state: directory
      owner: root
      group: root
      mode: 0755

Ou encore simplement créer un fichier vide avec touch :

  - name: création du répertoire /tmp/xavki
    file:
      path: /tmp/xavki/1/2/3/4/fichier.txt
      state: touch
      owner: root
      group: root
      mode: 0755

Ou encore sous forme de lien :

  - name: création du répertoire /tmp/xavki
    file:
      src: /tmp/xavki/1/2/3/4/
      dest: /tmp/symlink
      state: link  #hard
      owner: root
      group: root
      mode: 0755

Et enfin pour supprimer des fichiers ou des répertoires, il suffit d’utiliser le state absent très courrant dans les modules ansible.

  - name: dir sans idempotence
    file:
      path: /tmp/xavki.txt
      state: absent

Voilà j’espère que cette prise en main de ansible et que vous pouvez débuter en toute tranquilité à votre rythme. Je vous rappelle que vous pouvez venir découvrir plus de 900 vidéos sur la chaine xavki avec de nombreuses autres thématiques autour du devops bien sûr. Et retrouvez tous les fichiers de ces présentations sur le dépôt dédié à ansible.

Ansible, son inventaire… et son organisation

Après avoir découvert la CLI, continuons dans l’univers d’ansible pour apprendre à l’utiliser et bien comprendre ses principes. Eh oui, apprendre ansible c’est bien mais il faut surtout bien assimiler les concepts et bien organiser. Le but de cet article est d’aider les débutants à trouver leur chemin et de partager les pratiques avec les personnes ayant un niveau un peu plus avancé.

Il existe pas mal de bonnes pratiques pour ne pas se louper et toujours garder le cap. Après quelques années d’expériences, je pense que dans le domaine de l’infra as code, il faut toujours avoir des règles, des principes, des nomenclatures pour garder l’objectif de toujours s’y retrouver et éviter les dérives. Et systématiquement, il y a des dérives et il faudra revenir vers vos règles pour ramener les choses dans l’ordre.

Mais bon, quand on ne connait pas ou même lorsque l’on connait juste un peu, ce n’est pas évident de trouver son cap. Et surtout il faut éviter d’inventer des choses qui existent déjà.

Rester dans les fondamentaux a aussi un gros avantage. Si vous intégrez de nouvelles personnes dans vos équipes et qu’elles connaissent déjà les bonnes pratiques, ce sera encore plus facile pour eux d’être intégré technologiquement parlant. Et cela est très important en matière d’IaC car celle-ci décrit votre infrastructure et l’installation d’élements importants.

Bref l’inventaire ou inventory est un élément essentiel dans ansible et dans votre infrastructure. Pour débuter avec ansible, il faut donc bien organiser celui-ci.

Inventory ou fichier d’inventaire, c’est votre infrastructure

L’inventory n’est pas juste ce fichier mais celui-ci est central. Nous verrons dans le point suivant que l’inventaire est aussi composé de ses variables que nous nommons… variables d’inventaire.

L’inventaire comprend la liste de vos machines, il peut être de 3 types de formats : json, yaml, ini. Personnellement, je préfère le format yaml. Pourquoi ? tout simplement car :

  • tous les autres fichiers ansible sont en format yaml, donc par souci d’homogénéité
  • également car grâce à son indentation il permet de bien visualiser la hiérarchie des groupes et hosts (même si nous ne sommes pas toujours fan du format yaml).

Une machine est appelée host assez logiquement. Un ou plusieurs hosts peuvent consituer un groupe (group). Les hosts peuvent être décrit par des éléments permettant de les joindre : ip, dns principalement.

Et si vous avez des nomenclatures de serveurs adaptées, vous pourrez même gagner du temps en utilisant des patterns, par exemple : srv-bdd-[1-5].

Mettons maintenant tout cela en musique :

all:
  children:
    parent1:
      hosts:
        srv4:
      children:
        enfant1:
          hosts:
            srv1:
            srv2:
        enfant2:
          hosts:
            srv3:
          children
            enfant3:
              hosts:
                srv5:

Cela pour le format yaml, on a :

  • le groupe parent de tous qui se nomme toujours ALL (non modifiable)
  • le sous-groupe de ALL qui se nomme parent1 (à vous de choisir le nom)
  • parent1 est composé d’un host srv4 et de deux sous-groupes : enfant1 et enfant2
  • enfant1 est composé de srv1 et srv2
  • enfant2 est composé de srv3 et un autre sous-groupe enfant3
  • etc

Et maintenant pour le format ini.

[parent1]
srv4
[enfant1]
srv1
srv2
[enfant2]
srv3
[enfant3]
srv5
[parent1:children]
groupe1
groupe2
[enfant2:children]
enfant3

Et voilà l’essentiel. On peut également passer des variables directement dans ce fichier pour les associer à des groupes ou encore à des hosts. Mais je ne recommande pas de faire cela ou surtout il faut le limiter au maximum pour éviter que votre fichier d’inventaire ansible ne soit imbuvable.

Tutoriels : inventory, sa structure

Les variables d’inventaires ansible

Pour apprendre ansible, nous le reverrons mais il est important d’avoir un peu en tête la hiérarchie des variables ou précédence des variables… 22 types de variables au final dont certaines sont plus prioritaires que d’autres. Rassurez-vous vous n’avez pas besoin de toutes les connaître et surtout il faut éviter autant que possible de toutes les utiliser pour faciliter la maintenance de votre code.

Les formations ansible passent souvent assez rapidement sur les variables d’inventaires. C’est assez logique car sans mise en pratique c’est toujours délicat à aborder. Néanmoins il faut y passer quelques minutes pour bien débuter.

Notre fichier inventory est donc composé de hosts et de groupes. Nous allons donc pouvoir définir des variables de groupes et d’autres spécifiquement pour des hosts. Une fois que l’on a dit cela, il se dégage logiquement une hiérarchie ou précédence, les variables de hosts s’imposent aux variables de groupes. Ainsi, si vous avez un groupe de webserver avec une variable port = 80, si vous avez une exception dans ce groupe vous pourrez surcharger la variable de groupe par la variable du host en question port = 8080, par exemple.

Comment cela s’organise ?

Assez simplement au même niveau que notre inventory (le fichier), on va retrouver deux répertoires :

  • group_vars
  • host_vars

Une fois dans ces répertoires nous allons pouvoir créer soit :

  • des répertoires par groupe avec le nom du groupe ou par nom de host, vous pourrez ainsi créer plusieurs fichiers car vous avez beaucoup de variables et donc un besoin d’organiser un maximum
  • des fichiers yaml par nom de groupe ou nom de host car vous avez peu de variables.
├── 00_inventory.yml
├── group_vars
│   ├── all.yml
│   ├── dbserver.yml
│   └── webserver
│       ├── vault.yml
│       └── webserver.yml
└── host_vars
    ├── srv1
    │   └── srv1.yml
    └── srv2.yml

On retrouve bien :

  • notre fichier d’inventaire 00_inventory.yml
  • nos deux répertoires principaux toujours nommés group_vars et host_vars
  • et des sous-répertoires ou fichiers

Et si vous avez différents environnements vous pouvez tendre vers cette organisation assez connue :

├── dev
│   ├── 00_inventory.yml
│   ├── group_vars
│   │   ├── all.yml
│   │   ├── dbserver.yml
│   │   └── webserver
│   │       ├── vault.yml
│   │       └── webserver.yml
│   └── host_vars
│       ├── srv1
│       │   └── srv1.yml
│       └── srv2.yml
├── prod
│   ├── 00_inventory.yml
│   ├── group_vars
│   │   ├── all.yml
│   │   ├── dbserver.yml
│   │   └── webserver
│   │       ├── vault.yml
│   │       └── webserver.yml
│   └── host_vars
│       ├── srv1
│       │   └── srv1.yml
│       └── srv2.yml
└── stage
    ├── 00_inventory.yml
    ├── group_vars
    │   ├── all.yml
    │   ├── dbserver.yml
    │   └── webserver
    │       ├── vault.yml
    │       └── webserver.yml
    └── host_vars
        ├── srv1
        │   └── srv1.yml
        └── srv2.yml

Prenez bien votre temps pour bien comprendre et retenir ce type d’organisation car vous la retrouverez souvent ou elle pourra repondre à votre besoin. Pour débuter avec l’inventaire ansible c’est déjà un très bon début.

Voici une petite démonstration qui va permettre de rendre parlant tout cela avec une variable que l’on va surcharger à différents endroits.

Tutoriel : les variables d’inventaire

Mon dépôt de formation ansible ici.

Retrouvez également la documentation officielle concernant l’inventory ici.

English version : if you want to learn and start with ansible

Commencer avec la CLI de ansible et quelques astuces

Lors de notre précédent article, nous avons débuter avec ansible :

  • principes de base
  • installations possibles
  • premières commandes

Nous n’allons pas encore nous jeter dans le grand bain des rôles et playbooks. Pour un débutant, il est important de comprendre le fonctionnement de base d’un outil. En guise de formation et pour faire un premier pas avec la ligne de commande, je vous propose de pratiquer quelques commandes.

Retrouvez mon dépôt ici.

Et la vidéo associée :

La plus basique : le ping ansible

Pour savoir si ansible fonctionne de votre serveur/laptop source vers votre machine cible, nous pouvons utiliser le module ping. Attention, il ne s’agit pas là de faire un ping réseau ou icmp mais un ping au sens de ansible. En gros, ansible peut-il faire une connexion ssh vers la machine cible d’où vous le lancer.

Cela induit donc plusieurs paramètres : le serveur et le user. Il est important de ne pas oublier ce dernier car c’est avec lui que sera associé la clef ssh ou le password. L’utilisateur de départ qui initie la connexion est celui qui lance la commande ansible et l’utilisateur final peut être précisé par l’option -u.

Regardons la ligne ci-dessous :

ansible -i "node2," all -u vagrant -m ping

On a :

  • -i : qui précise le serveur target/cible, cela peut être un nom dns ou une ip. Important,vous devez rajouter une virgule après ce n’est pas une erreur de frappe. Suivi de « all » qui définit le groupe qui par défaut est all, nous reverrons cela plus tard avec l’inventaire.
  • -u : précise l’utilsiateur de la machine cible. Si vous utilisez une clef ssh c’est dans la conf ssh de ce user que vous devez avoir ajouté votre clef publique (dans le fichier authorized_keys).
  • -k : si vous n’avez pas de clef publique ou que vous souhaitez utiliser une connexion ssh via un passowrd vous pouvez le faire avec cette option. Ansible proposera alors de le saisir après avoir lancé la commande.

Vous pouvez forcer l’utilisation du password ssh de cette manière :

ansible -i "node2," all -u vagrant -k --ssh-extra-args="-o 'PreferredAuthentications=password'" -m ping

Pour afficher le résultat sur une ligne :

ansible -i "node2," all -u vagrant -m ping --one-line

Pour utiliser à distance une commande sur le shell distant :

ansible -i "node2," all -u vagrant -m command -a uptime

Et voilà vous avez lancé un uptime à distance et récupéré son résultat.

Poussons plus loin dans l’utilisation de la CLI

Bien sûr on peut même aller plus loin avec la simple ligne de commande ansible. Je vous propose pour vous former quelques exemples qui vous permettront de vous aguerrir par la pratique et sans faire de code pour le moment.

Par exemple, par la ligne de commande nous pouvons définir une variable et afficher son résultat comme si nous étions sur le serveur distant.

ansible -i "node2," all -e "var1=xavki" -m debug -a 'msg={{ var1 }}'

Ainsi nous passons quelques nouvelles options :

  • -e : pour définir une variable « var1 » avec sa valeur « xavki »
  • -m : pour préciser le module à utiliser, en l’occurence « debug »
  • -a : pour définir un paramètre de ce module, nous définissons « msg » avec la valeur de var1. Remarquez le double accolade qui est un format jinja, ansible reposant sur python.

Maintenant lançons un shell un peu plus élaboré avec quelques pipe dans ansible :

ansible -i "node2," all -u vagrant -m shell -a "ps aux | grep vagrant | wc -l" --one-line

On retrouve toujours nos options et nous avons simplement changé de module en utilisant « shell ». Et on profite du oneline pour l’output.

Comment installer à distance un serveur nginx :

ansible -i "node2," all -b -m apt -a 'name=nginx state=latest'

Là encore changement de module pour « apt » et définition de deux paramètres de ce module avec -a.

De même pour arrêter ou redémarer le service systemd :

ansible -i "node2," all -b -m service -a 'name=nginx state=stopped'

Et encore un peu plus…

Et on peut pousser encore plus loin avec d’autres onelines très facile à comprendre et utiliser.

Comment faire l’équivalent d’un scp avec ansible en une ligne ?

ansible -i "node2," all -m copy -a 'src=toto.txt dest=/tmp/titi.txt'

On y définit le fichier source et la destination. Mieux qu’un scp, ansible va faire jouer son idempotence et ne réalisera cette action que si nécessaire. C’est à dire si le fichier n’existe pas ou si il est différent du fichier source.

Pour faire l’inverse et récupérer un fichier d’une machine distante ?

ansible -i "node2," all -m fetch -a 'src=/tmp/titi.txt dest=xavki.txt flat=yes'

Cette fois-ci on utilisera le module « fetch », là encore en une ligne pour débuter tranquillement et apprendre à notre rythme.

Mais savez vous que à chaque run, ansible récupère ce que l’on appelle des facts, ce sont des variables génériques soit nécessaire pour son fonctionnement soit souvent utiles.

Eh bien regardons les facts disponibles pour une machine donnée :

ansible -i "node2," all -m setup -a "filter=ansible_distribution*"

Vous voyez que dans cette exemple, nous filtrons ceux-ci pour ne récupérer que les facts relatifs à la distribution.

Forez vous avec des tutorials ansible sur la chaine Xavki

Se former et apprendre Ansible et mettre un pied dans l’automatisation

Vous le savez, la chaine xavki que je tiens, est axée autour du devops. Comment devenir devops ou en acquérir les réflexe ou même la philosophie ? Dans ce domaine, certains outils sont marquants et sortent du lot. L’infrastructure as code est bien sûr un peu essentielle. De nombreux softs existent dans ce domaine et certains ont gagné des parts ces dernières années. Ansible fait partie de ces outils du parfait devops.

Ansible en quelques principes ?

Les principes d’ansible en font de lui un des plus faciles à adopter du marché. Totalement gratuit, il se base sur le langage python qui a fortement progressé ces dernières années agrandissant sensiblement son périmètre au fur et à mesure des années (IA, big data, statistiques, développement, CMS, framework…).

En outre, pour faciliter les choses, il se base sur une méthode de type push. A savoir que ansible ne nécessite pas d’agent. Mieux, une simple connexion ssh et python vous permettront de faire l’essentiel des tâches que vous aurez à réaliser. Un bon point pour les sysadmins qui restent fidèles à leurs scripts bash avec des boucles pour lancer un peu de ssh. Ou encore aux développeurs python qui utilisent paramiko avec une gestion délicate de l’idempotence… Ansible peut satisfaire vraiment beaucoup de monde.

Certains apprécieront moins son langage descriptif à base de yaml. Néanmoins, il permet de glisser sur la tendance et permet d’organiser clairement le code sous réserve de respecter les bonnes indentations. Un bon IDE vous y aidera d’autant plus.

Quelques éléments centraux :

  • le fichier d’inventaire (inventory file) : facile à deviner, il permet de regrouper la liste des machines, des groupes de machines ou même des patterns de serveurs
  • les variables d’inventaire : il s’agit des variables spécifiques à des hosts/serveurs ou à des groupes de machines. Elles sont stockées soit dans le fichier d’inventaire mais plutôt dans des répertoires host_vars et group_vars, respectivement pour les serveurs et les groupes de serveurs.
  • le rôle : regroupe un ensemble de tâches ou d’actions cohérentes pour installer, configurer etc (par exemple installer un serveur web). Un rôle est constitué notamment d’actions que l’on appelle tasks.
  • les tasks : ce sont des tâches individuelles qui utilise un module suivant des paramètres adaptés à la finalité de l’action
  • le playbook : fichier permettant de faire la jointure entre l’inventaire et les rôles. Il a une fonction centrale qui permet de dire quel groupe ou quel serveur va avoir tels et tels rôles de joués.

Respecter ces principes est PRIMORDIAL pour la faciliter de l’organisation du code dans son ensemble. S’agissant de bonnes pratiques, n’importe quelle personne ayant suivie une formation ansible pourra s’y retrouver relativement facilement et pouvoir découvrir votre infra en lisant comme dans un livre (on l’oubli trop souvent).

Installer le binaire

Potentiellement il y a 3 choix pour installer ansible :

  • via le gestionnaire de module python comme pip (pip3)
  • via le téléchargement de la source
  • via le gestionnaire de paquets de votre distribution préférée

Personnellement je préfère de loin cette dernière solution. Mais le contexte peut vous en faire décider autrement.

Sur debian on va simplement faire

sudo apt update

sudo apt install ansible

Et voilà le tour est joué. Vous pourrez très bien le faire sur redhat/centos/fedora car le projet ansible est porté par Redhat.

Pour configurer ansible, il est nécessaire de retenir un nom de fichier : ansible.cfg.

Vous pourrez le retrouver dans /etc/ansible/ ou encore dans votre home ou enfin à la racine de votre code (localisation du playbook).

Je vous invite à en découvrir plus sur la playlist de tutos ansible.

Premières commandes en CLI

Si vous avez installé ansible, vous êtes prêts à faire feu !!! Sauf si vous n’avez pas créé votre clef ssh. Dans ce cas, je vous propose une petite piqure de rappel ici.

Bref comment débuter et faire vos premières commandes ?

Pour pinguer les machines cibles.

ansible -i "node2," all -u vagrant -m ping

Attention, on parle d’un ping au sens ansible à savoir réussir une connexion ssh globalement.

-i : permet de préciser le fichier d’inventaire mais comme nous ne l’avons pas encore vu et que notre cible est une seule et unique machine on va simplement préciser cette machine entre double quote MAIS n’oubliez pas la virgule et le all (pour indiquer que cette machine fait partie du groupe all.

-u : permet de préciser l’utilisateur distant pour notre ssh ( <user>@<server>)

-m : permet de préciser l’utilisation d’un module, en l’occurence le module ping.

Dans notre cas nous avons une clef ssh mais on peut également faire la même chose par un password ssh :

ansible -i "node2," all -u vagrant -k -m ping

et si vous voulez forcer le fonctionnement par password pour une raison précise :

ansible -i "node2," all -u vagrant -k --ssh-extra-args="-o 'PreferredAuthentications=password'" -m ping