Comment télécharger des fichiers depuis une URL spécifique avec le module Ansible get_url

AnsibleAnsibleBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Ansible est un outil d'automatisation open-source puissant qui simplifie la gestion de l'infrastructure informatique. Dans ce tutoriel, nous allons explorer le module get_url d'Ansible, qui permet de télécharger des fichiers à partir d'une URL spécifique. Ce module est essentiel pour les tâches d'automatisation telles que l'installation de logiciels, la gestion de la configuration et le déploiement de contenu.

Tout au long de ce tutoriel, vous apprendrez à configurer Ansible, à utiliser le module get_url avec des options de base et avancées, et à mettre en œuvre des exemples pratiques pour automatiser les téléchargements de fichiers. À la fin de ce guide, vous aurez une solide compréhension de la façon d'exploiter ce module pour rationaliser vos processus de gestion de fichiers.

Installation et configuration d'Ansible

Avant de pouvoir utiliser le module get_url, nous devons nous assurer qu'Ansible est correctement installé et configuré sur notre système.

Installation d'Ansible

Commençons par installer Ansible dans l'environnement LabEx :

sudo apt update
sudo apt install -y ansible

Après avoir exécuté ces commandes, vérifiez qu'Ansible est correctement installé en vérifiant sa version :

ansible --version

Vous devriez voir une sortie similaire à celle-ci, affichant la version d'Ansible et les détails de configuration :

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, ...) [GCC 11.x]

Création d'un répertoire de travail

Ensuite, créons un répertoire dédié à notre projet Ansible :

mkdir -p ~/project/ansible-get-url
cd ~/project/ansible-get-url

Configuration d'un inventaire simple

Ansible doit savoir quels hôtes gérer. Pour ce tutoriel, nous allons créer un fichier d'inventaire simple qui cible la machine locale :

echo "localhost ansible_connection=local" > inventory.ini

Ce fichier d'inventaire spécifie que nous voulons exécuter Ansible sur localhost en utilisant une connexion locale.

Création du fichier de configuration Ansible

Pour personnaliser le comportement d'Ansible, créons un fichier de configuration simple :

cat > ansible.cfg << EOF
[defaults]
inventory = inventory.ini
host_key_checking = False
EOF

Ce fichier de configuration indique à Ansible d'utiliser notre fichier d'inventaire et désactive la vérification des clés d'hôte, ce qui simplifie les connexions dans un environnement de test.

Test de la configuration Ansible

Vérifions que notre configuration Ansible fonctionne correctement en exécutant une simple commande ping :

ansible localhost -m ping

Vous devriez voir une réponse réussie comme :

localhost | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false,
    "ping": "pong"
}

Cette sortie confirme qu'Ansible est correctement installé et peut communiquer avec localhost. Nous sommes maintenant prêts à utiliser le module get_url à l'étape suivante.

Création d'un playbook de base avec le module get_url

Maintenant que nous avons configuré Ansible, créons un playbook simple qui utilise le module get_url pour télécharger un fichier à partir d'une URL.

Comprendre les playbooks Ansible

Un playbook Ansible est un fichier YAML qui définit un ensemble de tâches à exécuter sur les hôtes gérés. Les playbooks sont organisés en une série de plays, où chaque play se compose de :

  • Un ensemble d'hôtes à cibler
  • Un ensemble de tâches à exécuter

Création de notre premier playbook

Créons un playbook de base qui utilise le module get_url. Créez un fichier nommé download-file.yml dans votre répertoire de projet :

cd ~/project/ansible-get-url

Ouvrez l'éditeur de fichiers et créez le fichier avec le contenu suivant :

---
- name: Download a file from URL
  hosts: localhost
  become: no
  tasks:
    - name: Create downloads directory
      file:
        path: ~/project/ansible-get-url/downloads
        state: directory
        mode: "0755"

    - name: Download a sample text file
      get_url:
        url: https://raw.githubusercontent.com/ansible/ansible/devel/README.md
        dest: ~/project/ansible-get-url/downloads/ansible-readme.md
        mode: "0644"

Ce playbook fait ce qui suit :

  1. Crée un répertoire downloads pour stocker nos fichiers téléchargés
  2. Utilise le module get_url pour télécharger le fichier README.md d'Ansible depuis GitHub

Comprendre les paramètres du module get_url

Décomposons les paramètres clés de la tâche get_url :

  • url : Spécifie l'URL à partir de laquelle télécharger le fichier
  • dest : Définit le chemin de destination où le fichier sera enregistré
  • mode : Définit les permissions du fichier (0644 signifie lecture et écriture pour le propriétaire, lecture pour le groupe et les autres)

Exécution du playbook

Maintenant que nous avons créé notre playbook, exécutons-le en utilisant la commande ansible-playbook :

ansible-playbook download-file.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Download a file from URL] ***********************************************

TASK [Gathering Facts] ********************************************************
ok: [localhost]

TASK [Create downloads directory] *********************************************
changed: [localhost]

TASK [Download a sample text file] ********************************************
changed: [localhost]

PLAY RECAP ********************************************************************
localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Vérification du fichier téléchargé

Vérifions que le fichier a été téléchargé correctement :

ls -l ~/project/ansible-get-url/downloads/

Vous devriez voir le fichier téléchargé :

-rw-r--r-- 1 labex labex 3154 Mar 15 12:34 ansible-readme.md

Vous pouvez également afficher le contenu du fichier téléchargé :

head -n 10 ~/project/ansible-get-url/downloads/ansible-readme.md

Cela affichera les 10 premières lignes du fichier README.md d'Ansible, confirmant qu'il a été téléchargé avec succès.

Félicitations ! Vous avez créé et exécuté avec succès votre premier playbook Ansible en utilisant le module get_url pour télécharger un fichier à partir d'une URL.

Utilisation des options avancées de get_url

Maintenant que nous avons couvert les bases, explorons quelques options avancées du module get_url qui peuvent être utiles dans des scénarios réels.

Création d'un playbook avancé

Créons un nouveau playbook nommé advanced-download.yml qui démontre diverses options avancées :

cd ~/project/ansible-get-url

Ouvrez l'éditeur de fichiers et créez le fichier avec le contenu suivant :

---
- name: Advanced get_url Module Options
  hosts: localhost
  become: no
  tasks:
    - name: Create advanced downloads directory
      file:
        path: ~/project/ansible-get-url/advanced-downloads
        state: directory
        mode: "0755"

    - name: Download with checksum validation
      get_url:
        url: https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64
        dest: ~/project/ansible-get-url/advanced-downloads/jq
        mode: "0755"
        checksum: sha256:af986793a515d500ab2d35f8d2aecd656e764504b789b66d7e1a0b727a124c44

    - name: Download with timeout and retries
      get_url:
        url: https://raw.githubusercontent.com/ansible/ansible-examples/master/README.md
        dest: ~/project/ansible-get-url/advanced-downloads/examples-readme.md
        timeout: 30
        retries: 3
        delay: 5
        force: yes

    - name: Download only if file doesn't exist
      get_url:
        url: https://raw.githubusercontent.com/ansible/ansible/devel/examples/ansible.cfg
        dest: ~/project/ansible-get-url/advanced-downloads/ansible-example.cfg
        force: no

Comprendre les paramètres avancés

Examinons les paramètres avancés utilisés dans ce playbook :

  1. Validation de la somme de contrôle (Checksum Validation) :

    • checksum : Spécifie la somme de contrôle attendue du fichier téléchargé (format : algorithme:somme de contrôle)
    • Cela garantit l'intégrité du fichier téléchargé et empêche le téléchargement si le fichier existe déjà avec la somme de contrôle correcte
  2. Délai d'attente et tentatives (Timeout and Retries) :

    • timeout : Temps maximum en secondes pour que la requête HTTP se termine
    • retries : Nombre de tentatives en cas d'échec du téléchargement
    • delay : Délai entre les tentatives en secondes
    • force : Indique s'il faut télécharger le fichier même s'il existe déjà
  3. Téléchargement conditionnel (Conditional Download) :

    • force: no : Le fichier ne sera téléchargé que s'il n'existe pas à la destination

Exécution du playbook avancé

Exécutons notre playbook avancé :

ansible-playbook advanced-download.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Advanced get_url Module Options] ****************************************

TASK [Gathering Facts] ********************************************************
ok: [localhost]

TASK [Create advanced downloads directory] ************************************
changed: [localhost]

TASK [Download with checksum validation] **************************************
changed: [localhost]

TASK [Download with timeout and retries] **************************************
changed: [localhost]

TASK [Download only if file doesn't exist] ************************************
changed: [localhost]

PLAY RECAP ********************************************************************
localhost                  : ok=5    changed=4    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Vérification des téléchargements avancés

Vérifions les fichiers que nous avons téléchargés avec les options avancées :

ls -l ~/project/ansible-get-url/advanced-downloads/

Vous devriez voir tous les fichiers téléchargés :

-rwxr-xr-x 1 labex labex 3773448 Mar 15 12:45 jq
-rw-r--r-- 1 labex labex     426 Mar 15 12:45 examples-readme.md
-rw-r--r-- 1 labex labex    1690 Mar 15 12:45 ansible-example.cfg

Testons si le binaire jq téléchargé fonctionne :

~/project/ansible-get-url/advanced-downloads/jq --version

Vous devriez voir une sortie indiquant la version de jq (par exemple, jq-1.6), confirmant que l'exécutable a été correctement téléchargé avec la somme de contrôle correcte.

Vous avez maintenant utilisé avec succès diverses options avancées du module get_url pour télécharger des fichiers avec différentes exigences et contraintes.

Mise en œuvre d'un déploiement d'application web pratique

Appliquons ce que nous avons appris dans un scénario plus pratique : le déploiement d'une application web simple en utilisant le module get_url d'Ansible.

Configuration du projet d'application web

Tout d'abord, créons une structure de répertoire pour notre application web :

mkdir -p ~/project/ansible-get-url/webapp/public
cd ~/project/ansible-get-url

Création du playbook de déploiement de l'application web

Maintenant, nous allons créer un playbook nommé deploy-webapp.yml qui téléchargera les fichiers nécessaires à notre application web :

---
- name: Deploy Web Application Files
  hosts: localhost
  become: no
  vars:
    webapp_dir: ~/project/ansible-get-url/webapp
    assets_base_url: https://raw.githubusercontent.com/ansible/ansible-documentation/devel/docs/docsite/rst/_static
  tasks:
    - name: Ensure webapp directories exist
      file:
        path: "{{ item }}"
        state: directory
        mode: "0755"
      loop:
        - "{{ webapp_dir }}"
        - "{{ webapp_dir }}/public"
        - "{{ webapp_dir }}/public/css"
        - "{{ webapp_dir }}/public/images"

    - name: Create index.html
      copy:
        dest: "{{ webapp_dir }}/public/index.html"
        content: |
          <!DOCTYPE html>
          <html>
          <head>
            <title>Ansible Demo App</title>
            <link rel="stylesheet" href="css/style.css">
          </head>
          <body>
            <div class="container">
              <h1>Welcome to Ansible Demo</h1>
              <p>This site was deployed using Ansible's get_url module!</p>
              <img src="images/ansible-logo.png" alt="Ansible Logo">
            </div>
          </body>
          </html>

    - name: Download CSS file
      get_url:
        url: "{{ assets_base_url }}/css/ansible.css"
        dest: "{{ webapp_dir }}/public/css/style.css"
        mode: "0644"
        timeout: 30
        retries: 3

    - name: Download Ansible logo
      get_url:
        url: "{{ assets_base_url }}/images/ansible_logo.svg"
        dest: "{{ webapp_dir }}/public/images/ansible-logo.png"
        mode: "0644"
        timeout: 30
        retries: 3

    - name: Install Python HTTP server
      apt:
        name: python3-http.server
        state: present
      become: yes

    - name: Display information about running the web server
      debug:
        msg: |
          Web application has been deployed!
          To start the web server, run:
          cd {{ webapp_dir }}/public && python3 -m http.server 8080
          Then access it at: http://localhost:8080

Ce playbook :

  1. Crée la structure de répertoire nécessaire pour notre application web
  2. Crée un fichier index.html avec un contenu HTML de base
  3. Télécharge un fichier CSS et une image du logo Ansible en utilisant le module get_url
  4. Installe un serveur HTTP Python
  5. Affiche des informations sur la façon d'exécuter le serveur web

Exécution du playbook de déploiement de l'application web

Exécutons le playbook :

ansible-playbook deploy-webapp.yml

Vous devriez voir une sortie indiquant que l'application web a été déployée avec succès.

Démarrage du serveur web

Maintenant, démarrons le serveur web pour tester notre application déployée :

cd ~/project/ansible-get-url/webapp/public
python3 -m http.server 8080 &

Le serveur web est maintenant en cours d'exécution en arrière-plan sur le port 8080. Si vous étiez dans un environnement normal avec accès au navigateur, vous pourriez accéder à l'application web à l'adresse http://localhost:8080.

Vérification des fichiers déployés

Vérifions que tous les fichiers requis ont été déployés correctement :

ls -la ~/project/ansible-get-url/webapp/public/

Vous devriez voir le fichier index.html et les répertoires que nous avons créés.

ls -la ~/project/ansible-get-url/webapp/public/css/

Cela devrait afficher le fichier CSS téléchargé.

ls -la ~/project/ansible-get-url/webapp/public/images/

Cela devrait afficher l'image du logo Ansible téléchargée.

Affichage du contenu HTML

Vérifions le contenu du fichier index.html :

cat ~/project/ansible-get-url/webapp/public/index.html

Vous devriez voir le contenu HTML que nous avons créé dans le playbook.

Arrêt du serveur web

Lorsque vous avez terminé les tests, vous pouvez arrêter le serveur web en trouvant son ID de processus et en le tuant :

pkill -f "python3 -m http.server 8080"

Félicitations ! Vous avez déployé avec succès une application web simple en utilisant le module get_url d'Ansible pour télécharger les fichiers nécessaires.

Résumé

Dans ce tutoriel, vous avez acquis une expérience pratique de l'utilisation du module get_url d'Ansible pour télécharger des fichiers à partir d'URL spécifiques. Vous avez appris :

  • Comment installer et configurer Ansible pour le développement local
  • Comment créer des playbooks de base en utilisant le module get_url pour télécharger des fichiers
  • Comment utiliser des options avancées telles que la validation de la somme de contrôle (checksum validation), les délais d'attente (timeouts), les tentatives (retries) et les téléchargements conditionnels
  • Comment mettre en œuvre un scénario pratique de déploiement d'application web en utilisant le module get_url

Ces compétences sont fondamentales pour automatiser les tâches de gestion de fichiers dans diverses opérations informatiques, notamment le déploiement de logiciels, la gestion de contenu et la configuration système. Le module get_url est un outil polyvalent qui peut être intégré dans des flux de travail Ansible plus complexes pour rationaliser vos processus de gestion d'infrastructure.

Au fur et à mesure que vous poursuivez votre parcours avec Ansible, envisagez d'explorer des modules connexes tels que uri, unarchive et synchronize, qui complètent le module get_url pour une automatisation plus complète de la gestion des fichiers.