Créez des pull requests automatisées pour l'infrastructure gérée par Terraform à l'aide AWS d'Actions GitHub - Recommandations AWS
RésuméConditions préalables et limitationsArchitectureOutilsBonnes pratiquesÉpopéesRessources connexes

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Créez des pull requests automatisées pour l'infrastructure gérée par Terraform à l'aide AWS d'Actions GitHub

Matt Padgett, Ashish Bhatt, Ashwin Divakaran, Sandip Gangapadhyay et Prafful Gupta, Amazon Web Services

Résumé

Ce modèle présente un utilitaire d'automatisation conçu pour éliminer le travail manuel et répétitif lié à la gestion des modifications dans plusieurs référentiels Terraform. De nombreuses entreprises utilisent les référentiels Terraform pour gérer leur infrastructure en tant que code (IaC), souvent avec des centaines de référentiels distincts représentant différents environnements, services ou équipes. La gestion de ces référentiels à grande échelle représente un défi opérationnel majeur. Les tâches de routine telles que la mise à jour d'un paramètre, la mise à niveau des versions de modules ou l'application de modifications de configuration nécessitent souvent de créer et de gérer des pull requests (PRs) dans de nombreux référentiels plusieurs fois par jour.

Même pour de simples modifications, ce processus manuel et répétitif prend du temps et est source d'erreurs. Les ingénieurs doivent systématiquement appliquer les mêmes modifications à tous les référentiels ciblés et créer des titres et des descriptions de relations publiques significatifs. En outre, ils doivent souvent interagir avec des outils externes tels que Jira pour récupérer ou inclure des références de suivi des problèmes. Ces tâches, bien que nécessaires, consistent à soulever des objets lourds de manière indifférenciée, consomment un temps précieux en ingénierie et réduisent l'efficacité globale. Le manque d'automatisation de ce flux de travail crée des frictions, ralentit la livraison et augmente la charge cognitive des équipes chargées de la maintenance des infrastructures Terraform à grande échelle.

Présentation de la solution

Pour relever ce défi, ce modèle propose un utilitaire entièrement piloté par la configuration, permettant aux utilisateurs de définir les modifications souhaitées dans un fichier de configuration structuré. Ce fichier spécifie les référentiels, les modules, les paramètres et les valeurs cibles à l'aide d'un schéma clairement défini.

Une fois configuré, l'utilitaire exécute les étapes automatisées suivantes :

  1. Lit la configuration définie par l'utilisateur pour déterminer l'étendue et la nature des modifications

  2. Crée une nouvelle branche dans chaque référentiel cible avec les mises à jour requises appliquées

  3. Génère un PR pour chaque modification, garantissant ainsi la cohérence entre tous les référentiels

  4. Envoie des notifications Slack (facultatif) pour avertir les parties prenantes à l'aide de liens directs vers le PRs

En automatisant ces tâches répétitives, l'utilitaire réduit considérablement le temps, les efforts et les risques associés à la gestion des mises à jour d'infrastructure à grande échelle. Il permet aux équipes de se concentrer sur des travaux d'ingénierie à plus forte valeur ajoutée tout en garantissant que les modifications sont appliquées de manière cohérente et peuvent être suivies dans tous les référentiels.

Conditions préalables et limitations

Conditions préalables

  • Un actif Compte AWS.

  • Python version 3.8 ou ultérieure.

  • Un jeton d'accès GitHub personnel (PAT). Pour plus d'informations, consultez la section Création d'un jeton d'accès personnel (classique) dans la GitHub documentation.

  • Le GitHub PAT peut accéder à vos référentiels cibles afin que l'utilitaire puisse effectuer des opérations telles que la création de branches et les pull requests. Pour plus d'informations, consultez le référentiel de GitHub code de ce modèle.

Limites

  • La complexité de la configuration constitue le principal défi. L'efficacité de l'automatisation est limitée par les capacités de son fichier de configuration. Bien que le système gère efficacement les modifications standard, les modifications complexes de l'infrastructure peuvent nécessiter une intervention manuelle et certains cas extrêmes restent hors du champ d'application de la gestion automatisée.

  • La sécurité et l'accès présentent des considérations importantes, notamment en ce qui concerne la gestion des jetons GitHub d'accès et des limites de débit des API. Organisations doivent trouver un juste équilibre entre le besoin d'automatisation et le stockage et la gestion sécurisés des informations d'identification, en garantissant des contrôles d'accès appropriés tout en préservant l'efficacité opérationnelle.

  • Les contraintes de validation constituent une autre limite notable, car le système automatisé a une capacité limitée à valider la logique métier et les exigences spécifiques à l'environnement. Les dépendances complexes et les interactions entre services nécessitent souvent une supervision humaine, car la validation automatique ne permet pas de saisir pleinement toutes les nuances contextuelles et les règles métier.

  • Des problèmes d'échelle et de performance apparaissent lors de modifications d'infrastructure à grande échelle. Le système doit fonctionner dans les limites de GitHub l'API tout en gérant simultanément de nombreux référentiels. Les opérations gourmandes en ressources sur une infrastructure étendue peuvent créer des goulots d'étranglement en matière de performances nécessitant une gestion minutieuse.

  • Les limites d'intégration limitent la flexibilité du système, car il est principalement conçu pour fonctionner avec des outils spécifiques tels que GitHub Slack. Organisations qui utilisent différents outils peuvent avoir besoin de solutions personnalisées et les options de personnalisation du flux de travail de ce modèle sont limitées aux points d'intégration pris en charge.

Architecture

Le schéma suivant montre le flux de travail et les composants de cette solution.

Flux de travail pour créer des pull requests automatisées à l'aide d' GitHub actions.

Le flux de travail se compose des étapes suivantes :

  1. Le développeur déclenche GitHub des actions en spécifiant le référentiel Terraform.

  2. L'utilitaire d'automatisation lit les configurations définies.

  3. L'utilitaire d'automatisation extrait également le référentiel Terraform fourni.

  4. L'utilitaire d'automatisation crée une nouvelle branche et met à jour les modèles Terraform localement.

  5. L'utilitaire d'automatisation envoie la nouvelle branche vers le référentiel et crée un nouveau PR.

  6. L'utilitaire d'automatisation utilise les notifications Slack qui incluent des liens de relations publiques pour informer les développeurs et active le déploiement des modèles Terraform. AWS Cloud

Outils

  • GitHubest une plateforme de développement que les développeurs peuvent utiliser pour créer, stocker, gérer et partager leur code.

  • GitHub Actions est une plateforme d'intégration et de livraison continues (CI/CD) étroitement intégrée aux GitHub référentiels. Vous pouvez utiliser GitHub les actions pour automatiser votre pipeline de création, de test et de déploiement.

  • HashiCorp Terraform est un outil d'infrastructure en tant que code (IaC) qui vous aide à créer et à gérer des ressources sur site et dans le cloud.

  • Slack, une offre de Salesforce, est une plateforme conversationnelle basée sur l'IA qui permet la collaboration par chat et vidéo, automatise les processus sans code et prend en charge le partage d'informations.

Référentiel de code

Le code de ce modèle est disponible dans le flux de travail GitHub automatisé de mise à jour de l'infrastructure Terraform à l'aide du référentiel GitHub Actions.

Bonnes pratiques

  • Une gestion du changement efficace est essentielle à la réussite de la mise en œuvre. Organisations devraient adopter une stratégie de déploiement progressif pour les changements à grande échelle. Maintenez des conventions de dénomination des branches et des descriptions de relations publiques cohérentes et garantissez une documentation complète de toutes les modifications.

  • Les contrôles de sécurité doivent être rigoureusement mis en œuvre, en se concentrant sur les principes du moindre privilège d'accès et sur une gestion sécurisée des informations d'identification. Activez les règles de protection des succursales pour empêcher les modifications non autorisées. Effectuez des audits de sécurité réguliers pour préserver l'intégrité du système.

  • Un protocole de test robuste doit inclure terraform plan l'exécution automatisée dans les pipelines d'intégration continue et de déploiement continu (CI/CD). Le protocole doit également inclure des contrôles de validation avant la validation et des environnements de révision dédiés aux modifications critiques. Cette approche de test à plusieurs niveaux permet de détecter les problèmes à un stade précoce et de garantir la stabilité de l'infrastructure.

  • La stratégie de surveillance doit inclure des mécanismes d'alerte complets, un suivi détaillé des success/failure métriques et des mécanismes de relance automatisés en cas d'échec des opérations. Cette stratégie contribue à garantir la visibilité opérationnelle et permet de répondre rapidement à tous les problèmes qui se présentent.

  • Les normes de configuration doivent mettre l'accent sur le contrôle des versions pour toutes les configurations, en maintenant la modularité pour la réutilisabilité et l'évolutivité. Une documentation claire du schéma et des exemples aide les équipes à comprendre et à utiliser efficacement le système d'automatisation.

Épopées

Sous-tâcheDescriptionCompétences requises

Configurez le référentiel.

Pour configurer le référentiel, exécutez les commandes suivantes :

# Clone the automation tool repository
git clone https://github.com/aws-samples/sample-terraform-pr-automation-utility
cd sample-terraform-pr-automation-utility

# Copy example configuration
cp config.example.yaml config.yaml
AWS DevOps

Installez les dépendances.

Pour installer et vérifier les dépendances Python, exécutez les commandes suivantes :

# Install Python dependencies
pip3 install -r requirements.txt

# Verify installation
python3 -c "import github; import hcl2; import yaml; import requests; print('All packages installed successfully')"
AWS DevOps

Configurez le GitHub jeton.

Pour configurer le GitHub jeton puis vérifier qu'il fonctionne, exécutez les commandes suivantes :

# Set GitHub token environment variable
export GITHUB_TOKEN="your_github_token_here"

# Verify token works
curl -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/user
AWS DevOps
Sous-tâcheDescriptionCompétences requises

Configurez le config.yaml fichier.

Pour définir vos référentiels cibles et les modifications souhaitées, modifiez le fichier config.yam l comme suit :

repositories:
  - owner: "your-org"
    repo: "your-terraform-repo"
    files:
      - path: "variables.tf"
        changes:
          variables:
            - app_version:
                default:
                  update:
                    - from: ["1.0.0"]
                      to: "1.1.0"

settings:
  pr_title_template: "Infrastructure Update - {{timestamp}}"
  slack:
    username: "Terraform Bot"
    icon_emoji: ":terraform:"
    notify_on_success: true
    notify_on_error: true
    notify_batch_summary: true
AWS DevOps
Sous-tâcheDescriptionCompétences requises

Effectuez des tests avant le vol.

Testez toujours votre configuration avant de l'exécuter sur des référentiels de production. Utilisez les commandes suivantes :

# 1. Test configuration syntax
python3 -c "from main import get_config_content; get_config_content()"

# 2. Run in dry-run mode first
DRY_RUN=true python3 main.py

# 3. Test with minimal configuration
# Use a simple config.yaml with just one repository and one change
AWS DevOps

Vérifiez l'accès au référentiel.

Pour vérifier que le GitHub jeton peut accéder au référentiel, exécutez la commande suivante :

# Test GitHub token access
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/repos/owner/repo-name

# Should return repository information, not 404
AWS DevOps
Sous-tâcheDescriptionCompétences requises

Exécutez l'utilitaire d'automatisation à l'aide de l'interface utilisateur GitHub Actions.

Pour exécuter l'utilitaire d'automatisation à l'aide de l'interface utilisateur GitHub Actions, procédez comme suit :

  1. Accédez à votre référentiel sur GitHub.

  2. Choisissez l'onglet Actions.

  3. Choisissez le flux de travail Terraform Infrastructure Update Automation.

  4. Choisissez Exécuter le flux de travail.

  5. Configurez les entrées de flux de travail suivantes :

    • Configuration de la source :

      • Sélectionnez la branche cible pour l'automatisation.

      • Spécifiez le chemin d'accès au fichier de configuration (config.yaml) contenant les modifications souhaitées.

    • Contrôles de prévisualisation :

      • Choisissez l'option Aperçu pour passer en revue les modifications sans les appliquer.

    • Gestion de la succursale :

      • Entrez la branche de base pour créer de nouvelles branches de fonctionnalités.

      • Entrez la configuration du préfixe de branche.

      • Cochez la case Fermer automatiquement les pull requests obsolètes.

    • Configuration des notifications :

      • Entrez votre URL pour l'URL du webhook Slack pour les notifications enrichies (remplace le secret du dépôt).

      • Cochez la case Tester l'intégration de Slack avant le traitement (essai à sec uniquement).

      • Entrez vos informations pour une chaîne Slack par défaut Override (par exemple, #infrastructure -test).

    • Réglages avancés :

      • Cochez la case Activer la journalisation du débogage à des fins de résolution des problèmes.

AWS DevOps

(Alternative) Exécutez l'utilitaire d'automatisation depuis la ligne de commande.

Si vous préférez, vous pouvez exécuter l'utilitaire d'automatisation à partir de la ligne de commande au lieu d'utiliser l'interface utilisateur GitHub Actions. Utilisez la commande suivante :

# Run actual automation
python3 main.py
AWS DevOps
Sous-tâcheDescriptionCompétences requises

Passez en revue les créations PRs et les modifications.

Pour contrôler les résultats de l'exécution du GitHub flux de travail, procédez comme suit :

  • Consultez les journaux d'exécution du flux de travail pour connaître l'état du traitement.

  • Passez en revue PRs le créé par l'utilitaire d'automatisation.

  • Surveillez les notifications Slack (si elles sont configurées).

AWS DevOps
Sous-tâcheDescriptionCompétences requises

(Facultatif) Nettoyez PRs.

Fermer, abandonné ou inutile PRs.

AWS DevOps

Ressources connexes

AWS Directives prescriptives

GitHub documentation