Aller au contenu principal

Installation d'HashiCorp Vault sur un Noeud

Bienvenue dans ce guide détaillé sur l'installation d'HashiCorp Vault. Si vous avez déjà parcouru mon précédent guide sur l'introduction à Vault, vous savez déjà que Vault est un outil incontournable dans l'univers de la gestion des secrets et de la sécurité des données. Si ce n'est pas le cas, je vous invite à le consulter ici pour comprendre les bases et l'importance de Vault dans les environnements DevOps.

L'objectif de ce guide est de vous guider pas à pas à travers l'installation de Vault. Que vous soyez un administrateur système expérimenté ou que vous débutiez avec Vault, ce guide est conçu pour vous fournir toutes les informations nécessaires pour une installation réussie et sécurisée.

Prérequis Techniques​

Avant de plonger dans l'installation proprement dite de Vault, il est crucial de s'assurer que vous avez tout ce qu'il faut pour un déploiement réussi. Dans cette section, nous allons passer en revue les prérequis techniques et les compétences nécessaires pour installer Vault.

Configuration Système Requise​

La première étape est de s'assurer que votre système répond aux exigences minimales pour exécuter Vault. Voici ce dont vous aurez besoin :

  • *Système d'exploitation : Vault est compatible avec la plupart des systèmes d'exploitation modernes, y compris Linux, Windows et macOS. Assurez-vous d'utiliser une version prise en charge.
  • *Mémoire et Processeur : Bien que les besoins exacts dépendent de votre utilisation prévue, je recommande au minimum 2 Go de RAM et 2 cœurs de processeur pour une expérience fluide.
  • *Espace Disque : L'espace disque requis dépendra de la quantité de données que vous prévoyez de stocker dans Vault. Prévoyez suffisamment d'espace pour le stockage des secrets et des logs.

Dépendances Logicielles​

Certains composants logiciels sont nécessaires pour exécuter Vault :

  1. Backend de Stockage : Vault nécessite un backend de stockage pour conserver les secrets. Les options populaires incluent Consul, Etcd et les solutions de stockage cloud, mais ici nous utiliserons le stockage sur filesystems.

Installation de Vault​

L'utilisation d'Ansible pour installer Vault simplifie et automatise le processus, en garantissant la cohérence et la reproductibilité de l'installation sur différents environnements.

Préparation du Playbook Ansible​

Commencez par créer un playbook Ansible de base. Assurez-vous que vous avez Ansible installé sur votre machine de contrôle et que vous pouvez vous connecter à votre serveur cible.

Dans votre playbook, définissez les hôtes sur lesquels Vault doit être installé, ainsi que des variables permettant de paramétrer son exécution. Par exemple :

- hosts: mon_serveur_vault
  vars:
    vault_version: "1.15.4"
    vault_directory: /opt/vault
    vault_user: vault
    vault_group: vault
    vault_ui: false
    vault_tls_disabled: true

Ajoutez des tâches pour télécharger pour créer le groupe et l'utilisateur vault :

  tasks:
    - name: Create group vault
      become: true
      ansible.builtin.group:
        name: "{{ vault_group }}"
        state: present
    - name: Create user vault
      become: true
      ansible.builtin.user:
        name: "{{ vault_group }}"
        home: "{{ vault_directory }}"
        shell: /bin/nologin
        # shell: /bin/nologin
        create_home: false
        group: "{{ vault_group }}"
        state: present

On créé ensuite le répertoire qui recevra le binaire, la config et les données de vault :

    - name: Create vault directories
      become: true
      ansible.builtin.file:
        path: "{{ vault_directory }}/{{ item }}"
        owner: vault
        group: vault
        mode: "0755"
        state: directory
      loop:
        - data
        - bin
        - config

Pour éviter de télécharger à chaque exécution du playbook le binaire mettons en place un test que le binaire présent est bien celui avec la version attendue :

    - name: Check if vault bin exist
      become: true
      ansible.builtin.stat:
        path: "{{ vault_directory }}/bin/vault"
      register: vault_exist

On vérifie que la version de Vault installé est celle attendue dans un bloc. Si la version n'est pas celle attendue, on arrête le service.

    - name: Vault exist
      when: vault_exist.stat.exists
      block:
        - name: Check vault version
          become: true
          ansible.builtin.shell:
            cmd: "./vault --version | egrep -o '([0-9]{1,}\\.)+[0-9]{1,}'"
            chdir: "{{ vault_directory }}/bin"
          register: vault_version_installed
          changed_when: false
        - name: Stop Service if not good version
          when: vault_version_installed.stdout != vault_version
          become: true
          ansible.builtin.service:
            name: vault
            state: stopped

Si la version du binaire n'est pas celle attendue ou n'est pas présente, on le télécharge depuis le site officiel. On le décompresse et on le déplace dans le répertoire attendu.

 - name: Install Vault
   become: true
   ansible.builtin.unarchive:
     src: "https://releases.hashicorp.com/vault/{{ vault_version }}/vault_{{ vault_version }}_linux_amd64.zip"
     dest: "{{ vault_directory }}/bin"
     owner: vault
     group: vault
     mode: "0755"
     remote_src: true
   when: not vault_exist.stat.exists or vault_version_installed.stdout != vault_version

On crée le service avec un template :

    - name: Systemd unit
      become: true
      ansible.builtin.template:
        src: vault.service.j2
        dest: /etc/systemd/system/vault.service
        force: true
        owner: root
        group: root
        mode: "0644"
      notify: Reload vault

Le template du service :

# {{ ansible_managed }}

[Unit]
Description="HashiCorp Vault - A tool for managing pki and secrets"
Documentation=https://www.vaultproject.io/docs/
Requires=network-online.target
After=network-online.target
ConditionPathExists={{ vault_directory }}

[Service]
User={{ vault_user }}
Group={{ vault_group }}
ExecStart=/bin/sh -c 'exec {{ vault_directory }}/bin/vault server -config={{ vault_directory }}/config/vault.hcl'
ExecReload=/bin/kill --signal HUP $MAINPID
KillMode=process
KillSignal=SIGINT
Restart=on-failure
RestartSec=5
TimeoutStopSec=30
StartLimitInterval=60
StartLimitBurst=3
LimitNOFILE=524288
LimitNPROC=524288
LimitCORE=0

[Install]
WantedBy=multi-user.target

On fait de même avec la config :

    - name: Install config
      become: true
      ansible.builtin.template:
        src: vault.hcl.j2
        dest: "{{ vault_directory }}/config/vault.hcl"
        owner: vault
        group: vault
        mode: "0755"
      notify: Restart vault
      register: vault_config

Le template qui au format hcl :

storage "file" {
  path = "{{ vault_directory }}/data"
}

listener "tcp" {
  address = "0.0.0.0:8200"
  tls_disable = "{{ vault_tls_disabled }}"
}

ui = "{{ vault_ui }}"
disable_mlock = true
log_level = "Debug"

Et on démarre le service :

    - name: Start vault
      become: true
      ansible.builtin.service:
        name: vault
        state: started
      when: not vault_config.changed

Je vous livre mon astuce pour lancer plusieurs actions dans un handler ansible, en incluant plusieurs taches :

- name: Restart vault
  become: true
  ansible.builtin.service:
    name: vault
    state: restarted

- name: Reload vault
  ansible.builtin.include_tasks: reload.yml

Le contenu du fichier reload.yml :

- name: Reload Systemd
  become: true
  ansible.builtin.systemd:
    daemon_reload: true

- name: Reload Service
  become: true
  ansible.builtin.service:
    name: vault
    state: reloaded

Je suis en train de reconstruire mon homelab et je vous livrerai bientôt le code source de celui-ci dans sa totalité !

Exécution du Playbook et Vérification​

Exécutez le playbook pour installer Vault sur vos serveurs.

ansible-playbook playbook_vault.yml

Connectez-vous à votre serveur et vérifiez que Vault est installé correctement et que le service fonctionne.

systemctl status vault

● vault.service - "HashiCorp Vault - A tool for managing pki and secrets"
     Loaded: loaded (/etc/systemd/system/vault.service; enabled; preset: enabled)
     Active: active (running) since Thu 2024-02-01 07:30:21 CET; 13min ago
       Docs: https://www.vaultproject.io/docs/
   Main PID: 99824 (vault)
      Tasks: 9 (limit: 4454)
     Memory: 31.2M
        CPU: 1.470s
     CGroup: /system.slice/vault.service
             └─99824 /data/vault/bin/vault server -config=/data/vault/config/vault.hcl

En utilisant Ansible pour l'installation de Vault, vous bénéficiez d'une méthode automatisée et standardisée, réduisant les erreurs humaines et accélérant le processus de déploiement.

Initialisation du Vault​

Une fois que Vault est installé et configuré, l'étape suivante est son initialisation. Cette étape est importante car elle implique la création de clés de déverrouillage (unseal keys) et d'un jeton racine (root token), qui sont essentiels pour l'accès à Vault.

Pour initialiser Vault, utilisez la commande suivante :

export VAULT_ADDR=http://127.0.0.1:8200

vault operator init

Cette commande va configurer le stockage de clés de chiffrement et générer un ensemble de clés de déverrouillage et un jeton racine. Par défaut, Vault génère 5 clés de déverrouillage et nécessite au moins 3 pour déverrouiller le serveur.

Pour simplifier dans un environnement de lab, vous pouvez réduire le nombre de clés requises :

export VAULT_ADDR=http://127.0.0.1:8200

vault operator init -key-shares 1 -key-threshold 1

Unseal Key 1: lWF1ue8BgtW3/19Uf49GaAicvaebxtFWlDFvEIKvs3s=

Initial Root Token: hvs.FkLQnkIPosIar9SSeDfdsFEb

Vault initialized with 1 key shares and a key threshold of 1. Please securely
distribute the key shares printed above. When the Vault is re-sealed,
restarted, or stopped, you must supply at least 1 of these keys to unseal it
before it can start servicing requests.

Vault does not store the generated root key. Without at least 1 keys to
reconstruct the root key, Vault will remain permanently sealed!

It is possible to generate new unseal keys, provided you have a quorum of
existing unseal keys shares. See "vault operator rekey" for more information.

Cette commande crée une seule clé de déverrouillage.

Les clés de déverrouillage et le jeton racine sont les éléments les plus sensibles de Vault. Elles doivent être stockées avec le plus haut niveau de sécurité. En cas de compromission, un attaquant pourrait avoir un accès complet à vos secrets.

Pour un environnement de production, ces clés devraient être réparties entre des personnes de confiance et stockées dans des endroits sécurisés. Des solutions comme les gestionnaires de mots de passe d'entreprise, les coffres-forts numériques, ou même le stockage physique sécurisé peuvent être utilisés.

Le jeton racine donne un accès complet et sans restriction à Vault. Il doit être utilisé avec prudence et seulement quand c'est absolument nécessaire. Après l'initialisation initiale et la configuration, il est conseillé de le stocker en sécurité et de l'utiliser rarement.

Déverrouillage de Vault​

Après l'initialisation de Vault, il est nécessaire de déverrouiller l'instance pour qu'elle devienne opérationnelle. Cette étape, appelée "unsealing", est cruciale pour la sécurité et l'accessibilité de Vault.

Chaque fois que Vault démarre, il se lance dans un état scellé (sealed). Dans cet état, Vault est incapable d'accéder à ses données stockées ou de répondre aux demandes. Le déverrouillage est donc nécessaire après chaque redémarrage du serveur ou de l'instance Vault.

Si Vault a été scellé manuellement en réponse à une situation de sécurité (par exemple, une suspicion de compromission), il doit être déverrouillé une fois la situation résolue et la sécurité rétablie.

Pour déverrouiller Vault, utilisez la commande vault operator unseal. Vous devrez entrer les clés de déverrouillage générées lors de l'initialisation. Si vous avez configuré Vault avec une seule clé de déverrouillage pour le lab, une seule clé sera nécessaire. Dans un environnement de production avec un schéma de clés multiple (par exemple, 5 clés avec un seuil de 3), vous devrez fournir suffisamment de clés distinctes pour atteindre le seuil.

export VAULT_TOKEN=<votre token>

vault operator unseal <Votre_Clé_Unseal>

Unseal Key (will be hidden):
Key             Value
---             -----
Seal Type       shamir
Initialized     true
Sealed          false
Total Shares    1
Threshold       1
Version         1.15.4
Build Date      2023-12-04T17:45:28Z
Storage Type    file
Cluster Name    vault-cluster-58439b8a
Cluster ID      b7ffb63a-49cc-36c0-63cb-e3e9fdb8879b
HA Enabled      false

Répétez cette commande avec chaque clé unique jusqu'à ce que Vault soit déverrouillé. Le statut de déverrouillage sera affiché après chaque commande.

Après le déverrouillage, vérifiez que Vault fonctionne correctement en utilisant :

vault status

Ce statut doit indiquer que Vault est en état déverrouillé (unsealed) et prêt à l'emploi.

Audit et Monitoring de Vault​

Un aspect important de la gestion de Vault est la mise en place d'un système d'audit et de monitoring efficace. Cela permet de suivre les activités au sein de Vault, d'identifier les problèmes potentiels et de garantir la conformité aux politiques de sécurité.

Activation des Logs d'Audit​

Vault supporte plusieurs backends d'audit tels que les fichiers, Syslog et les sockets. Chaque backend a ses propres caractéristiques et convient à différents scénarios d'usage.

Pour activer un backend d'audit, utilisez la commande suivante. Par exemple, pour un fichier de log :

sudo touch /var/log/vault_audit.log
sudo chown vault:vault /var/log/vault_audit.log
sudo chmod 600 /var/log/vault_audit.log
vault audit enable file file_path=/var/log/vault_audit.log

Cette commande configure Vault pour écrire les logs d'audit dans un fichier spécifié.

Configuration du Monitoring​

Vault expose un endpoint /sys/health que vous pouvez interroger pour surveiller l'état de santé du service. Cela peut être intégré à des outils de monitoring comme Prometheus ou Nagios.

Vault fournit également des métriques via un endpoint /sys/metrics qui peut être utilisé pour collecter des données sur les performances et l'utilisation. Ces métriques peuvent être surveillées via des systèmes comme Prometheus.

Configurez des alertes basées sur les logs d'audit et les métriques pour être informé en cas de comportement anormal ou de problèmes de performance.

Conclusion et Perspectives​

Avec les étapes couvertes dans ce guide, vous avez maintenant une installation de Vault, prête à être intégrée dans votre environnement de travail. Nous avons parcouru l'installation, la configuration initiale, la mise en place de l'audit et du monitoring. Ces composantes constituent le cœur d'un déploiement efficace de Vault, offrant une fondation solide pour la gestion sécurisée de vos secrets et données sensibles.

Cependant, notre voyage avec Vault ne s'arrête pas là. Dans un prochain guide, nous explorerons en détail comment utiliser Vault pour gérer les infrastructures à clés publiques (PKI). Cette gestion des PKI est un élément crucial pour renforcer davantage la sécurité de vos communications et de vos données.

En particulier, nous verrons comment configurer Vault pour émettre des certificats TLS/SSL, ce qui est essentiel pour activer HTTPS sur vos serveurs et applications dont notre Vault. Ce pas supplémentaire vous permettra de garantir une communication sécurisée et chiffrée, non seulement au sein de votre infrastructure, mais aussi avec vos utilisateurs finaux.