Module get_url Ansible : télécharger un fichier HTTP/HTTPS

ansible.builtin.get_url: télécharge un fichier depuis une URL HTTP/HTTPS/FTP directement sur le managed node (pas de passage par le control node). C’est le module n°1 RHCE 2026 pour récupérer un binaire upstream, une release applicative, un dépôt RPM custom, ou un fichier de config externe.

Options critiques : url:, dest:, mode:, checksum: (vérification d’intégrité), force: true (override), headers: (auth API), validate_certs: (TLS strict).

# Téléchargement avec vérification SHA-256 obligatoire (supply chain)
- ansible.builtin.get_url:
    url: https://releases.example.com/myapp-1.2.3.tar.gz
    dest: /opt/downloads/myapp-1.2.3.tar.gz
    checksum: "sha256:{{ myapp_checksum_sha256 }}"
    owner: root
    group: root
    mode: "0644"
    validate_certs: true       # défaut, mais explicite c'est mieux
    timeout: 60
  become: true

# Avec authentification Bearer (API privée)
- ansible.builtin.get_url:
    url: https://api.example.com/private/binary
    dest: /opt/downloads/private-bin
    headers:
      Authorization: "Bearer {{ vault_api_token }}"
    mode: "0755"
    checksum: "sha256:{{ private_bin_sha256 }}"
  no_log: true       # pour ne pas leaker le token en debug
  become: true

Sécurité non négociable :

checksum: sha256:... est mandatory en production. Sans ça, vous téléchargez aveuglément ce que le serveur HTTP envoie ; un attaquant qui prend le contrôle du miroir substitue le binaire et vous installez sa version. Utiliser SHA-256 (pas MD5/SHA-1, dépassés).
validate_certs: true (défaut) — ne jamais mettre false sauf debug ponctuel sur cert auto-signé interne. Désactiver TLS = MITM accepté.
no_log: true sur toute tâche avec headers: qui contient un token/password — sinon l’auth atterrit dans les logs en -v.
mode: explicite et restrictif : 0644 pour fichiers de conf/archive, 0755 pour binaires, 0600 pour fichiers de credentials.
timeout: explicite (30-60 s) — sans ça, un endpoint qui pend bloque le playbook indéfiniment.
Tester en check mode : --check télécharge un HEAD pour vérifier que l’URL répond, sans écrire le fichier. Utile pour valider une config en CI.

Ce que vous allez apprendre

Télécharger un fichier idempotent (Ansible vérifie ETag/Last-Modified par défaut).
Vérifier l’intégrité avec checksum: sha256:... (mandatory en prod).
Authentifier un download avec Basic Auth ou Bearer token.
Désactiver TLS strict avec validate_certs: false (à proscrire en prod).
Choisir entre get_url: (download fichier) et uri: (appel API).

Prérequis

Connaître la structure HTTP/HTTPS de base (URL, headers, status code).
Savoir générer un checksum SHA256 (sha256sum file.tar.gz).

Téléchargement basique

- name: Telecharger un binaire
  ansible.builtin.get_url:
    url: https://example.com/myapp-1.0.0.tar.gz
    dest: /opt/myapp.tar.gz
    mode: "0644"

À la première exécution, Ansible télécharge. Au 2ème run, il vérifie via ETag ou Last-Modified HTTP — pas de re-download si le serveur n’a pas changé.

Idempotence : get_url ne re-télécharge que si nécessaire. Pratique pour des artefacts versionnés où l’URL contient déjà la version.

Vérification d’intégrité (`checksum:`)

- name: Telecharger node_exporter avec verification SHA256
  ansible.builtin.get_url:
    url: https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
    dest: /opt/node_exporter.tar.gz
    checksum: sha256:a550cd5c05f760b7934a2d0afad66d2e92e681482f5f57a917465b1fba3b02a6
    mode: "0644"

Comportement :

Fichier téléchargé avec SHA256 différent de celui spécifié → tâche failed.
SHA256 identique → idempotent, pas de re-download.

Formats supportés :

sha256:<hex> — recommandé (collision-résistant).
sha512:<hex> — plus fort (overkill généralement).
sha1:<hex> — déprécié (cassé).
md5:<hex> — ne pas utiliser.
sha256:https://example.com/SHA256SUMS — récupère depuis URL et matche le filename.

Pattern production : toujours spécifier un checksum pour des binaires critiques. Sans, un MITM ou un repo compromis pousserait n’importe quoi.

Authentification

# Basic Auth (HTTP)
- ansible.builtin.get_url:
    url: https://repo.private.com/files/private.tar.gz
    dest: /opt/private.tar.gz
    url_username: "{{ vault_repo_user }}"
    url_password: "{{ vault_repo_password }}"
    mode: "0600"

# Bearer Token (API moderne)
- ansible.builtin.get_url:
    url: https://api.github.com/repos/myorg/myapp/releases/latest
    dest: /opt/release-meta.json
    headers:
      Authorization: "Bearer {{ vault_github_token }}"
      Accept: application/vnd.github+json
    mode: "0600"

Stockage des secrets : toujours dans Ansible Vault (vault_* par convention) — jamais hardcodé dans le playbook.

`force: true` (override l’idempotence)

- ansible.builtin.get_url:
    url: https://example.com/dynamic-content.txt
    dest: /opt/dynamic.txt
    force: true
    mode: "0644"

Par défaut, get_url est idempotent. force: true force le download à chaque run.

Cas d’usage : endpoint qui retourne du contenu dynamique (token CSRF, snapshot horaire), ou rotation d’un artefact.

`validate_certs: false` (DANGER)

- ansible.builtin.get_url:
    url: https://internal-dev.lab/file.tar.gz
    dest: /opt/file.tar.gz
    validate_certs: false   # DESACTIVE LE CHECK TLS — DANGER
    mode: "0644"

Désactive la vérification TLS — risque MITM. Cas légitimes : lab interne avec PKI self-signed, test temporaire en dev.

Jamais en prod : si vous voyez validate_certs: false en code de production, c’est une faille de sécurité — corrigez le truststore ou utilisez un certif valide (Let’s Encrypt, internal CA).

URL dynamique vs contenu identique

# La query string change a chaque run, mais le contenu serveur est identique
- ansible.builtin.get_url:
    url: "https://example.com/static.zip?cache_buster={{ ansible_date_time.epoch }}"
    dest: /opt/static.zip
    checksum: sha256:abc123...   # Compare le contenu, pas l URL

Si l’URL change à chaque run mais que le contenu est identique, Ansible ne peut pas savoir via ETag/Last-Modified. Le checksum sauve la mise : Ansible compare le contenu local au checksum attendu — si match, skip même si l’URL diffère.

Combiner avec `unarchive:`

- name: Telecharger et extraire node_exporter
  block:
    - ansible.builtin.get_url:
        url: https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
        dest: /tmp/node_exporter.tar.gz
        checksum: sha256:a550cd5c05f760b7934a2d0afad66d2e92e681482f5f57a917465b1fba3b02a6

    - ansible.builtin.unarchive:
        src: /tmp/node_exporter.tar.gz
        dest: /opt/
        remote_src: true
        creates: /opt/node_exporter-1.7.0.linux-amd64/node_exporter

Alternative plus directe : unarchive: src: accepte des URLs directement avec remote_src: true. Mais pas de checksum: côté unarchive: — si l’intégrité compte, faire get_url: puis unarchive: séparément.

Pièges courants

Symptôme	Cause	Fix
Re-download à chaque run sur URL stable	Pas d’ETag/Last-Modified côté serveur	Utiliser `checksum:` pour idempotence
Tâche failed silencieusement	Fichier corrompu sans `checksum:`	Toujours `checksum:` en prod
Téléchargement de 5Go reprend à 0	`get_url` ne supporte pas le resume	Utiliser `community.general.*` ou wget direct
MITM ne déclenche pas d’erreur	`validate_certs: false`	Ne jamais désactiver TLS sauf cas dev

À retenir

get_url: télécharge côté managed node (pas via control node).
Idempotent par défaut via ETag / Last-Modified HTTP.
checksum: sha256:... mandatory en prod pour vérification d’intégrité.
headers: pour Bearer tokens et API keys.
validate_certs: false = DANGER — uniquement en dev avec PKI interne.
URL dynamique → utiliser checksum: pour idempotence sur le contenu.

Pratiquer dans le lab

Cette page a un lab d’accompagnement : labs/modules-reseau/get-url/ dans stephrobert/ansible-training.

Challenge — sur db1.lab :

Télécharger gpl-3.0.txt dans /opt/lab-gpl3.txt.
Télécharger lgpl-3.0.txt dans /opt/lab-lgpl3.txt avec force: false.
Vérifier l’idempotence (2ème run = changed=0).

Validation pytest+testinfra :

ansible-playbook solution.yml
pytest -v labs/modules-reseau/get-url/challenge/tests/

4 tests vérifient l’existence, le mode, et le contenu des deux fichiers.

Prochaines étapes

Module uri Pour des appels API REST (GET/POST/PUT/DELETE) avec parsing JSON automatique

archive et unarchive Pour extraire le tarball téléchargé (combinaison get_url + unarchive)

Module dnf — options Si l'objectif est d'installer un paquet RHEL, dnf est plus adapté que get_url

Pivot Modules Vue d'ensemble des modules réseau, fichiers, paquets, RHEL système