Aller au contenu
DevSecOps Logo DevSecOps Logo DevSecOps
Docs
Blog
Blog

Les lookup Ansible

Mise à jour :

logo

Les lookups dans Ansible sont des outils puissants qui permettent d’accéder à des données externes et de les intégrer dynamiquement dans vos playbooks. Que vous ayez besoin de lire un fichier, de récupérer une variable d’environnement, ou de générer des données en temps réel, les lookups facilitent la gestion de configurations complexes. Dans ce guide, je vais vous montrer comment les utiliser efficacement pour rendre vos déploiements plus flexibles et adaptés à des environnements variés.

Qu’est-ce qu’un Lookup en Ansible ?

Un lookup dans Ansible est une fonction qui permet de récupérer des données externes à l’exécution d’un playbook. Il joue un rôle indispensable pour intégrer des données dynamiques provenant de sources externes comme des fichiers, des variables d’environnement, des résultats de commandes, ou même des générateurs de données. Contrairement aux variables définies directement dans un playbook ou un fichier d’inventaire, un lookup permet d’obtenir des informations qui ne sont pas nécessairement disponibles au moment de l’écriture du playbook, mais qui sont déterminées ou calculées lors de l’exécution.

Pourquoi utiliser les lookups ?

Prenons un exemple simple : vous avez un fichier sur votre serveur qui contient des configurations spécifiques à un environnement (comme des identifiants de base de données, des configurations réseau, ou des informations d’accès). Si vous écrivez un playbook pour déployer une application, vous devrez probablement utiliser ces informations. Au lieu de les coder en dur dans le playbook, ce qui limiterait sa réutilisabilité, vous pouvez utiliser un lookup pour lire ces données directement à partir du fichier.

Un autre cas d’utilisation courant des lookups est la récupération de variables d’environnement. Par exemple, si vous déployez des applications sur différents serveurs et que chaque serveur a des variables d’environnement spécifiques, comme le chemin d’accès aux fichiers logs, ou l’URL de l’API à utiliser, le lookup permet d’obtenir ces informations sans modifier le playbook à chaque fois.

Comment fonctionne un lookup ?

Lorsqu’un lookup est appelé dans une tâche Ansible, il est exécuté localement, c’est-à-dire qu’il s’exécute sur la machine qui lance le playbook, et non sur les hôtes distants où le playbook est déployé. Cela signifie que les informations qu’il récupère doivent être disponibles localement, sauf dans le cas de certaines données spécifiques comme les variables d’environnement qui existent également sur les hôtes distants.

Par exemple, si vous utilisez lookup(‘file’), Ansible s’attend à trouver ce fichier sur la machine qui exécute le playbook, pas sur les hôtes cibles.

Différences entre lookup et variables

La principale différence entre un lookup et une variable classique est que le lookup est calculé à l’exécution, tandis que les variables sont généralement statiques et définies à l’avance dans un fichier d’inventaire ou un playbook. Cela fait des lookups un outil parfait pour accéder à des informations qui ne sont disponibles que dynamiquement ou dans des fichiers externes.

En résumé, un lookup est une méthode dynamique pour intégrer des données externes ou générer des valeurs en temps réel lors de l’exécution d’un playbook.

Syntaxe des Lookups dans un Playbook

L’intégration des lookups dans un playbook Ansible nécessite une compréhension de la syntaxe propre à cette fonction. Contrairement aux variables traditionnelles, les lookups sont appelés à l’intérieur de blocs spécifiques qui permettent de récupérer et manipuler des données externes pendant l’exécution du playbook. Cette section va détailler la syntaxe de base des lookups et expliquer comment les intégrer correctement dans vos tâches Ansible.

Utilisation des lookups

Les lookups peuvent être utilisés dans plusieurs parties d’un playbook, en fonction du besoin. Voici les trois principaux endroits où vous pouvez les intégrer :

  1. Dans une tâche : C’est l’utilisation la plus courante. On fait appel au lookup dans une tâche pour obtenir des données dynamiques lors de l’exécution d’une action.

    Exemple avec une tâche qui lit un fichier :

     - name: Copie de la clé publique
       authorized_key:
         user: vagrant
         state: present
         key: "{{ lookup('file', '~/.ssh/id_rsa.pub') }}"

  2. Dans une variable : Il est possible d’initialiser une variable avec le résultat d’un lookup. Cela peut être utile lorsque vous souhaitez réutiliser plusieurs fois la même donnée issue d’un lookup dans plusieurs tâches.

    Exemple avec une variable définie via un lookup :

    - hosts: all
      vars:
        config_data: "{{ lookup('file', '/etc/config.txt') }}"
      tasks:
        - name: Afficher le contenu de la variable config_data
          ansible.builtin.debug:
            msg: "{{ config_data }}"

    Dans cet exemple, la variable config_data est définie une seule fois grâce au lookup et ensuite réutilisée dans plusieurs tâches si nécessaire.

  3. Dans un fichier de modèle (template) : Les lookups sont souvent utilisés dans les fichiers jinja pour insérer des données dynamiques dans des fichiers de configuration que vous générez avec Ansible.

    Exemple d’un fichier template avec un lookup :

    # fichier de configuration généré
    configuration={{ lookup('file', '/chemin/vers/paramètres.txt') }}

    Dans ce modèle, le lookup insère le contenu d’un fichier directement dans la configuration générée par le template.

Utilisation des paramètres avec lookup

Certains plugins lookup acceptent des arguments supplémentaires. Par exemple, le plugin file permet de spécifier un chemin vers un fichier et le plugin password permet de définir la longueur du mot de passe généré.

Prenons l’exemple du lookup password :

- name: Générer un mot de passe de 16 caractères
  ansible.builtin.debug:
    msg: "{{ lookup('password', '/dev/null length=16') }}"

Ici, le lookup génère un mot de passe de 16 caractères grâce au paramètre length=16.

Utilisation de lookups avec des boucles

Les lookups peuvent être utilisés dans des boucles pour interroger plusieurs fichiers ou ressources. Par exemple, si vous avez plusieurs fichiers à lire et que vous souhaitez éviter de dupliquer vos tâches, vous pouvez utiliser une boucle with_items ou loop.

Exemple de lookup avec une boucle :

- name: Lire plusieurs fichiers de configuration
  ansible.builtin.debug:
    msg: "{{ lookup('file', item) }}"
  with_items:
    - '/etc/config1.txt'
    - '/etc/config2.txt'
    - '/etc/config3.txt'

Dans cet exemple, Ansible parcourt chaque fichier spécifié dans la liste et utilise le lookup pour en afficher le contenu.

Exemple complet de syntaxe avec lookup

Pour résumer, voici un exemple complet de playbook qui utilise plusieurs lookups dans des contextes différents :

- hosts: localhost
  vars:
    config_file: "{{ lookup('file', '/etc/app/config.txt') }}"
    env_variable: "{{ lookup('env', 'USER') }}"


  tasks:
    - name: Afficher le contenu du fichier de configuration
      ansible.builtin.debug:
        msg: "Contenu du fichier: {{ config_file }}"


    - name: Afficher la variable d'environnement USER
      ansible.builtin.debug:
        msg: "Utilisateur: {{ env_variable }}"


    - name: Générer un mot de passe
      ansible.builtin.debug:
        msg: "Mot de passe généré : {{ lookup('password', '/dev/null length=12') }}"

Ce playbook démontre comment les lookups peuvent être utilisés pour lire un fichier, récupérer une variable d’environnement et générer un mot de passe. La syntaxe et la flexibilité des lookups permettent d’accéder dynamiquement à des ressources externes, rendant les playbooks plus adaptatifs et puissants.

Principaux Lookups dans Ansible, regroupés par catégorie

Les lookups dans Ansible permettent d’accéder à différentes sources de données au moment de l’exécution d’un playbook. Voici un aperçu des principaux lookups disponibles dans la collection ansible.builtin, classés par fonction, pour vous aider à les utiliser efficacement dans vos playbooks.

Gestion des fichiers et contenu

Ces lookups sont principalement utilisés pour lire ou lister le contenu de fichiers locaux ou distants. Ils sont très utiles lorsque vos playbooks doivent extraire des informations de fichiers de configuration, de modèles ou de ressources distantes.

  • file : Ce lookup permet de lire le contenu d’un fichier. Utile pour récupérer des configurations spécifiques ou des données texte depuis des fichiers plats.

  • fileglob : Liste tous les fichiers qui correspondent à un modèle donné (par exemple, des fichiers portant une extension spécifique dans un dossier). Pratique pour traiter plusieurs fichiers à la fois.

  • first_found : Ce lookup renvoie le premier fichier trouvé à partir d’une liste de chemins spécifiés. Il est utile lorsqu’il faut vérifier plusieurs emplacements pour une ressource.

  • template : Récupère le contenu d’un fichier après l’avoir traité via jinja, permettant d’insérer des variables et de personnaliser les fichiers à la volée.

  • unvault : Ce lookup lit les fichiers chiffrés avec Ansible Vault et retourne leur contenu en clair après déchiffrement.

  • url : Permet de récupérer le contenu d’une URL. Utile pour télécharger des fichiers distants ou récupérer des ressources en ligne pendant l’exécution d’un playbook.

Gestion des variables et environnements

Ces lookups facilitent l’accès aux variables, qu’il s’agisse de variables d’environnement ou de variables définies dans le playbook.

  • env : Ce lookup permet de récupérer la valeur d’une variable d’environnement sur la machine locale ou distante.

  • vars : Permet d’accéder aux variables définies dans un playbook et de les utiliser de manière dynamique dans d’autres parties du playbook.

  • varnames : Recherche les noms de variables dans l’environnement d’exécution et renvoie les variables correspondantes.

  • password : Ce lookup permet de générer ou de récupérer des mots de passe aléatoires, utiles pour la création d’utilisateurs ou d’identifiants uniques.

Gestion des structures de données

Ces lookups sont spécialisés dans la gestion des structures complexes comme les dictionnaires, listes, ou tableaux. Ils facilitent l’extraction de données à partir de formats plus structurés.

  • csvfile : Lit les données d’un fichier CSV ou TSV et permet de les manipuler dans les playbooks.

  • dict : Ce lookup renvoie les paires clé/valeur d’un dictionnaire pour faciliter l’accès aux données stockées sous forme de clé-valeur.

  • indexed_items : Ce lookup prend une liste d’éléments et retourne la liste avec des index. Utile pour réécrire des listes avec un identifiant unique.

  • items : Permet de lister les éléments d’une structure, généralement utilisée pour parcourir des listes dans des playbooks.

  • list : Renvoie simplement ce qui lui est donné. Pratique pour manipuler des données sous forme de listes dans Ansible.

  • nested : Compose une liste en combinant des éléments imbriqués provenant d’autres listes, ce qui permet de créer des structures plus complexes.

  • subelements : Utilisé pour parcourir des listes de dictionnaires et extraire des sous-éléments imbriqués. Particulièrement utile pour des structures de données JSON ou YAML complexes.

  • together : Fusionne plusieurs listes pour créer une liste synchronisée. Utile pour combiner plusieurs sources de données dans une même tâche.

Gestion des inventaires et hôtes

Ces lookups permettent de récupérer des informations sur les hôtes et inventaires, facilitant ainsi la gestion des environnements complexes.

Commandes et pipelines

Ces lookups permettent d’exécuter des commandes sur le système local et de capturer leur sortie dans un playbook.

  • lines : Exécute une commande et renvoie ses lignes de sortie une par une. Cela peut être utilisé pour parcourir la sortie de commandes complexes.

  • pipe : Lit la sortie d’une commande exécutée sur le système local et la réutilise dans les tâches suivantes du playbook.

Choix et séquences

Ces lookups permettent de manipuler des listes et de choisir ou générer des séquences aléatoires ou définies.

  • random_choice : Ce lookup renvoie un élément aléatoire à partir d’une liste. Très utile pour des tâches où des choix aléatoires sont nécessaires (comme des tests ou des environnements de développement).

  • sequence : Génère une séquence numérique, utile pour automatiser des boucles et des tâches répétitives.

Fichiers de configuration

Ces lookups sont orientés vers la lecture et la manipulation des fichiers de configuration, tels que les fichiers INI ou les options de configuration Ansible.

  • config : Renvoie les valeurs des options de configuration Ansible en cours, facilitant la vérification ou l’ajustement des paramètres pendant l’exécution d’un playbook.

  • ini : Ce lookup permet de lire et manipuler des données provenant de fichiers INI, format courant pour les fichiers de configuration.

Bonnes pratiques

  1. Utiliser les lookups de manière locale : Les lookups s’exécutent localement sur la machine qui exécute le playbook et non sur les hôtes cibles. Il est donc important de comprendre que les fichiers ou ressources interrogés doivent être accessibles localement. Si vous avez besoin d’accéder à des ressources sur les hôtes distants, envisagez d’autres méthodes comme les modules ou des copies locales.
  2. Gérer les erreurs et les exceptions : Lors de l’utilisation d’un lookup, il est recommandé de prévoir des mécanismes de gestion des erreurs pour éviter que le playbook échoue en cas d’absence de fichier ou de ressource. Vous pouvez utiliser des filtres comme default() pour définir une valeur de secours si un lookup échoue, afin de rendre vos playbooks plus robustes.
  3. Optimiser les performances: Les lookups peuvent entraîner des ralentissements, surtout lorsqu’ils interrogent des ressources externes (comme des fichiers ou des URL). Minimisez leur utilisation excessive ou imbriquée dans des boucles pour améliorer la performance des playbooks. Préférez définir les valeurs récupérées via des lookups dans des variables si elles sont utilisées à plusieurs endroits.
  4. Choisir le lookup adapté : Ansible propose une large gamme de lookups pour différents usages. Assurez-vous de bien comprendre les fonctionnalités et les limites de chaque plugin afin de choisir le lookup le plus approprié à votre besoin, qu’il s’agisse de récupérer des fichiers, de lire des variables d’environnement ou de traiter des structures de données complexes.
  5. Sécuriser les données sensibles : Lorsque vous utilisez des lookups pour accéder à des informations sensibles, comme des mots de passe ou des clés de sécurité, veillez à protéger ces données. Utilisez Ansible Vault pour chiffrer les fichiers contenant ces informations et assurez-vous que seules les personnes ou systèmes autorisés y ont accès.

Conclusion

Les lookups dans Ansible sont des outils puissants qui vous permettent de dynamiser vos playbooks en accédant à des données externes de manière flexible. Grâce aux lookups, vous pouvez interroger des fichiers locaux, des variables d’environnement, des résultats de commandes ou des ressources distantes comme des URL. Ils offrent une solution idéale pour rendre vos configurations adaptables et réutilisables, en particulier dans des environnements changeants ou complexes.

Cependant, comme pour tout outil, une utilisation judicieuse est essentielle. En choisissant les lookups adaptés à chaque situation, en gérant correctement les erreurs et en optimisant leur utilisation pour éviter des ralentissements inutiles, vous pouvez créer des playbooks plus efficaces et robustes. Les lookups ne sont pas seulement un moyen d’accéder à des informations, mais aussi un levier pour rendre vos déploiements Ansible plus intelligents et agiles.

Avec une bonne compréhension de leurs capacités et limitations, vous serez capable de tirer pleinement parti des lookups, améliorant ainsi la gestion de vos infrastructures automatisées et vos processus de configuration.