Les approches héritées de type « Click-Ops » pour gérer les applications SaaS modernes et les services d'entreprise deviennent rapidement obsolètes pour de nombreuses organisations. Les équipes soucieuses de pérenniser et de codifier leurs configurations ont commencé à se tourner vers des approches compatibles avec GitOps pour gérer ces systèmes.
Et pour une bonne raison, d'ailleurs.
Introduction à l'Infrastructure as Code (« IaC ») et à l'Intégration Continue / Déploiement Continu (CI/CD)
Un nombre croissant d'organisations préfère implémenter les modifications via du code ou des fichiers de définition de configuration plutôt que de dépendre d'administrateurs cliquant dans une console, communément appelé ClickOps. Dans une approche CI/CD (ou « GitOps »), un état souhaité est défini, généralement dans un fichier YAML ou un autre format bien structuré, et le fichier est engagé sur une branche Git. Une demande de tirage est soumise pour initier un flux de travail de test, révision et approbation, suivi d'une séquence de fusions vers une branche où une action automatisée implémente la modification dans Jamf Pro via API. Ces techniques peuvent également être utilisées pour déplacer une modification à travers des étapes de test et d'acceptation utilisateur avant que quoi que ce soit ne se produise en production où cela aurait un impact sur toute la flotte.
Définir la configuration sous forme de code permet des flux de travail bien définis d'examen du code, d'approbation et de demande de tirage, de la même manière que le développement logiciel professionnel. Cela signifie que votre environnement devient testable, reproductible et scalable, tout en fournissant un chemin pour revenir à une version précédente si une modification cause des problèmes inattendus.
Vous pouvez itérer rapidement et revenir rapidement sans avoir à parcourir une interface utilisateur aux côtés de la documentation pour comprendre où la défaillance s'est produite.
Notre équipe a parlé de cette approche globale à JNUC 2025 à Denver. Dans cet article, nous avons l'intention d'aller un peu plus loin et, nous l'espérons, de vous donner une piste claire pour commencer à explorer cela par vous-même.
D'abord, pourquoi avons-nous choisi Terraform ?
Terraform est un outil très puissant dans le monde de l'Infrastructure as Code - il est agile et peut être adapté pour communiquer avec n'importe quelle API que vous souhaites. Quand nous avons commencé à explorer cette approche, nous avons contacté Deployment Theory qui avait déjà construit un fournisseur Terraform pour Jamf Pro. Notre équipe a commencé à travailler avec eux pour comprendre son application et a depuis contribué beaucoup à ce projet. De plus, nous avons construit nos propres fournisseurs pour Apple Business et Apple School Manager ainsi qu'un nouveau fournisseur pour l'API de la plateforme Jamf.
Nous avons documenté ces éléments et continuerons à mettre à jour ceci à l'avenir sur notre site développeur ici : https://developer.jamf.com/jamf-pro/docs/jamf-pro-api-developer-resources#terraform-providers
Avant d'aller beaucoup plus loin, veuillez ne pas tester ceci dans une instance de production. Terraform est un outil puissant, nous vous recommandons donc d'utiliser une instance de test. Vous pouvez acquérir une instance bêta de Jamf Pro auprès de Jamf Account à utiliser à cette fin si vous n'avez pas d'instance sandbox ou de test.
Maintenant, commençons à vous faire démarrer avec Terraform pour construire certaines ressources dans Jamf Pro.
Remarque : Pour garder les choses simples, nous utiliserons l'authentification de base, mais vous pouvez passer à l'utilisation d'OAuth à l'avenir.
Installation de Terraform
Nous utiliserons Homebrew pour installer Terraform par souci de simplicité. Si vous n'avez pas Homebrew installé, veuillez suivre les étapes ici.
Ouvrez Terminal et procédez comme suit :
D'abord, nous accéderons au répertoire officiel de HashiCorp.
brew tap hashicorp/tap
Ensuite, nous installerons Terraform.
brew install hashicorp/tap/terraform
Enfin, nous validerons que tout a fonctionné correctement. L'exécution de cette commande devrait vous afficher la version de Terraform que vous avez installée. Si ce n'est pas le cas, réessayez les étapes ci-dessus.
terraform -version
Bien entendu, HashiCorp a documenté ses étapes d'installation à titre de référence ici.
Installation de Visual Studio Code
Vous pouvez vraiment utiliser n'importe quel éditeur de texte ou environnement de développement intégré (IDE) pour écrire Terraform. Cependant, nous avons constaté que Visual Studio Code supporte très bien Terraform avec des extensions pour la coloration syntaxique facilement disponibles. Comme VS Code est également un outil gratuit, c'est pour nous l'idéal pour le recommander à des fins de test.
Vous pouvez télécharger VS Code ici et suivre l'installation sur votre système.
Une fois que vous avez installé VS Code, vous pouvez cliquer sur l'onglet Extensions sur le côté gauche (ou taper Shift + Command + X sur votre clavier) et rechercher « HashiCorp Terraform ». Allez-y et installez cette extension pour obtenir la coloration syntaxique Terraform complète.
Démarrage d'un Projet Terraform
Un fichier de projet Terraform contient de nombreux éléments spécifiques qui sont nécessaires pour démarrer et commencer à construire votre projet. La plupart des fichiers pertinents se termineront par l'extension de fichier .tf ou quelque chose de similaire comme .tfvars.
Il y a de nombreux composants qui composent la fonctionnalité ici, mais nous les couvrirons à une date ultérieure.
Commencer ici peut sembler un peu intimidant - il y a beaucoup à faire pour démarrer. Donc, nous avons voulu rendre cela un peu plus facile.
D'abord, ouvrons Terminal et créons un dossier pour que nous puissions stocker notre projet Terraform. Nous créerons ce dossier au niveau de votre utilisateur pour un accès facile.
mkdir jamf-terraform
Ensuite, nous allons changer de répertoire dans Terminal vers le dossier nouvellement créé
cd ~/jamf-terraform
Maintenant, nous clonerons notre branche de modèle à partir de notre principal référentiel de modules Terraform.
git clone -b template https://github.com/Jamf-Concepts/terraform-jamf-platform
Après cela, vous aurez un projet Terraform de modèle entièrement fonctionnel prêt à l'emploi pour Jamf Pro et Jamf Security Cloud.
Ajout d'un Fichier de Variables
Quelque chose que vous ne voulez pas que se retrouve dans votre référentiel Github - vos identifiants de connexion ou vos secrets client. Heureusement, Terraform a un chemin pour cela.
Ouvrez l'éditeur de texte de votre choix et copiez le texte suivant :
jamfpro_auth_method = "basic" ## oauth2 or basic
jamfpro_instance_url = "https://<tenant-name>.jamfcloud.com"
jamfpro_username = ""
jamfpro_password = ""
jamfpro_client_id = ""
jamfpro_client_secret = ""
## Jamf Protect Account Details
jamfprotect_url = "https://<tenant-name>.protect.jamfcloud.com"
jamfprotect_clientid = ""
jamfprotect_client_password = ""
## (Jamf Pro) General Settings Knobs ##
include_categories = false
Vous nommez ce fichier terraform.tfvars et l'enregistrez au niveau supérieur de votre référentiel de modèle nouvellement cloné.
Maintenant, vous pouvez commencer à remplir les informations de votre fichier terraform.tfvars nouvellement créé. J'ai défini la méthode d'authentification sur basique pour vous simplifier les choses, mais sachez que vous pouvez passer à oauth2 à l'avenir. Donc, pour l'instant, vous entrerez simplement votre nom d'utilisateur et votre mot de passe locaux dans les champs jamfpro_username et jamfpro_password respectivement. Vous pouvez également entrer vos informations Jamf Protect - vous devrez simplement créer un client API dans votre locataire Protect.
Nous avons également inclus un curseur pour le module inclus avec ce référentiel de modèle. C'est effectivement une simple variable booléenne qui nous permet de déclarer si nous appliquerons un module particulier. Vous pouvez choisir d'utiliser ce type d'approche avec les modules supplémentaires que vous construisez à l'avenir ou simplement supprimer toutes les exigences booléennes et simplement laisser tout s'exécuter à chaque fois.
Fichier d'État Terraform
Puisque nous n'avons pas encore engagé de ressources réelles dans notre instance - c'est maintenant le moment parfait pour parler de ce qu'est le fichier d'état dans Terraform.
Chaque fois que vous ajoutez, modifiez ou détruisez des ressources via Terraform, ces mises à jour sont enregistrées dans un fichier appelé terraform.tfstate puis sauvegardées dans un fichier appelé terraform.tfstate.backup.
C'est ainsi que Terraform se souvient de ce qu'il a fait dans votre instance et c'est critique pour la fonctionnalité à long terme. Chaque fois que vous exécutez Terraform contre une instance, ce fichier d'état est consulté avant que quelque chose soit fait. Chaque fichier d'état doit être associé à sa propre instance, il est donc important de les garder séparés pour maintenir la fonctionnalité et éviter de croiser les flux.
Exécution de Terraform
Maintenant, vous êtes en bonne position - vous avez Terraform installé, un référentiel de modèle et vos identifiants définis dans un fichier de variables.
Maintenant, vous êtes prêt à exécuter notre module de modèle contre votre instance Jamf Pro de test ou bêta. Pour ce faire, vous ouvrirez Terminal et exécuterez les commandes suivantes.
terraform init -upgrade
Cela initialisera Terraform et mettra à niveau tous les fournisseurs requis vers les dernières versions pour toute personne qui l'a utilisé auparavant sur ses machines, mais cela fera aussi l'installation initiale des fournisseurs Terraform requis si vous êtes entièrement nouveau sur le sujet.
terraform fmt -recursive
Cela formatera récursivement tout le code Terraform dans votre branche clonée locale pour s'assurer qu'il aura tous l'air correct et fonctionnera correctement.
terraform plan
Cela examinera votre instance Jamf Pro de test, votre fichier d'état Terraform et votre code de module Terraform pour tout changement ou nouvelles choses à appliquer ou supprimer de votre instance et retournera un plan complet ou un aperçu de ce qui se passera quand vous exécutez le module complètement.
terraform apply
Cela exécutera d'abord le plan et rapportera ce qui sera ajouté, modifié ou détruit. Il vous demandera ensuite de confirmer cette action. Le champ n'acceptera que 2 entrées : yes ou no.
terraform apply -parallelism=1
Cela forcera toutes les ressources créées à prendre leur tour et à aller une à une. Puisque de nombreuses applications SaaS ont des systèmes en place pour détecter les attaques potentielles, parfois c'est la meilleure façon d'aborder l'exécution de Terraform.
terraform destroy -parallelism=1
Cela détruira toutes les ressources créées qui sont référencées dans votre fichier d'état dans Terraform.
Chaque exécution ultérieure de n'importe quelle commande plan, apply, or destroy consultera votre fichier d'état, évaluera ce qui doit être ajouté, modifié ou détruit, puis exécutera l'action appropriée.
Exécution de ce Module Particulier
Quand vous exécutez le module de modèle que nous avons inclus, il créera 7 catégories dans votre Jamf Pro nommées pour chaque mission Apollo de 11 à 17 comme test simple.
Une fois ces éléments ajoutés, vous pouvez facilement les détruire en utilisant les commandes ci-dessus.
L'objectif plus large ici est de vous montrer la structure de Terraform afin que vous puissiez commencer à construire les modules pertinents pour votre environnement, ce qui m'amène à la section suivante de cet article.
L'Anatomie de Terraform
Le cœur de la fonctionnalité ici est la hiérarchie des fichiers .tf. La racine main.tf appelle le module enfant main.tf qui référence les fichiers .tfvars et les fichiers variables.tf. Voici une ventilation complète du flux et de l'ordre de communication :
Quand vous exécutez terraform apply :
le fichier d'état est consulté.
La racine main.tf est évaluée pour les modules enfants qui sont demandés.
La racine variables.tf est scannée pour les variables pertinentes pour les modules enfants en cours d'application.
terraform.tfvars est scanné pour toutes les variables pertinentes pour exécuter chaque module enfant.
Les fichiers main.tf du module enfant sont ensuite appelés et exécutés en référençant leurs propres fichiers variables.tf locaux pour les variables pertinentes du module enfant local.
Chaque ressource est ensuite créée et les références sont enregistrées dans terraform.tfstate.
Terraform signalera le succès ou l'échec avec les codes pertinents et les messages de réponse à utiliser pour résoudre les problèmes si nécessaire.
Points à Garder à l'Esprit
Quand vous commencez à construire vos propres modules, vous pouvez copier le module de modèle que nous avons inclus et le modifier selon vos besoins.
Chaque module enfant doit avoir ses propres fichiers main.tf et variables.tf.
Chaque module enfant doit être représenté dans la racine main.tf.
Lisez attentivement le module dans le référentiel de modèle et recherchez chaque point de référence pour que vous compreniez pleinement comment chaque pièce fonctionne ensemble pour atteindre l'objectif.
Vous pouvez utiliser des opérations booléennes (également appelées curseurs) dans votre fichier terraform.tfvars pour appeler des modules enfants ou simplement les laisser toujours être appelés chaque fois que vous exécutez terraform apply.
Vous pouvez également faire dépendre vos appels de module du fait qu'une variable soit remplie ou vous pouvez même mettre en place des déclarations simples d'inclusion ou d'exclusion pour déterminer quand les modules s'exécutent en fonction de vos propres critères.
Terraform est un outil très puissant avec de nombreuses fonctions intégrées que vous pouvez utiliser. Certaines d'entre elles seront nécessaires au fur et à mesure que vous construisez des fonctions spécifiques et certaines vous ne les utiliserez jamais, mais elles sont toutes très bien documentées sur https://developer.hashicorp.com/terraform