Ansible : Créer un fichier avec du contenu - Guide d'automatisation

Introduction

Ansible est un outil d'automatisation informatique puissant qui simplifie la gestion de l'infrastructure. Dans ce laboratoire pratique, vous apprendrez à utiliser Ansible pour créer des fichiers avec un contenu spécifique sur des systèmes cibles. À la fin de ce laboratoire, vous comprendrez les bases de la gestion de fichiers avec Ansible et serez capable de mettre en œuvre la création automatisée de fichiers dans votre propre infrastructure.

Installation et configuration d'Ansible

Avant de pouvoir commencer à utiliser Ansible pour créer des fichiers, nous devons l'installer et le configurer sur notre système. Mettons en place notre environnement :

Installation d'Ansible

Tout d'abord, nous allons mettre à jour les listes de paquets et installer Ansible sur notre système Ubuntu 22.04 :

sudo apt update
sudo apt install -y ansible

Après avoir exécuté ces commandes, vous devriez voir une sortie indiquant qu'Ansible a été installé avec succès. Vérifions l'installation :

ansible --version

Vous devriez voir une sortie similaire à celle-ci :

ansible [core 2.12.0]
  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
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, ...) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Création d'un inventaire Ansible simple

Ansible utilise un fichier d'inventaire pour définir les hôtes qu'il gérera. Pour ce laboratoire, nous allons créer un inventaire local qui inclut notre propre machine :

Créez un nouveau répertoire pour notre projet Ansible :

mkdir -p ~/project/ansible-files
cd ~/project/ansible-files

Créez un fichier d'inventaire en utilisant VSCode :
- Cliquez sur l'icône Explorer dans le WebIDE
- Naviguez vers le répertoire ~/project/ansible-files
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier inventory
- Ajoutez le contenu suivant au fichier :

[local]
localhost ansible_connection=local

Ce fichier d'inventaire indique à Ansible d'exécuter des commandes sur la machine locale sans utiliser SSH.

Créez un simple fichier ansible.cfg dans le même répertoire :
- Cliquez sur l'icône Explorer dans le WebIDE
- Naviguez vers le répertoire ~/project/ansible-files
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier ansible.cfg
- Ajoutez le contenu suivant au fichier :

[defaults]
inventory = ./inventory
host_key_checking = False

Vérifions notre configuration en exécutant une simple commande Ansible :

cd ~/project/ansible-files
ansible local -m ping

Vous devriez voir une sortie similaire à :

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

Cela confirme qu'Ansible est correctement installé et configuré pour exécuter des commandes sur votre machine locale.

Création de fichiers avec du contenu à l'aide des playbooks Ansible

Maintenant qu'Ansible est configuré, apprenons à créer des fichiers avec du contenu. Ansible fournit plusieurs modules pour la gestion des fichiers, et nous nous concentrerons sur le module copy dans cette étape.

Comprendre les playbooks Ansible

Les playbooks Ansible sont des fichiers YAML qui décrivent un ensemble de tâches à exécuter sur les hôtes cibles. Chaque tâche utilise un module Ansible spécifique pour effectuer une action.

Créons notre premier playbook pour créer un fichier avec du contenu :

Dans le WebIDE, créez un nouveau fichier dans le répertoire ~/project/ansible-files :
- Faites un clic droit sur le répertoire et sélectionnez "New File"
- Nommez le fichier create_file.yml
- Ajoutez le contenu suivant :

---
- name: Create a file with content
  hosts: local
  tasks:
    - name: Create a simple text file
      copy:
        dest: "~/project/hello.txt"
        content: |
          Hello from Ansible!
          This file was created using the Ansible copy module.
          Current date: {{ ansible_date_time.date }}

Comprenons ce que fait ce playbook :

La ligne hosts: local spécifie que ce playbook s'exécutera sur les hôtes du groupe local de notre inventaire.
La section tasks contient une liste de tâches à exécuter.
Le module copy est utilisé pour créer un fichier avec du contenu.
Le paramètre dest spécifie le chemin de destination du fichier.
Le paramètre content contient le contenu texte qui sera écrit dans le fichier.
{{ ansible_date_time.date }} est une variable qui sera remplacée par la date actuelle lors de l'exécution du playbook.

Maintenant, exécutons le playbook :

cd ~/project/ansible-files
ansible-playbook create_file.yml

Vous devriez voir une sortie similaire à :

PLAY [Create a file with content] ***********************************************

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

TASK [Create a simple text file] ***********************************************
changed: [localhost]

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

Vérifions que le fichier a été créé et qu'il contient le contenu attendu :

cat ~/project/hello.txt

Vous devriez voir une sortie similaire à :

Hello from Ansible!
This file was created using the Ansible copy module.
Current date: 2023-08-15

La date reflétera la date actuelle lorsque vous exécuterez le playbook.

Idempotence dans Ansible

L'idempotence est une fonctionnalité clé d'Ansible - l'exécution du même playbook plusieurs fois doit produire le même résultat. Exécutons à nouveau le playbook pour voir l'idempotence en action :

ansible-playbook create_file.yml

Cette fois, vous devriez voir que le nombre "changed" est 0 :

PLAY [Create a file with content] ***********************************************

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

TASK [Create a simple text file] ***********************************************
ok: [localhost]

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

Cela montre qu'Ansible reconnaît que le fichier existe déjà avec le contenu correct, il ne le modifie donc pas à nouveau.

Utilisation de variables et de modèles dans Ansible

Dans cette étape, nous allons explorer comment utiliser des variables et des modèles pour créer des fichiers plus dynamiques avec Ansible.

Travailler avec des variables

Les variables rendent vos playbooks plus flexibles et réutilisables. Créons un playbook qui utilise des variables pour créer un fichier de configuration :

Créez un nouveau fichier dans le WebIDE dans le répertoire ~/project/ansible-files :
- Faites un clic droit sur le répertoire et sélectionnez "New File"
- Nommez le fichier variables_demo.yml
- Ajoutez le contenu suivant :

---
- name: Create files using variables
  hosts: local
  vars:
    app_name: "MyApplication"
    app_version: "1.0.0"
    port_number: 8080
    log_level: "INFO"
  tasks:
    - name: Create config file with variables
      copy:
        dest: "~/project/app_config.ini"
        content: |
          ## Configuration for {{ app_name }}
          ## Generated by Ansible

          [application]
          name = {{ app_name }}
          version = {{ app_version }}

          [server]
          port = {{ port_number }}
          log_level = {{ log_level }}

Dans ce playbook :

La section vars définit les variables qui peuvent être utilisées dans tout le playbook.
Les variables sont référencées en utilisant la syntaxe {{ variable_name }}.
Le module copy est utilisé pour créer un fichier avec du contenu qui inclut ces variables.

Maintenant, exécutons le playbook :

cd ~/project/ansible-files
ansible-playbook variables_demo.yml

Vous devriez voir une sortie similaire à :

PLAY [Create files using variables] ********************************************

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

TASK [Create config file with variables] ***************************************
changed: [localhost]

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

Examinons le contenu du fichier généré :

cat ~/project/app_config.ini

Vous devriez voir une sortie similaire à :

## Configuration for MyApplication
## Generated by Ansible

[application]
name = MyApplication
version = 1.0.0

[server]
port = 8080
log_level = INFO

Utilisation des modèles Jinja2

Pour un contenu de fichier plus complexe, Ansible prend en charge les modèles Jinja2. Créons un fichier de modèle et utilisons-le dans un playbook :

Créez un répertoire de modèles :

mkdir -p ~/project/ansible-files/templates

Créez un fichier de modèle dans le WebIDE :
- Naviguez vers le répertoire ~/project/ansible-files/templates
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier web_config.j2
- Ajoutez le contenu suivant :

## Web Server Configuration
## Generated by Ansible on {{ ansible_date_time.date }}

server {
    listen {{ web_port }};
    server_name {{ server_name }};

    location / {
        root {{ doc_root }};
        index index.html;
    }

    {% if enable_ssl %}
    ## SSL Configuration
    ssl_certificate {{ ssl_cert }};
    ssl_certificate_key {{ ssl_key }};
    {% endif %}
}

Maintenant, créez un playbook qui utilise ce modèle :
- Naviguez vers le répertoire ~/project/ansible-files
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier template_demo.yml
- Ajoutez le contenu suivant :

---
- name: Create files using templates
  hosts: local
  vars:
    web_port: 80
    server_name: "example.com"
    doc_root: "/var/www/html"
    enable_ssl: true
    ssl_cert: "/etc/ssl/certs/example.com.crt"
    ssl_key: "/etc/ssl/private/example.com.key"
  tasks:
    - name: Create web server config from template
      template:
        src: templates/web_config.j2
        dest: ~/project/web_server.conf

Dans ce playbook :

Le module template est utilisé à la place de copy.
Le paramètre src pointe vers notre fichier de modèle.
Le paramètre dest spécifie où créer le fichier de sortie.
Les variables définies dans la section vars seront utilisées dans le modèle.

Exécutez le playbook :

cd ~/project/ansible-files
ansible-playbook template_demo.yml

Vous devriez voir une sortie similaire à :

PLAY [Create files using templates] ********************************************

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

TASK [Create web server config from template] **********************************
changed: [localhost]

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

Examinons le fichier de configuration généré :

cat ~/project/web_server.conf

Vous devriez voir une sortie similaire à :

## Web Server Configuration
## Generated by Ansible on 2023-08-15

server {
    listen 80;
    server_name example.com;

    location / {
        root /var/www/html;
        index index.html;
    }

    ## SSL Configuration
    ssl_certificate /etc/ssl/certs/example.com.crt;
    ssl_certificate_key /etc/ssl/private/example.com.key;
}

Remarquez comment le modèle Jinja2 a été rendu avec nos variables, et la section conditionnelle pour SSL a été incluse car enable_ssl était défini sur true.

Gestion avancée des fichiers avec Ansible

Dans cette dernière étape, nous allons explorer quelques techniques avancées de gestion de fichiers avec Ansible, notamment les permissions de fichiers, la création conditionnelle de fichiers et l'utilisation de plusieurs modules liés aux fichiers.

Définition des permissions et de la propriété des fichiers

Lors de la création de fichiers, vous devez souvent définir des permissions et une propriété spécifiques. Créons un playbook qui le démontre :

Créez un nouveau fichier dans le WebIDE :
- Naviguez vers le répertoire ~/project/ansible-files
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier file_permissions.yml
- Ajoutez le contenu suivant :

---
- name: Manage file permissions and ownership
  hosts: local
  tasks:
    - name: Create a script file with execute permissions
      copy:
        dest: ~/project/script.sh
        content: |
          #!/bin/bash
          echo "This script was created by Ansible"
          echo "Current user: $(whoami)"
          echo "Current directory: $(pwd)"
        mode: "0755"

    - name: Create a read-only configuration file
      copy:
        dest: ~/project/readonly.conf
        content: |
          ## This is a read-only configuration file
          setting1 = value1
          setting2 = value2
        mode: "0444"

Dans ce playbook :

Le paramètre mode est utilisé pour définir les permissions des fichiers.
0755 signifie lecture, écriture et exécution pour le propriétaire, et lecture et exécution pour le groupe et les autres.
0444 signifie lecture seule pour tout le monde.

Exécutez le playbook :

cd ~/project/ansible-files
ansible-playbook file_permissions.yml

Vous devriez voir une sortie similaire à :

PLAY [Manage file permissions and ownership] **********************************

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

TASK [Create a script file with execute permissions] **************************
changed: [localhost]

TASK [Create a read-only configuration file] **********************************
changed: [localhost]

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

Vérifions les permissions des fichiers créés :

ls -l ~/project/script.sh ~/project/readonly.conf

Vous devriez voir une sortie similaire à :

-rwxr-xr-x 1 labex labex 118 Aug 15 12:34 /home/labex/project/script.sh
-r--r--r-- 1 labex labex  73 Aug 15 12:34 /home/labex/project/readonly.conf

Vérifions que le script peut être exécuté :

~/project/script.sh

Vous devriez voir une sortie similaire à :

This script was created by Ansible
Current user: labex
Current directory: /home/labex/project/ansible-files

Création conditionnelle de fichiers

Parfois, vous devez créer des fichiers uniquement lorsque certaines conditions sont remplies. Créons un playbook qui démontre la création conditionnelle de fichiers :

Créez un nouveau fichier dans le WebIDE :
- Naviguez vers le répertoire ~/project/ansible-files
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier conditional_file.yml
- Ajoutez le contenu suivant :

---
- name: Conditional file creation
  hosts: local
  vars:
    environment: "development"
    create_debug_file: true
    create_backup: false
  tasks:
    - name: Create environment-specific configuration
      copy:
        dest: "~/project/{{ environment }}_config.yml"
        content: |
          ## Configuration for {{ environment }} environment
          debug: {{ 'enabled' if environment == 'development' else 'disabled' }}
          log_level: {{ 'DEBUG' if environment == 'development' else 'INFO' }}

    - name: Create debug log file
      copy:
        dest: ~/project/debug.log
        content: |
          ## Debug log file
          ## Created: {{ ansible_date_time.iso8601 }}
        mode: "0644"
      when: create_debug_file

    - name: Create backup directory
      file:
        path: ~/project/backup
        state: directory
        mode: "0755"
      when: create_backup

Dans ce playbook :

La directive when est utilisée pour l'exécution conditionnelle des tâches.
Les conditionnels Jinja2 sont utilisés dans le contenu du fichier pour modifier les valeurs en fonction des variables.
Le module file est utilisé pour créer un répertoire.

Exécutez le playbook :

cd ~/project/ansible-files
ansible-playbook conditional_file.yml

Vous devriez voir une sortie similaire à :

PLAY [Conditional file creation] **********************************************

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

TASK [Create environment-specific configuration] ******************************
changed: [localhost]

TASK [Create debug log file] **************************************************
changed: [localhost]

TASK [Create backup directory] ************************************************
skipped: [localhost]

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

Remarquez que la tâche "Create backup directory" a été ignorée car create_backup était défini sur false.

Examinons les fichiers créés :

cat ~/project/development_config.yml
cat ~/project/debug.log
ls -la ~/project/ | grep backup

Vous devriez voir le contenu des deux fichiers qui ont été créés et confirmer qu'aucun répertoire de sauvegarde n'a été créé.

Utilisation de plusieurs modules liés aux fichiers

Ansible fournit plusieurs modules pour la gestion des fichiers. Créons un playbook qui démontre l'utilisation de plusieurs modules liés aux fichiers :

Créez un nouveau fichier dans le WebIDE :
- Naviguez vers le répertoire ~/project/ansible-files
- Faites un clic droit et sélectionnez "New File"
- Nommez le fichier file_modules.yml
- Ajoutez le contenu suivant :

---
- name: Demonstrate file-related modules
  hosts: local
  tasks:
    - name: Create a directory
      file:
        path: ~/project/ansible_demo
        state: directory
        mode: "0755"

    - name: Create a file using the copy module
      copy:
        dest: ~/project/ansible_demo/copied.txt
        content: "This file was created using the copy module.\n"

    - name: Create a symbolic link
      file:
        src: ~/project/ansible_demo/copied.txt
        dest: ~/project/ansible_demo/link_to_copied.txt
        state: link

    - name: Create a file with blockinfile module
      blockinfile:
        path: ~/project/ansible_demo/block.txt
        create: true
        block: |
          This is a block of text
          that will be inserted
          as a single unit.
        marker: "## {mark} ANSIBLE MANAGED BLOCK"

Dans ce playbook :

Le module file est utilisé avec state: directory pour créer un répertoire.
Le module file est utilisé avec state: link pour créer un lien symbolique.
Le module blockinfile est utilisé pour créer un fichier avec un bloc de texte entouré de commentaires de marqueur.

Exécutez le playbook :

cd ~/project/ansible-files
ansible-playbook file_modules.yml

Vous devriez voir une sortie similaire à :

PLAY [Demonstrate file-related modules] ***************************************

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

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

TASK [Create a file using the copy module] ************************************
changed: [localhost]

TASK [Create a symbolic link] *************************************************
changed: [localhost]

TASK [Create a file with blockinfile module] **********************************
changed: [localhost]

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

Vérifions les résultats :

ls -la ~/project/ansible_demo/
cat ~/project/ansible_demo/copied.txt
cat ~/project/ansible_demo/link_to_copied.txt
cat ~/project/ansible_demo/block.txt

Vous devriez voir :

Un répertoire appelé ansible_demo
Un fichier appelé copied.txt avec le contenu spécifié
Un lien symbolique appelé link_to_copied.txt pointant vers copied.txt
Un fichier appelé block.txt avec un bloc de texte entouré de commentaires de marqueur

La sortie de la dernière commande devrait être similaire à :

## BEGIN ANSIBLE MANAGED BLOCK
This is a block of text
that will be inserted
as a single unit.
## END ANSIBLE MANAGED BLOCK

Cela démontre la polyvalence des capacités de gestion de fichiers d'Ansible.

Résumé

Félicitations pour avoir terminé ce laboratoire de gestion de fichiers Ansible. Vous avez appris plusieurs concepts et techniques importants :

Comment installer et configurer Ansible pour les tâches d'automatisation de base
Création de fichiers avec un contenu spécifique à l'aide du module copy
Utilisation de variables pour rendre le contenu de vos fichiers dynamique
Travailler avec les modèles Jinja2 pour une génération de fichiers plus complexe
Définition des permissions et de la propriété des fichiers
Mise en œuvre de la création conditionnelle de fichiers basée sur des variables
Utilisation de divers modules Ansible pour différentes tâches de gestion de fichiers

Ces compétences constituent une base solide pour l'automatisation des tâches de gestion de fichiers dans votre infrastructure. Avec Ansible, vous pouvez garantir un contenu de fichier cohérent sur plusieurs serveurs, appliquer les modifications de manière contrôlée et maintenir un enregistrement vérifiable de votre configuration.

Pour poursuivre votre parcours d'apprentissage d'Ansible, envisagez d'explorer des sujets plus avancés tels que les rôles, l'organisation des playbooks et l'intégration d'Ansible avec d'autres outils DevOps.

Comment créer un fichier avec du contenu dans Ansible

Introduction

Installation et configuration d'Ansible

Installation d'Ansible

Création d'un inventaire Ansible simple

Création de fichiers avec du contenu à l'aide des playbooks Ansible

Comprendre les playbooks Ansible

Idempotence dans Ansible

Utilisation de variables et de modèles dans Ansible

Travailler avec des variables

Utilisation des modèles Jinja2

Gestion avancée des fichiers avec Ansible

Définition des permissions et de la propriété des fichiers

Création conditionnelle de fichiers

Utilisation de plusieurs modules liés aux fichiers

Résumé