Tutoriel : Faire ses déploiements avec Ansible

Ansible est une application de gestion de configuration de postes créé par Michael DeHaan très utilisé dans l’univers Devops grâce à sa simplicité d’apprentissage et au fait qu’il gère tout lui même (sans aucun agent contrairement aux outils comme Puppet ou Chef).

Il existe de nombreuses applications pour automatiser les déploiements mais aujourd’hui nous nous arrêtons sur le dernier né qui est vraiment très facile à mettre en place.

Installation

Comme pour l’ensemble de mes tutoriaux, je vais proposer celui-ci sur une Ubuntu 16.04 mais vous pourrez facilement trouver les méthodes d’installation sur les autres systèmes d’installation.

sudo apt-get -y install ansible

Contrairement à d’autres outils de déploiement, Ansible va attaquer les serveurs lui même en SSH. Cependant pour faire cela, nous allons créer une clé publique/privée en local puis envoyer la clé publique sur le serveur sur lequel on désire autoriser Ansible à intervenir :

ssh-keygen
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.0.100

Maintenant que cela est fait, nous allons insérer notre serveur dans le fichier /etc/ansible/hosts comme ceci :

[web]
192.168.0.100

Le [web] n’est pas obligatoire mais permet de créer ou groupe de serveurs et d’appeler directement web dans les futures configurations.

Maintenant que tout est installé, nous allons tester que tout est ok en lançant la méthode suivante :

 ansible all -m ping -u root

Si tout va bien, vous aurez en retour :

192.168.0.100 | SUCCESS => {
     "changed": false,
     "ping": "pong"
}

Notre premier déploiement

Maintenant que notre Ansible est prêt, nous allons en profiter pour créer notre premier déploiement.

Pour créer notre premier déploiement, nous allons créer un playbook qui est un fichier sous le format Yaml que les développeurs Symfony par exemple connaissent très bien. Nous allons y installer Git et Apache comme ceci dans un fichier test.yml :

- name: Installation de Symfony
  hosts: web 
  remote_user: root 
  tasks: 
    - name: Installer Git
    apt: name=git state=latest
    - name : Installer Symfony
    command: chdir=/var/www/ git clone https://github.com/symfony/symfony.git

Comme vous pouvez le voir, la syntaxe est relativement simple à comprendre ; par contre en effet, un apprentissage sera indispensable pour bien maitriser Ansible. Cependant face à la concurrence, elle est vraiment facile et certaines choses deviendront même intuitives.

Voici l’explication de chaque ligne écrite ci-dessus :

name : c’est un label qui apparaitra d’ailleurs quand vous aller lancer votre script de déploiement. Ca sera utile pour suivre le bon déroulement (ou non) de votre script.

hosts : vous mettez le host, l’IP ou le raccourci que vous aviez indiqué dans le fichier /etc/ansible/hosts (qui peut contenir plusieurs serveurs).

remote_user : tout simplement l’utilisateur qui sera utilisé sur le serveur. En général celui que vous avez utilisé pour votre clé SSH.

tasks : c’est la définition d’une tâche à effectuer qui sera décomposée en plusieurs fonctions possibles. Dans notre cas, on en fera deux : une première pour installer Git et une deuxième pour cloner le projet Symfony.

apt : c’est le raccourci pour faire de l’apt-get (gestionnaire de package Ubuntu/Debian).

command : c’est la méthode pour faire une commande plus classique. Cependant, tout ne sera pas faisable donc il vous faudra parfois aller chercher les spécificités pour appliquer vos commandes. Ici par exemple, le chdir permet de lancer la commande dans un dossier bien précis.

Pour lancer notre script, nous allons lancer la commande suivante :

ansible-playbook test.yml

Vous verrez le script dépiler les “task” et vous indiquer si tout es ok ou si il rencontre une erreur.

Installation complexe de composer

Comme certains le savent, Symfony a besoin d’utiliser composer (gestionnaire de package en PHP) pour s’installer intégralement. Quand on manipule Ansible pour la première fois, il est relativement complexe de créer soit même son fichier de déploiement mais avec une bonne recherche Google du type “composer install with ansible”, vous devriez trouver toute l’aide nécessaire.

Voici la méthode pour le faire sous Ansible à mettre à la suite de vos “task” :

    - name: téléchager composer
      get_url:
        url: https://getcomposer.org/installer
        dest: /tmp/installer
      tags: composer

    - name: installer composer
      shell: cat /tmp/installer | php -- --install-dir=/usr/local/bin
      args:
        creates: /usr/local/bin/composer
      tags: composer

    - name: renommer composer.phar en composer
      shell: mv /usr/local/bin/composer.phar /usr/local/bin/composer
      args:
        creates: /usr/local/bin/composer
      tags: composer

    - name: rendre composer exécutable
      file: 
        path: /usr/local/bin/composer
        mode: a+x
        state: file
      tags: composer

Si vous êtes familier avec le monde Linux, vous devriez comprendre très rapidement ces lignes. Ce sont d’autres exemples utiles pour créer des scripts de déploiement.

Lancement de composer avec des conditions et variable

Nous allons à présent lancer composer en utilisant une variable et en mettant une condition en place (pour faire un travail propre).

Pour rappel, la première fois, il faut faire un “composer Install” qui va d’ailleurs créer un fichier composer.lock. Ensuite, il faudra faire des composer update pour mettre à jour les packages.

Voici ce que cela donnera dans Ansible :

    - stat: path=/var/www/symfony/composer.lock
      register: composer_file

    - name: composer install symfony
      command: chdir=/var/www/symfony composer install
      when: composer_file.stat.exists == False

    - name: composer update symfony
      command: chdir=/var/www/symfony composer update
      when: composer_file.stat.exists == True
Vous l’aurez compris, le when permet de créer une condition qui ici vérifie si le fichier composer.lock existe ou non. Le register permet de créer une variable réutilisable.

Installer notre environnement

On a tout vu pour Symfony mais il serait pas mal d’installer notre environnement. Nous allons d’ailleurs en profiter pour rencontrer une variable de type liste {{ item }} qui fera référence aux items définis en dessous :
 - name: Installation du package
      apt: name={{ item }} state=latest
      with_items:
        - apache2
        - libapache2-mod-php7.0
        - php7.0
        - php7.0-fpm
        - php7.0-mysql
        - php7.0-curl
        - curl
        - php7.0-mbstring
        - php7.0-xml
        - php7.0-zip
        - php7.0-cli
        - php7.0-bcmath

    - name: enabled mod_rewrite
      apache2_module: name=rewrite state=present
      notify:
        - restart apache2
Nous en profitons pour activer le mod rewrite d’Apache 2 qui n’est pas activé par défaut sur Ubuntu et par notifier Apache d’un redémarrage pour prendre en compte cette activation.

Conclusion

N’hésitez pas à vous amuser avec ce qu’on vient de vous montrer sur Ansible. Si le sujet vous intéresse vraiment, je n’hésiterais pas à refaire un deuxième tutoriel sur son sujet.

Laissez une réponse