Gérez AWS Organizations les politiques sous forme de code en utilisant AWS CodePipeline Amazon Bedrock - Recommandations AWS
RécapitulatifConditions préalables et limitationsArchitectureOutilsBonnes pratiquesÉpopéesRésolution des problèmesRessources connexesInformations supplémentaires

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.

Gérez AWS Organizations les politiques sous forme de code en utilisant AWS CodePipeline Amazon Bedrock

Créée par André Cavalcante (AWS) et Mariana Pessoa de Queiroz (AWS)

Récapitulatif

Vous pouvez utiliser les politiques d'autorisation AWS Organizations pour configurer et gérer de manière centralisée l'accès des principaux et des ressources dans vos comptes de membres. Les politiques de contrôle des services (SCPs) définissent les autorisations maximales disponibles pour les rôles AWS Identity and Access Management (IAM) et les utilisateurs de votre organisation. Les politiques de contrôle des ressources (RCPs) définissent le maximum d'autorisations disponibles pour les ressources de votre organisation.

Ce modèle vous permet de gérer SCPs et d'assimiler l'infrastructure RCPs sous forme de code (IaC) que vous déployez par le biais d'un pipeline d'intégration et de déploiement continus (CI/CD). En utilisant AWS CloudFormation ou Hashicorp Terraform pour gérer ces politiques, vous pouvez réduire la charge associée à la création et à la maintenance de plusieurs politiques d'autorisation.

Ce modèle inclut les fonctionnalités suivantes :

  • Vous créez, supprimez et mettez à jour les politiques d'autorisation à l'aide de fichiers manifestes (scp-management.jsonetrcp-management.json).

  • Vous travaillez avec des barrières de sécurité plutôt que des politiques. Vous définissez vos barrières de sécurité et leurs cibles dans les fichiers manifestes.

  • Le pipeline, qui utilise AWS CodeBuild AWS CodePipeline, fusionne et optimise les garde-fous contenus dans les fichiers manifestes. Pour chaque instruction du fichier manifeste, le pipeline combine les barrières de sécurité en un seul SCP ou RCP, puis l'applique aux cibles définies.

  • AWS Organizations applique les politiques à vos cibles. Une cible peut être une Compte AWS unité organisationnelle (UO), un environnement (qui est un groupe de comptes ou OUs que vous définissez dans le environments.json fichier) ou un groupe de comptes partageant un AWS tag.

  • Amazon Bedrock lit les journaux du pipeline et résume tous les changements de politique.

  • Le pipeline nécessite une approbation manuelle. L'approbateur peut consulter le résumé élaboré par Amazon Bedrock, qui l'aide à comprendre les modifications.

Conditions préalables et limitations

Prérequis

Limites

  • Vous ne pouvez pas utiliser ce modèle pour gérer SCPs ou RCPs qui a été créé en dehors de ce pipeline CI/CD. Toutefois, vous pouvez recréer les politiques existantes par le biais du pipeline. Pour plus d'informations, consultez la section Migration des politiques existantes vers le pipeline dans la section Informations supplémentaires de ce modèle.

  • Le nombre de comptes et OUs les politiques de chaque compte sont soumis aux quotas et aux limites de service pour AWS Organizations.

  • Ce modèle ne peut pas être utilisé pour configurer des politiques de gestion AWS Organizations, telles que des politiques de sauvegarde, des politiques de balises, des politiques d'applications de chat ou des politiques déclaratives.

Architecture

Le schéma suivant montre le flux de travail du pipeline de gestion des politiques et de ses ressources associées.

Publication SCPs et RCPs via un pipeline de gestion des politiques.

Le schéma suivant illustre le flux de travail suivant :

  1. Un utilisateur valide les modifications apportées aux fichiers scp-management.json ou aux fichiers rcp-management.json manifestes dans la branche principale du référentiel distant.

  2. La modification de la main branche initie le pipeline. AWS CodePipeline

  3. CodePipeline lance le Validate-Plan CodeBuild projet. Ce projet utilise un script Python dans le référentiel distant pour valider les politiques et les fichiers manifestes de politiques. Ce CodeBuild projet effectue les opérations suivantes :

    1. Vérifie que les fichiers manifestes SCP et RCP contiennent une instruction unique IDs ()Sid.

    2. Utilise les scripts scp-policy-processor/main.py et rcp-policy-processor/main.py Python pour concaténer les glissières de sécurité du dossier des barres de sécurité en une seule politique RCP ou SCP. Il combine des rambardes qui ont les mêmes ResourceAction, et. Condition

    3. Utilisée AWS Identity and Access Management Access Analyzer pour valider la politique finale optimisée. S'il y a des découvertes, le pipeline s'arrête.

    4. Crée scps.json des rcps.json fichiers, que Terraform utilise pour créer des ressources.

    5. Exécute la terraform plan commande, qui crée un plan d'exécution Terraform.

  4. (Facultatif) Le Validate-Plan CodeBuild projet utilise le bedrock-prompt/prompt.py script pour envoyer une invite à Amazon Bedrock. Vous définissez l'invite dans le bedrock-prompt/prompt.txt fichier. Amazon Bedrock utilise Anthropic Claude Sonnet 3.5 pour générer un résumé des modifications proposées en analysant les logs Terraform et Python.

  5. CodePipeline utilise une rubrique Amazon Simple Notification Service (Amazon SNS) afin d'informer les approbateurs que les modifications doivent être révisées. Si Amazon Bedrock a généré un résumé des modifications, la notification inclut ce résumé.

  6. Un approbateur de politique approuve l'action dans. CodePipeline Si Amazon Bedrock a généré un résumé des modifications, l'approbateur peut consulter le résumé CodePipeline avant de l'approuver.

  7. CodePipeline lance le Apply CodeBuild projet. Ce projet utilise Terraform pour appliquer les modifications du RCP et du SCP dans. AWS Organizations

Le modèle IaC associé à cette architecture déploie également les ressources suivantes qui prennent en charge le pipeline de gestion des politiques :

  • Un compartiment Amazon S3 pour stocker les CodePipeline artefacts et les scripts, tels que scp-policy-processor/main.py et bedrock-prompt/prompt.py

  • Une clé AWS Key Management Service (AWS KMS) qui chiffre les ressources créées par cette solution

Outils

Services AWS

  • Amazon Bedrock est un service d'intelligence artificielle entièrement géré qui met à disposition de nombreux modèles de base très performants via une API unifiée.

  • AWS CodeBuildest un service de génération entièrement géré qui vous aide à compiler le code source, à exécuter des tests unitaires et à produire des artefacts prêts à être déployés. 

  • AWS CodePipelinevous permet de modéliser et de configurer rapidement les différentes étapes d'une version logicielle et d'automatiser les étapes nécessaires à la publication continue des modifications logicielles.

  • AWS Organizationsest un service de gestion de comptes qui vous aide à Comptes AWS en regrouper plusieurs au sein d'une organisation que vous créez et gérez de manière centralisée.

  • AWS SDK pour Python (Boto3)est un kit de développement logiciel qui vous aide à intégrer votre application, bibliothèque ou script Python à Services AWS.

  • Amazon Simple Storage Service (Amazon S3) est un service de stockage d'objets basé sur le cloud qui vous permet de stocker, de protéger et de récupérer n'importe quel volume de données.

Autres outils

  • HashiCorp Terraform est un outil IaC qui vous aide à utiliser du code pour provisionner et gérer l'infrastructure et les ressources du cloud.

Référentiel de code

Le code de ce modèle est disponible dans le organizations-policy-pipeline GitHub référentiel. Les fichiers clés contenus dans le sample-repository dossier sont les suivants :

  • Le environments dossier environments.json contient une liste d'environnements. Les environnements sont un groupe de cibles, et ils peuvent contenir Compte AWS IDs des unités organisationnelles (OUs).

  • Dans le rcp-management dossier :

    • Le guardrails dossier contient les rambardes individuelles pour votre RCPs

    • Le policies dossier contient la personne RCPs

    • Le fichier rcp-management.json manifeste vous permet de gérer les barrières de sécurité RCP complètes et leurs RCPs cibles associées.

  • Dans le scp-management dossier :

    • Le guardrails dossier contient les rambardes individuelles pour votre SCPs

    • Le policies dossier contient la personne SCPs

    • Le fichier scp-management.json manifeste vous permet de gérer les barrières SCP complètes et leurs SCPs cibles associées.

  • Le utils dossier contient des scripts qui peuvent vous aider à migrer vos fichiers actuels SCPs et vous RCPs permettre de les gérer tout au long du pipeline. Pour plus d'informations, consultez la section Informations supplémentaires de ce modèle.

Bonnes pratiques

  • Avant de configurer le pipeline, nous vous recommandons de vérifier que vous n'avez pas atteint les limites de vos AWS Organizations quotas.

  • Nous vous recommandons d'utiliser le compte AWS Organizations de gestion uniquement pour les tâches qui doivent être effectuées dans ce compte. Pour plus d'informations, consultez la section Meilleures pratiques pour le compte de gestion.

Épopées

TâcheDescriptionCompétences requises

Créer un référentiel .

Créez un référentiel à partir duquel votre équipe des opérations de sécurité gérera les politiques. Utilisez l'un des fournisseurs de référentiels tiers pris en AWS CodeConnections charge.

DevOps ingénieur

Déléguer l'administration des politiques.

Déléguez l'administration des AWS Organizations politiques au compte membre sur lequel vous déployez le pipeline. Pour obtenir des instructions, voir Créer une politique de délégation basée sur les ressources avec. AWS Organizations Pour un exemple de politique, voir Exemple de stratégie de délégation basée sur les ressources dans la section Informations supplémentaires de ce modèle.

Administrateur AWS

(Facultatif) Activez le modèle de base.

Si vous souhaitez générer des résumés des modifications apportées aux politiques, autorisez l'accès au modèle de base Anthropic Claude 3.5 Sonnet dans Amazon Bedrock, Compte AWS là où vous déployez le pipeline. Pour obtenir des instructions, consultez Ajouter ou supprimer l'accès aux modèles de fondation Amazon Bedrock.

AWS général
TâcheDescriptionCompétences requises

Pour cloner le référentiel.

Entrez la commande suivante pour cloner le organizations-policy-pipeline référentiel à partir de GitHub :

git clone https://github.com/aws-samples/organizations-policy-pipeline.git

DevOps ingénieur

Définissez votre méthode de déploiement.

  1. Dans le référentiel cloné, ouvrez le variables.tf fichier.

  2. Pourproject_name, entrez le préfixe que vous souhaitez appliquer aux noms des ressources déployées.

  3. Pourprovider_type, entrez le fournisseur du référentiel distant. Des valeurs valides sont fournies dans le fichier.

  4. Pourfull_repository_name, entrez le nom du référentiel distant.

  5. Pourbranch_name, entrez le nom de la branche Git que vous utiliserez pour déployer les politiques. Un push ou une fusion dans cette branche démarre le pipeline. Il s'agit généralement de la branche principale.

  6. Pourterraform_version, entrez la version de Terraform que vous utilisez.

  7. Pourenable_bedrock, entrez true si vous souhaitez qu'Amazon Bedrock récapitule les modifications. Entrez false si vous ne souhaitez pas générer de résumé des modifications.

  8. Pourtags, entrez les paires clé-valeur que vous souhaitez attribuer sous forme de balises aux ressources déployées.

  9. Enregistrez et fermez le fichier variables.tf.

DevOps ingénieur

Déployez le pipeline.

  1. Entrez la commande suivante pour créer un plan et passer en revue les modifications :

    terraform plan

  2. Entrez la commande suivante pour appliquer le plan et créer l'infrastructure du pipeline :

    terraform apply
DevOps ingénieur, Terraform

Connectez le référentiel distant.

À l'étape précédente, Terraform a créé une CodeConnections connexion au référentiel tiers. Dans la console AWS Developer Tools, modifiez le statut de la connexion de PENDING àAVAILABLE. Pour obtenir des instructions, voir Mettre à jour une connexion en attente.

AWS DevOps

Abonnez-vous à la rubrique Amazon SNS.

Terraform a créé une rubrique Amazon SNS. Abonnez un point de terminaison au sujet et confirmez l'abonnement afin que les approbateurs reçoivent des notifications concernant les actions d'approbation en attente dans le pipeline. Pour obtenir des instructions, consultez la section Création d'un abonnement à une rubrique Amazon SNS.

AWS général
TâcheDescriptionCompétences requises

Remplissez le référentiel distant.

Depuis le dépôt cloné, copiez le contenu du sample-repository dossier dans votre dépôt distant. Cela inclut les utils dossiers environments rcp-managementscp-management,, et.

DevOps ingénieur

Définissez vos environnements.

  1. Dans le environments dossier, ouvrez le environments.json fichier. Il s'agit du fichier dans lequel vous définissez la cible Comptes AWS et OUs pour votre RCPs et SCPs.

  2. Supprimez les exemples d'environnements.

  3. Ajoutez vos environnements cibles au format suivant :

    [
    {
        "ID": "<environment-name>",
        "Target": [
            "<ou-name>:<ou-id>",
            "<account-name>:<account-id>"
        ]
    }
]

    Où :

    • <environment-name>est le nom que vous attribuez au groupe OUs de comptes AWS. Vous pouvez utiliser ce nom dans le fichier manifeste pour définir l'endroit où vous souhaitez appliquer vos politiques.

    • <ou-name>est le nom de l'unité d'organisation cible.

    • <ou-id>est l'ID de l'unité d'organisation cible.

    • <account-name>est le nom de la cible Compte AWS.

    • <account-id>est l'ID de la cible Compte AWS.

    Pour des exemples, consultez le référentiel de code source.

  4. Enregistrez et fermez le fichier environments.json.

DevOps ingénieur

Définissez vos rambardes.

  1. Accédez au rcp-management/guardrails dossier de votre référentiel distant. Il s'agit du dossier dans lequel vous définissez les barrières de sécurité pour votre fichier manifeste RCP. Chaque garde-corps doit figurer dans un dossier individuel. Les fichiers Guardrail peuvent contenir une ou plusieurs instructions.

    Note

    Vous pouvez utiliser le même garde-fou dans plusieurs instructions des fichiers manifestes pour SCPs et. RCPs Si vous modifiez le garde-corps, toutes les politiques qui incluent ce garde-corps sont affectées.

  2. Supprimez tous les exemples de garde-corps copiés depuis le référentiel du code source.

  3. Créez un nouveau fichier .json et donnez-lui un nom descriptif.

  4. Ouvrez le fichier .json que vous avez créé.

  5. Définissez le garde-corps au format suivant :

    [
    {
        "Sid": "<guardrail-name>",
        "Effect": "<effect-value>",
        "Action": [
            "<action-name>"
        ],
        "Resource": "<resource-arn>",
        "Condition": {
            "<condition-operator>": {
                "<condition-key>": [
                    "<condition-value>"
                ]
            }
        }
    }
]

    Où :

    • <guardrail-name>est un nom unique pour le garde-corps. Ce nom ne peut être utilisé pour aucun autre garde-corps.

    • <effect-value>doit être Allow ouDeny. Pour plus d'informations, consultez la section Effet.

    • <action-name>doit être le nom valide d'une action prise en charge par le service. Pour plus d'informations, consultez la section Action.

    • <resource-arn>est le nom de ressource Amazon (ARN) de la ressource à laquelle s'applique le garde-corps. Vous pouvez également utiliser des caractères génériques, tels que * ou?. Pour plus d'informations, consultez la section Ressource.

    • <condition-operator>est un opérateur de condition valide. Pour plus d'informations, consultez la section Opérateurs de condition.

    • <condition-key>est une clé de contexte de condition globale valide ou une clé de contexte spécifique à un service. Pour plus d'informations, consultez la section Condition.

    • <condition-value>est la valeur spécifique utilisée dans une condition pour évaluer si un garde-corps s'applique. Pour plus d'informations, consultez la section Condition.

    Par exemple, les garde-corps RCP, consultez le référentiel de code source.

  6. Enregistrez et fermez le fichier .json.

  7. Répétez ces étapes pour créer autant de garde-corps RCP que nécessaire.

  8. Répétez ces étapes dans le scp-management/guardrails dossier pour créer autant de garde-corps que nécessaire pour votre. SCPs Par exemple, les garde-corps SCP, consultez le référentiel du code source.

DevOps ingénieur

Définissez vos politiques.

  1. Accédez au rcp-management/policies dossier de votre référentiel distant. Il s'agit du dossier dans lequel vous définissez les politiques complètes pour votre fichier manifeste RCP. Chaque politique doit être un fichier individuel.

    Note

    Si vous modifiez une politique dans ce dossier, les modifications de stratégie affectent tous les comptes ou tous les comptes OUs auxquels cette politique est appliquée, comme défini dans le fichier manifeste.

  2. Supprimez tous les exemples de politiques copiés depuis le référentiel de code source.

  3. Créez un nouveau fichier .json et donnez-lui un nom descriptif.

  4. Ouvrez le fichier .json que vous avez créé.

  5. Définissez le RCP. Par exemple RCPs, consultez le référentiel de code source ou consultez les exemples de politiques de contrôle des ressources dans la AWS Organizations documentation.

  6. Enregistrez et fermez le fichier .json.

  7. Répétez ces étapes pour en créer RCPs autant que nécessaire.

  8. Répétez ces étapes dans le scp-management/policies dossier pour en créer SCPs autant que nécessaire. Par exemple SCPs, consultez le référentiel de code source ou consultez les exemples de politiques de contrôle des services dans la AWS Organizations documentation.

DevOps ingénieur
TâcheDescriptionCompétences requises

Configurez les fichiers manifestes.

  1. Dans le rcp-management dossier, ouvrez le rcp-management.json fichier. Il s'agit du fichier dans lequel vous définissez les garde-fous RCP qui RCPs s'appliquent pleinement à vos environnements cibles. Pour un exemple de ce fichier, consultez le référentiel de code source.

  2. Supprimez l'exemple de déclaration.

  3. Ajoutez une nouvelle déclaration au format suivant :

    [
    {
        "SID": "<statement-name>",
        "Target": {
            "Type": "<target-type>",
            "ID": "<target-name>"
        },
        "Guardrails": [
            "<guardrail-name>"
        ],
        "Policy": "<policy-name>",
        "Comments": "<comment-text>"
    }
]

    Où :

    • <statement-name>est un nom unique pour la déclaration.

    • <target-type>est le type de cible auquel vous souhaitez appliquer la politique. Les valeurs valides sont Account, OU, Environment ou Tag.

    • <target-name>est l'identifiant de la cible à laquelle vous souhaitez appliquer la politique. Indiquez l'un des éléments suivants :

      • Pour un Compte AWS, entrez l'identifiant sous la forme<account-name>:<account-id>.

      • Pour une unité d'organisation, entrez l'identifiant sous la forme<OU-name>:<ou-id>.

      • Pour un environnement, entrez le nom unique que vous avez défini dans le environments.json fichier.

      • Pour une balise, entrez la paire clé-valeur sous la forme. <tag-key>:<tag-value>

    • <guardrail-name>est le nom unique du garde-corps RCP que vous avez défini dans le dossier. rcp-management/guardrails Vous pouvez ajouter plusieurs rambardes dans cet élément. Vous pouvez laisser ce champ vide si vous ne souhaitez pas installer de garde-corps.

    • <policy-name>est le nom unique du RCP que vous avez défini dans le rcp-management/policies dossier. Vous ne pouvez ajouter qu'une seule politique dans cet élément. Vous pouvez laisser ce champ vide si vous ne souhaitez pas appliquer de politique.

    • <comment-text>est une description que vous pouvez saisir à des fins de documentation. Ce champ n'est pas utilisé pendant le traitement du pipeline. Vous pouvez laisser ce champ vide si vous ne souhaitez pas ajouter de commentaire.

  4. Répétez ces étapes pour ajouter autant d'instructions que nécessaire à configurer RCPs pour votre organisation.

  5. Enregistrez et fermez le fichier rcp-management.json.

  6. Dans le scp-management dossier, répétez ces étapes dans le scp-management.json fichier. Il s'agit du fichier dans lequel vous définissez les garde-corps SCP qui SCPs s'appliquent pleinement à vos environnements cibles. Pour un exemple de ce fichier, consultez le référentiel de code source.

DevOps ingénieur

Démarrez le pipeline.

Validez et envoyez les modifications à la branche du référentiel distant que vous avez définie dans le variables.tf fichier. Il s'agit généralement de la main branche. Le pipeline CI/CD démarre automatiquement. En cas d'erreur de pipeline, consultez la section Dépannage de ce modèle.

DevOps ingénieur

Approuvez les modifications.

Lorsque le Validate-Plan CodeBuild projet est terminé, les approbateurs des politiques reçoivent une notification via la rubrique Amazon SNS que vous avez précédemment configurée. Procédez comme suit :

  1. Ouvrez le message de notification.

  2. Le cas échéant, consultez le résumé des modifications apportées aux politiques.

  3. Suivez les instructions de la section Approuver ou rejeter une action d'approbation dans CodePipeline.

AWS général, approbateur de politiques

Validez le déploiement.

  1. Connectez-vous à la AWS Organizations console avec le compte dont vous êtes l'administrateur délégué AWS Organizations.

  2. Sur la page Politiques de contrôle des services, vérifiez que les politiques SCPs que vous avez créées sont répertoriées.

  3. Choisissez un SCP géré via le pipeline et confirmez qu'il s'applique aux cibles prévues.

  4. Sur la page Politiques de contrôle des ressources, vérifiez que celles RCPs que vous avez créées sont répertoriées.

  5. Choisissez un RCP géré via le pipeline et vérifiez qu'il s'applique aux cibles prévues.

AWS général

Résolution des problèmes

ProblèmeSolution

Erreurs de fichiers manifestes dans la Validate-Plan phase du pipeline

Un message « Erreurs de pipeline lors de la phase de validation et de planification pour les fichiers manifestes » apparaît dans la sortie du pipeline en cas d'erreur dans les rcp-management.json fichiers scp-management.json ou. Les erreurs possibles incluent un nom d'environnement incorrect, des champs ou des valeurs dupliqués SIDs ou non valides. Procédez comme suit :

  1. Suivez les instructions de la section Afficher les détails de la version dans AWS CodeBuild.

  2. Dans le journal de construction, recherchez l'erreur de validation. L'erreur fournit plus d'informations sur la cause de l'échec de la compilation.

  3. Mettez à jour le fichier .json correspondant.

  4. Validez et transférez le fichier mis à jour vers le référentiel distant. Le pipeline redémarre.

  5. Surveillez l'état pour confirmer que l'erreur de validation est résolue.

Conclusions d'IAM Access Analyzer au Validate-Plan cours de la phase du pipeline

Un message « Résultats trouvés dans IAM Access Analyzer pendant la phase de validation et de planification » apparaît dans la sortie du pipeline en cas d'erreur dans le garde-fou ou dans les définitions des politiques. Ce modèle utilise IAM Access Analyzer pour valider la politique finale. Procédez comme suit :

  1. Suivez les instructions de la section Afficher les détails de la version dans AWS CodeBuild.

  2. Dans le journal de compilation, recherchez l'erreur de validation d'IAM Access Analyzer. L'erreur fournit plus d'informations sur la cause de l'échec de la compilation. Pour plus d'informations sur les types de recherche, consultez la référence de vérification de validation des politiques IAM.

  3. Mettez à jour le fichier .json correspondant au garde-corps ou à la politique.

  4. Validez et transférez le fichier mis à jour vers le référentiel distant. Le pipeline redémarre.

  5. Surveillez l'état pour confirmer que l'erreur de validation est résolue.

Ressources connexes

Informations supplémentaires

Exemple de politique de délégation basée sur les ressources

Voici un exemple de politique de délégation basée sur les ressources pour. AWS Organizations Il permet au compte d'administrateur délégué de gérer SCPs et RCPs pour l'organisation. Dans l'exemple de politique suivant, remplacez-le <MEMBER_ACCOUNT_ID> par l'ID du compte sur lequel vous déployez le pipeline de gestion des politiques.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DelegationToAudit",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::<MEMBER_ACCOUNT_ID>:root"
      },
      "Action": [
        "organizations:ListTargetsForPolicy",
        "organizations:CreatePolicy",
        "organizations:DeletePolicy",
        "organizations:AttachPolicy",
        "organizations:DetachPolicy",
        "organizations:DisablePolicyType",
        "organizations:EnablePolicyType",
        "organizations:UpdatePolicy",
        "organizations:DescribeEffectivePolicy",
        "organizations:DescribePolicy",
        "organizations:DescribeResourcePolicy"
      ],
      "Resource": "*"
    }
  ]
}

Migration des politiques existantes vers le pipeline

Si vous en avez SCPs un existant ou RCPs que vous souhaitez migrer et gérer via ce pipeline, vous pouvez utiliser les scripts Python dans le sample-repository/utils dossier du référentiel de code. Ces scripts incluent :

  • check-if-scp-exists-in-env.py— Ce script vérifie si une politique spécifiée s'applique à des cibles dans un environnement spécifique, que vous définissez dans le environments.json fichier. Entrez la commande suivante pour exécuter ce script :

    python3 check-if-scp-exists-in-env.py \
   --policy-type <POLICY_TYPE> \
   --policy-name <POLICY_NAME> \
   --env-id <ENV_ID>

    Remplacez le texte suivant dans cette commande :

    • <POLICY_TYPE> est scp ou rcp

    • <POLICY_NAME>est le nom du SCP ou du RCP

    • <ENV_ID>est l'ID de l'environnement que vous avez défini dans le environments.json fichier

  • create-environments.py— Ce script crée un fichier environments.json en fonction de l'environnement actuel SCPs et RCPs de votre environnement. Cela exclut les politiques déployées via AWS Control Tower. Entrez la commande suivante pour exécuter ce script, où se <POLICY_TYPE> trouve scp ou rcp :

    python create-environments.py --policy-type <POLICY_TYPE>

  • verify-policies-capacity.py— Ce script vérifie chaque environnement que vous définissez afin de déterminer la capacité restante pour chaque quota AWS Organizations lié aux politiques. Vous définissez les environnements à archiver dans le environments.json fichier. Entrez la commande suivante pour exécuter ce script, où se <POLICY_TYPE> trouve scp ou rcp :

    python verify-policies-capacity.py --policy-type <POLICY_TYPE>