:warning: Ce projet open source soutenu par la communauté a atteint sa FIN DE VIE et ne recevra que des mises à jour de sécurité et des corrections de bogues critiques à l'avenir. Toute la fonctionnalité de ce projet (et plus encore) est disponible dans le Ansible Collection pour Venafi, qui est en développement actif. Le passage est facile, il suffit d'installer la collection venafi.machine_identity en utilisant Ansible Galaxy et de remplacer role: venafi.ansible_role_venafi par role: venafi.machine_identity.certificate dans vos playbooks. Veuillez effectuer la transition dès que possible.

Rôle Venafi pour Ansible

Cette solution ajoute des capacités d'enregistrement de certificats à Red Hat Ansible en s'intégrant parfaitement avec la Venafi Trust Protection Platform ou Venafi as a Service d'une manière qui garantit la conformité à la politique de sécurité de l'entreprise et offre une visibilité sur l'émission de certificats à l'échelle de l'entreprise.

:red_car: Testez nos exemples d'intégration aujourd'hui

Nous vous montrons étape par étape comment ajouter des certificats à votre automatisation Infrastructure as Code avec Ansible.

Produits	Exemples d'intégration disponibles...
	Comment configurer une livraison d'application sécurisée en utilisant F5 BIG-IP et le rôle Ansible Venafi
	Comment configurer une livraison d'application sécurisée en utilisant Citrix ADC et le rôle Ansible Venafi

REMARQUE Si vous ne voyez pas d'exemple pour un produit que vous utilisez, revenez plus tard. Nous travaillons dur pour ajouter plus d'exemples d'intégration.

Exigences

Passez en revue les prérequis Venafi, puis installez Ansible et VCert-Python (v0.10.0 ou supérieur) avec pip :

pip install ansible vcert --upgrade

Utilisation avec Ansible Galaxy

Pour plus d'informations sur Ansible Galaxy, rendez-vous sur https://galaxy.ansible.com/docs/using/installing.html

1. Installez le Rôle Venafi pour Ansible depuis Ansible Galaxy :

   ansible-galaxy install venafi.ansible_role_venafi
   

2. Créez le fichier credentials.yml et remplissez-le avec les paramètres de connexion :

   Trust Protection Platform :

   cat <<EOF >>credentials.yml
   access_token: 'p0WTt3sDPbzm2BDIkoJROQ=='
   url: 'https://tpp.venafi.example'
   zone: "DevOps\\Ansible"
   trust_bundle: "/path/to/bundle.pem"
   EOF
   

   Venafi as a Service :

   cat <<EOF >>credentials.yml
   token: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
   zone: 'Business App\\Enterprise CIT'
   EOF
   

   Le Rôle Venafi pour Ansible prend en charge les paramètres de connexion et d'identification suivants :

   Nom de la variable	Description
   access_token	Jeton d'accès de la Trust Protection Platform pour l'application API "ansible-by-venafi"
   password	[DÉPRÉCIÉ] Mot de passe WebSDK de la Trust Protection Platform, utilisez access_token si possible
   test_mode	Lorsque "true", le rôle fonctionne sans se connecter à la Trust Protection Platform ou à Venafi as a Service
   token	Clé API pour Venafi as a Service
   trust_bundle	Fichier texte contenant les certificats d'ancrage de confiance au format PEM
   url	URL du service Venafi (ex. "https://tpp.venafi.example"), généralement applicable uniquement à la Trust Protection Platform
   user	[DÉPRÉCIÉ] Nom d'utilisateur WebSDK de la Trust Protection Platform, utilisez access_token si possible
   zone	Dossier de politique pour TPP ou nom d'application et alias de modèle d'émission pour VaaS (ex. "Business App\Enterprise CIT")

3. Utilisez ansible-vault pour chiffrer le fichier credentials.yml avec un mot de passe. C'est optionnel mais fortement recommandé. Tant que vous connaissez le mot de passe, vous pouvez toujours déchiffrer le fichier pour apporter des modifications, puis le re-chiffrer. Rendez-vous sur https://docs.ansible.com/ansible/latest/user_guide/vault.html pour plus d'informations.

   ansible-vault encrypt credentials.yml
   

4. Écrivez un playbook simple nommé, par exemple, sample.yml.

   - hosts: localhost
     roles:
       - role: venafi.ansible_role_venafi
         certificate_cert_dir: "/tmp/etc/ssl/{{ certificate_common_name }}"
   

5. Exécutez le playbook.

   ansible-playbook sample.yml --ask-vault-pass
   

   L'exécution du playbook générera un certificat et le placera dans le dossier /tmp/etc/ssl/. Le paramètre --ask-vault-pass est nécessaire si vous avez chiffré le fichier credentials.yml. D'autres variables de playbook peuvent être ajoutées pour spécifier les propriétés du certificat et de la paire de clés, les emplacements des fichiers, et pour remplacer les comportements par défaut.

   Nom de la variable	Description
   credentials_file	Nom du fichier contenant les identifiants Venafi et les paramètres de connexion Par défaut : credentials.yml
   certificate_common_name	Nom commun à demander pour le certificat. Par défaut : "{{ ansible_fqdn }}"
   certificate_alt_name	Liste séparée par des virgules des Noms alternatifs de sujet à demander pour le certificat. Préfixez chaque valeur avec le type SAN. Exemple : "DNS:host.example.com,IP:10.20.30.40,email:[email protected]"
   certificate_privatekey_type	Algorithme de clé, "RSA" ou "ECDSA" Par défaut : "RSA" (de VCert)
   certificate_privatekey_size	Taille de la clé en bits pour les clés RSA Par défaut : "2048" (de VCert)
   certificate_privatekey_curve	Courbe elliptique pour les clés ECDSA Par défaut : "P251" (de VCert)
   certificate_privatekey_passphrase	Mot de passe à utiliser pour chiffrer la clé privée
   certificate_chain_option	Spécifie si le certificat CA racine apparaît "dernier" (par défaut) ou "premier" dans le fichier de chaîne
   certificate_cert_dir	Répertoire parent local où les actifs cryptographiques seront stockés Par défaut : "/etc/ssl/{{ certificate_common_name }}"
   certificate_cert_path	Répertoire local où les fichiers de certificats seront stockés Par défaut : {{ certificate_cert_dir }}/{{ certificate_common_name }}.pem
   certificate_chain_path	Répertoire local où les fichiers de chaîne de certificats seront stockés Par défaut : "{{ certificate_cert_dir }}/{{ certificate_common_name }}.chain.pem"
   certificate_privatekey_path	Répertoire local où les fichiers de clés privées seront stockés Par défaut : "{{ certificate_cert_dir }}/{{ certificate_common_name }}.key"
   certificate_csr_path	Répertoire local où les fichiers de demande de signature de certificat seront stockés Par défaut : "{{ certificate_cert_dir }}/{{ certificate_common_name }}.csr"
   certificate_remote_execution	Spécifie si les actifs cryptographiques seront générés à distance ou localement puis fournis à l'hôte distant Par défaut : false
   certificate_remote_cert_path	Répertoire sur l'hôte distant où les fichiers de certificats seront stockés Par défaut : "{{ certificate_cert_dir }}/{{ certificate_common_name }}.pem"
   certificate_remote_chain_path	Répertoire sur l'hôte distant où les fichiers de chaîne de certificats seront stockés Par défaut : "{{ certificate_cert_dir }}/{{ certificate_common_name }}.chain.pem"
   certificate_remote_privatekey_path	Répertoire sur l'hôte distant où les fichiers de clés privées seront stockés Par défaut : "{{ certificate_cert_dir }}/{{ certificate_common_name }}.key"
   certificate_copy_private_key_to_remote	Spécifie s'il faut copier le fichier de clé privée sur l'hôte distant Par défaut : true
   certificate_before_expired_hours	Nombre d'heures avant l'expiration du certificat avant qu'il puisse être renouvelé Par défaut : 72
   certificate_renew	Spécifie s'il faut renouveler le certificat s'il est dans la fenêtre "before_expired_hours" lorsque le playbook est exécuté Par défaut : true
   certificate_force	Spécifie s'il faut demander un nouveau certificat chaque fois que le playbook est exécuté Par défaut : false

   Les valeurs par défaut sont définies dans le fichier defaults/main.yml.

Préparer un environnement de démonstration Docker pour exécuter Ansible

1. (Optionnel) Préparez l'environnement de démonstration. Si vous souhaitez utiliser votre propre inventaire, mettez à jour le fichier tests/inventory.

   1. Pour exécuter notre playbook de test/démonstration, vous aurez besoin du rôle de provisionnement Docker. Téléchargez-le dans le répertoire tests/roles/provision_docker :

      git clone https://github.com/chrismeyersfsu/provision_docker.git tests/roles/provision_docker
      

   2. Ensuite, construisez les images Docker nécessaires pour le playbook de démonstration :

      docker build ./tests --tag local-ansible-test
      

   Les certificats de démonstration seront placés dans le répertoire /tmp/ansible/etc/ssl sur l'hôte Ansible. De là, ils seront distribués au répertoire /etc/ssl/ des hôtes distants.

2. Générez un fichier de crédentiels pour la Trust Protection Platform ou Venafi as a Service comme décrit dans la section ci-dessus.

3. Exécutez le playbook Ansible (supprimez docker_demo=true si vous souhaitez utiliser votre propre inventaire). Le contenu de credentials.yml sera utilisé pour décider si la Trust Protection Platform ou Venafi as a Service est utilisée. Si vous définissez le paramètre token, le playbook suppose que vous utilisez Venafi as a Service. Si vous définissez les paramètres access_token ou password, le playbook suppose que vous utilisez la Trust Protection Platform.

   ansible-playbook -i tests/inventory \
     tests/venafi-playbook-example.yml \
     --extra-vars "credentials_file=credentials.yml docker_demo=true" \
     --ask-vault-pass
   

   On vous demandera le mot de passe pour déchiffrer le credentials.yml comme précédemment. Le fichier source des identifiants peut être remplacé à l'aide de la variable credentials_file et ceci peut être spécifié sur la ligne de commande en utilisant le paramètre --extra-vars comme montré.

Exemple de Playbook

- hosts: servers
  roles:
    - role: "ansible-role-venafi"
      certificate_common_name: "{{ ansible_fqdn }}.venafi.example.com"
      certificate_cert_dir: "/tmp/ansible/etc/ssl/{{ certificate_common_name }}"
      certificate_cert_path: "{{ certificate_cert_dir }}/{{ certificate_common_name }}.pem"
      certificate_chain_path: "{{ certificate_cert_dir }}/{{ certificate_common_name }}.chain.pem"
      certificate_privatekey_path: "{{ certificate_cert_dir }}/{{ certificate_common_name }}.key"
      certificate_csr_path: "{{ certificate_cert_dir }}/{{ certificate_common_name }}.csr"

      # Où exécuter le module venafi_certificate. Si défini sur false, le certificat sera
      # créé sur l'hôte maître Ansible puis copié sur le serveur distant.
      certificate_remote_execution: false
      # Emplacement distant où placer le certificat.
      certificate_remote_cert_dir: "/etc/ssl"
      certificate_remote_cert_path: "{{ certificate_remote_cert_dir }}/{{ certificate_common_name }}.pem"
      certificate_remote_chain_path: "{{ certificate_remote_cert_dir }}/{{ certificate_common_name }}.chain.pem"
      certificate_remote_privatekey_path: "{{ certificate_remote_cert_dir }}/{{ certificate_common_name }}.key"
      # Défini sur false si vous ne voulez pas copier la clé privée vers le lieu distant.
      certificate_copy_private_key_to_remote: true

Pour des exemples de playbook, consultez le fichier venafi-playbook-example.yml. Pour des exemples de rôle, consultez le fichier venafi-role-playbook-example.yml.

Pour plus d'informations sur l'utilisation des rôles, rendez-vous sur https://docs.ansible.com/ansible/latest/user_guide/playbooks_reuse_roles.html

Licence

Copyright © Venafi, Inc. Tous droits réservés.

Cette solution est sous licence Apache, Version 2.0. Voir LICENSE pour le texte intégral de la licence.

Veuillez diriger vos questions/commentaires à opensource@venafi.com.