Aller au contenu principal

ansible-docker-ubuntu-conf

Comment utiliser Ansible pour installer et configurer Docker sur Ubuntu​

Introduction

L'automatisation des serveurs joue désormais un rôle essentiel dans l'administration des systèmes, en raison de la nature jetable des environnements d'application modernes. Les outils de gestion de la configuration tels qu'Ansible sont généralement utilisés pour rationaliser le processus d'automatisation de la configuration du serveur en établissant des procédures standard pour les nouveaux serveurs tout en réduisant l'erreur humaine associée aux configurations manuelles.

Ansible offre une architecture simple qui ne nécessite pas de logiciel spécial pour être installé sur les nœuds. Il fournit également un ensemble robuste de fonctionnalités et de modules intégrés qui facilitent l'écriture de scripts d'automatisation.

Pré-requis​

En l'exécutant, ce manuel effectuera les actions suivantes sur vos hôtes Ansible:

  • Install aptitude, qui est préféré par Ansible comme alternative à la aptgestionnaire de paquets.
  • Installer les paquets de systèmes requis.
  • Installer la clé Docker GPG APT.
  • Ajouter le dépôt officiel Docker à la aptsources.
  • Installer Docker.
  • Installer le module Python Docker via pip.
  • Tirer l'image par défaut spécifiée par default_container_image de Docker Hub.
  • Créer le nombre de conteneurs définis par le container_count variable, chacune utilisant l'image définie par default_container_image, et exécuter la commande définie dans default_container_command dans chaque nouveau récipient.

Une fois l’exécution du playbook terminée, vous aurez un certain nombre de conteneurs créés en fonction des options que vous avez définies dans vos variables de configuration.

Pour commencer, connectez-vous à un utilisateur compatible sudo sur votre serveur de nœud de contrôle Ansible.

  1. Préparer votre playbook

Le fichier playbook.yml est l'endroit où toutes vos tâches sont définies. Une tâche est la plus petite unité d'action que vous pouvez automatiser à l'aide d'un playbook Ansible. Mais d'abord, créez votre fichier playbook en utilisant votre

sudo nano playbook.yml

Cela ouvrira un fichier YAML vide. Avant de vous lancer dans l'ajout de tâches à votre playbook, commencez par ajouter les éléments suivants :

---
- hosts: all
  become: true
  vars:
    container_count: 4
    default_container_name: docker
    default_container_image: ubuntu
    default_container_command: sleep 1

Presque tous les playbooks que vous rencontrez commenceront par des déclarations similaires à celle-ci. hosts déclare quels serveurs le nœud de contrôle Ansible ciblera avec ce playbook. become indique si toutes les commandes seront effectuées avec des privilèges root élevés.

vars, vous permet de stocker des données dans des variables. Si vous décidez de les modifier à l'avenir, vous n'aurez qu'à modifier ces lignes individuelles dans votre fichier. Voici une brève explication de chaque variable :

container_count : Le nombre de conteneurs à créer. default_container_name : Nom du conteneur par défaut. default_container_image : Image Docker par défaut à utiliser lors de la création de conteneurs. default_container_command : Commande par défaut à exécuter sur les nouveaux conteneurs.

Ajout de tâches d'installation de packages à votre playbook​

Par défaut, les tâches sont exécutées de manière synchrone par Ansible dans l'ordre de haut en bas de votre playbook. Cela signifie que l'ordre des tâches est important et que vous pouvez supposer en toute sécurité qu'une tâche finira de s'exécuter avant que la tâche suivante ne commence.

Toutes les tâches de ce manuel peuvent être autonomes et réutilisées dans vos autres manuels.

Ajoutez vos premières tâches d'installation d'aptitude, un outil d'interface avec le gestionnaire de paquets Linux, et d'installation des paquets système requis. Ansible s'assurera que ces paquets sont toujours installés sur votre serveur :

tasks:
    - name: Install aptitude
      apt:
        name: aptitude
        state: latest
        update_cache: true

    - name: Install required system packages
      apt:
        pkg:
          - apt-transport-https
          - ca-certificates
          - curl
          - software-properties-common
          - python3-pip
          - virtualenv
          - python3-setuptools
        state: latest
        update_cache: true

Ici, vous utilisez le module intégré apt Ansible pour demander à Ansible d'installer vos paquets. Les modules dans Ansible sont des raccourcis pour exécuter des opérations que vous devriez autrement exécuter en tant que commandes bash brutes. Ansible se rabat en toute sécurité sur apt pour l'installation de paquets si aptitude n'est pas disponible, mais Ansible a historiquement préféré aptitude.

Vous pouvez ajouter ou supprimer des paquets à votre guise. Cela garantira que tous les paquets sont non seulement présents, mais également sur la dernière version, et qu'ils sont exécutés après l'appel d'une mise à jour avec apt.

Ajout de tâches d'installation de Docker à votre​

Votre tâche installera la dernière version de Docker à partir du dépôt officiel. La clé GPG de Docker est ajoutée pour vérifier le téléchargement, le dépôt officiel est ajouté en tant que nouvelle source de paquets et Docker sera installé. De plus, le module Docker pour Python sera également installé :

- name: Add Docker GPG apt Key
      apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

    - name: Add Docker Repository
      apt_repository:
        repo: deb https://download.docker.com/linux/ubuntu focal stable
        state: present

    - name: Update apt and install docker-ce
      apt:
        name: docker-ce
        state: latest
        update_cache: true

    - name: Install Docker Module for Python
      pip:
        name: docker

Vous verrez que les modules Ansible intégrés apt_key et apt_repository sont d'abord dirigés vers les URL correctes, puis chargés de s'assurer qu'ils sont présents. Cela permet d'installer la dernière version de Docker et d'utiliser pip pour installer le module pour Python.

Ajout de tâches d'image et de conteneur Docker à votre playbook​

La création effective de vos conteneurs Docker commence ici par l'extraction de l'image Docker souhaitée. Par défaut, ces images Docker Hub. officiel de Docker. En utilisant cette image, les conteneurs seront créés selon les spécifications définies par les variables déclarées en tête de votre fichier playbook.yml

- name: Pull default Docker image
      community.docker.docker_image:
        name: "{{ default_container_image }}"
        source: pull

    - name: Create default containers
      community.docker.docker_container:
        name: "{{ default_container_name }}{{ item }}"
        image: "{{ default_container_image }}"
        command: "{{ default_container_command }}"
        state: present
      with_sequence: count={{ container_count }}
  • docker_image est utilisé pour extraire l'image Docker que vous souhaitez utiliser comme base pour vos conteneurs.
  • docker_container vous permet de spécifier les spécificités des conteneurs que vous créez, ainsi que la commande que vous souhaitez leur transmettre.
  • with_sequence est la manière dont Ansible crée une boucle, et dans ce cas, elle bouclera la création de vos conteneurs en fonction du nombre que vous avez spécifié.

Il s'agit d'une boucle de comptage de base, la variable item fournit donc ici un nombre représentant l'itération de la boucle en cours. Ce nombre est utilisé ici pour nommer vos conteneurs.

Révision de votre dossier complet playbook​

Votre playbook de jeu devrait ressembler à peu près à ce qui suit, avec des différences mineures en fonction de vos personnalisations :

---
- hosts: all
  become: true
  vars:
    container_count: 4
    default_container_name: docker
    default_container_image: ubuntu
    default_container_command: sleep 1d

  tasks:
    - name: Install aptitude
      apt:
        name: aptitude
        state: latest
        update_cache: true

    - name: Install required system packages
      apt:
        pkg:
          - apt-transport-https
          - ca-certificates
          - curl
          - software-properties-common
          - python3-pip
          - virtualenv
          - python3-setuptools
        state: latest
        update_cache: true

    - name: Add Docker GPG apt Key
      apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

    - name: Add Docker Repository
      apt_repository:
        repo: deb https://download.docker.com/linux/ubuntu focal stable
        state: present

    - name: Update apt and install docker-ce
      apt:
        name: docker-ce
        state: latest
        update_cache: true

    - name: Install Docker Module for Python
      pip:
        name: docker

    - name: Pull default Docker image
      community.docker.docker_image:
        name: "{{ default_container_image }}"
        source: pull

    - name: Create default containers
      community.docker.docker_container:
        name: "{{ default_container_name }}{{ item }}"
        image: "{{ default_container_image }}"
        command: "{{ default_container_command }}"
        state: present
      with_sequence: count={{ container_count }}

Exécution de votre playbook​

Vous êtes maintenant prêt à exécuter ce manuel sur un ou plusieurs serveurs. La plupart des manuels sont configurés pour être exécutés sur chaque serveur de votre inventaire par défaut, mais vous devrez spécifier votre serveur cette fois.

Pour exécuter le playbook uniquement sur le serveur 1, en vous connectant en tant que sammy, vous pouvez utiliser la commande suivante :

ansible-playbook playbook.yml -l server1 -u sammy

L'indicateur -l spécifie votre serveur et l'indicateur -u spécifie l'utilisateur auquel se connecter sur le serveur distant.

Une fois l'exécution du playbook terminée, connectez-vous via SSH au serveur provisionné par Ansible pour vérifier si les conteneurs ont été créés avec succès.

ssh sammy@your_remote_server_ip

Et listez vos conteneurs Docker sur le serveur distant :

sudo docker ps -a

Cela signifie que les conteneurs définis dans le playbook ont ​​été créés avec succès. Comme il s'agissait de la dernière tâche du playbook, cela confirme également que le playbook a été entièrement exécuté sur ce serveur.

Conclusion​

L'automatisation de la configuration de votre infrastructure peut non seulement vous faire gagner du temps, mais elle permet également de garantir que vos serveurs suivent une configuration standard qui peut être adaptée à vos besoins. Compte tenu de la nature distribuée des applications modernes et de la nécessité d'assurer la cohérence entre les différents environnements de mise à disposition, ce type d'automatisation est devenu un élément central des processus de développement de nombreuses équipes.