Configurer une vm avec Ansible

Nous allons configurer la machine virtuelle que nous avons déployer précédemment, et pour ça nous allons utiliser Ansible

Ansible

Dans la premiere partie, nous avons installé Ansible, là nous allons l’utiliser pour déployer Docker sur notre vm.

Sachez qu’il y a de bonnes pratique en ce qui concerne le layout du dossier qui contiendra vos playbooks Ansible. Un petit coup d’œil ici vous en dira plus. dans notre exemple, on se contentera du strict minimum.

1. Création de dossier racine, inventory et roles :

     mkdir tuto-ansible
     mkdir tuto-ansible/inventory
     mkdir tuto-ansible/roles

2. On peut aussi créer le bon layout pour les roles a la main, mais a la place, utilisons cette commande qui le fera de façon plus complete :

     ansible-galaxy init tuto-ansible/roles/docker

3. Le résultat ressemblera a ça :

     roles/
       docker/
           tasks/
               main.yml
           handlers/
               main.yml
           templates/
               main.yml
           files/
               main.yml
           vars/
               main.yml
           defaults/
               main.yml
           meta/
               main.yml

Playbook & Tasks

1. Maintenant que les dossiers ont bien été créés, nous allons passer à la création des tasks et du playbook. Pour ça, prenons comme exemple la première task :

   - name: install prerequisites # le nom du task
     ansible.builtin.apt: # la fonction qui sera utiliser par le task, ici ça sera 'apt'
       name: '{{ item }}' # ici nous avons utilisé une boucle pour déployer les differents packages
       update_cache: true
     loop: '{{ pre_install_packages }}' # c'est ici d'où viendra la valeur du "{{ item }}" vu plus haut
     become: true # option pour passer en mode root

2. En ce qui concerne "{{ pre_install_packages }}", ceci est une variable qui se trouve dans roles/docker/defaults/main.yml :

   pre_install_packages:
     - apt-transport-https
     - ca-certificates
     - curl
     - gnupg-agent
     - software-properties-common

   Notez qu’il est de bonne pratique d’utiliser des variables plutôt que tout mettre en dur dans les tasks, ça sera plus pratique pour modifier après coup.

3. Ouvrez le fichier roles/docker/tasks/main.yml et ajoutez y :

   # Install tous les pre-requis avant d'installer docker
   - name: install prerequisites
     ansible.builtin.apt:
       name: '{{ item }}'
       update_cache: true
     loop: '{{ pre_install_packages }}'
     become: true
   
   # Télécharge la clé gpg
   - name: add apt-key
     ansible.builtin.apt_key:
       url: '{{ gpg_key_url }}'
     become: true
   
   # Ajoute la clé gpg au repo docker
   - name: add docker repo
     ansible.builtin.apt_repository:
       repo: deb "{{ docker_url }}" focal stable
     become: true
   
   #install docker
   - name: install docker
     ansible.builtin.apt:
       name: '{{ item }}'
     loop: '{{ main_pkg }}'
     become: true

4. Ajoutez les variables dans le fichier roles/docker/defaults/main.yml :

     ---
     # default file tasks/main.yml
   
     gpg_key_url: https://download.docker.com/linux/ubuntu/gpg
     docker_url: https://download.docker.com/linux/ubuntu
   
     pre_install_packages:
       - apt-transport-https
       - ca-certificates
       - curl
       - gnupg-agent
       - software-properties-common
   
     main_pkg:
       - docker-ce
       - docker-ce-cli
       - docker-compose
       - containerd.io

5. Au niveau du dossier inventory, créez un fichier inventory.ini, c’est ici que nous allons définir comment et quelle vm nous voulons atteindre :

     [vm]
     <adresse-ip-de-la-vm> ansible_connection=ssh ansible_user=azureadmin

6. Et enfin, au niveau du dossier racine, créez un fichier playbook.yml. C’est lui qui lancera notre task :

     ---
     - name: Docker # nom du playbook
       hosts: vm    # le host sur lequel nous allons appliquer le playbook, ici ça sera vm (comme dans le inventory.ini)
       roles:
         - docker   # le nom du role que nous voulons utiliser

Déploiement

1. Pour appliquer notre playbook, il suffit de lancer la commande suivante, en se mettant au niveau du dossier racine :

     ansible-playbook -i inventory/inventory.ini playbook/yml --private-key=@/.ssh/vm_id_rsa -v

Conclusion

Vous voilà avec une machine virtuelle créée via Terraform, avec Docker de déployé dessus via Ansible. le combo Terraform + Ansible est très pratique, ils offrent un grand panel de possibilités et de liberté pour gérer le déploiement des ressources et la configuration de celles-ci.