Gestisci AWS Organizations le policy come codice utilizzando AWS CodePipeline Amazon Bedrock - Prontuario AWS
RiepilogoPrerequisiti e limitazioniArchitetturaStrumentiBest practiceEpicheRisoluzione dei problemiRisorse correlateInformazioni aggiuntive

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Gestisci AWS Organizations le policy come codice utilizzando AWS CodePipeline Amazon Bedrock

Creato da Andre Cavalcante (AWS) e Mariana Pessoa de Queiroz (AWS)

Riepilogo

Puoi utilizzare le politiche di autorizzazione per configurare e gestire centralmente AWS Organizations l'accesso ai principali e alle risorse nei tuoi account membro. Le politiche di controllo dei servizi (SCPs) definiscono le autorizzazioni massime disponibili per i ruoli e gli utenti AWS Identity and Access Management (IAM) dell'organizzazione. Le politiche di controllo delle risorse (RCPs) definiscono le autorizzazioni massime disponibili per le risorse dell'organizzazione.

Questo modello consente di gestire SCPs e utilizzare l'infrastruttura RCPs come codice (IaC) da implementare attraverso una pipeline di integrazione e distribuzione continue (CI/CD). Utilizzando AWS CloudFormation o Hashicorp Terraform per gestire queste politiche, è possibile ridurre l'onere associato alla creazione e al mantenimento di più politiche di autorizzazione.

Questo modello include le seguenti funzionalità:

  • È possibile creare, eliminare e aggiornare le politiche di autorizzazione utilizzando i file manifest (scp-management.jsonandrcp-management.json).

  • Si lavora con i guardrail anziché con le politiche. Definisci i tuoi guardrail e i loro obiettivi nei file manifest.

  • La pipeline, che utilizza AWS CodeBuild e AWS CodePipeline, unisce e ottimizza i guardrail nei file manifest. Per ogni istruzione nel file manifest, la pipeline combina i guardrail in un unico SCP o RCP e quindi lo applica ai target definiti.

  • AWS Organizations applica le politiche ai tuoi obiettivi. Un obiettivo può essere un' Account AWS unità organizzativa (OU), un ambiente (che è un gruppo di account o OUs definito nel environments.json file) o un gruppo di account che condividono un AWS tag.

  • Amazon Bedrock legge i log della pipeline e riepiloga tutte le modifiche alle policy.

  • La pipeline richiede un'approvazione manuale. L'approvatore può consultare il riepilogo esecutivo preparato da Amazon Bedrock, che lo aiuta a comprendere le modifiche.

Prerequisiti e limitazioni

Prerequisiti

Limitazioni

  • Non è possibile utilizzare questo pattern per gestire SCPs o RCPs che sono stati creati al di fuori di questa pipeline CI/CD. Tuttavia, è possibile ricreare le politiche esistenti tramite la pipeline. Per ulteriori informazioni, consulta Migrazione delle politiche esistenti nella pipeline nella sezione Informazioni aggiuntive di questo modello.

  • Il numero di account e OUs le politiche di ciascun account sono soggetti alle quote e ai limiti di servizio per. AWS Organizations

  • Questo modello non può essere utilizzato per configurare le politiche di gestione in AWS Organizations, ad esempio, le politiche di backup, le politiche dei tag, le politiche delle applicazioni di chat o le politiche dichiarative.

Architettura

Il diagramma seguente mostra il flusso di lavoro della pipeline di gestione delle policy e le risorse associate.

Rilascio SCPs e RCPs tramite una pipeline di gestione delle politiche.

Il diagramma mostra il flusso di lavoro seguente:

  1. Un utente esegue il commit delle modifiche ai file scp-management.json o rcp-management.json manifest nel ramo principale del repository remoto.

  2. La modifica al main ramo avvia la pipeline. AWS CodePipeline

  3. CodePipeline avvia il progetto. Validate-Plan CodeBuild Questo progetto utilizza uno script Python nel repository remoto per convalidare le politiche e i file manifest delle politiche. Questo CodeBuild progetto fa quanto segue:

    1. Verifica che i file manifest SCP e RCP contengano un'istruzione univoca IDs ()Sid.

    2. Utilizza gli script scp-policy-processor/main.py e rcp-policy-processor/main.py Python per concatenare i guardrail nella cartella guardrails in un'unica politica RCP o SCP. Combina guardrail che hanno lo stesso valore, e. Resource Action Condition

    3. Viene utilizzato AWS Identity and Access Management Access Analyzer per convalidare la politica finale ottimizzata. Se ci sono dei risultati, la pipeline si arresta.

    4. Crea scps.json e rcps.json archivia, che Terraform utilizza per creare risorse.

    5. Esegue il terraform plan comando, che crea un piano di esecuzione Terraform.

  4. (Facoltativo) Il Validate-Plan CodeBuild progetto utilizza lo bedrock-prompt/prompt.py script per inviare un prompt ad Amazon Bedrock. Il prompt viene definito nel file. bedrock-prompt/prompt.txt Amazon Bedrock utilizza Anthropic Claude Sonnet 3.5 per generare un riepilogo delle modifiche proposte analizzando i log Terraform e Python.

  5. CodePipeline utilizza un argomento Amazon Simple Notification Service (Amazon SNS) per notificare agli approvatori che le modifiche devono essere riviste. Se Amazon Bedrock ha generato un riepilogo delle modifiche, la notifica include questo riepilogo.

  6. Un approvatore della politica approva l'azione in. CodePipeline Se Amazon Bedrock ha generato un riepilogo delle modifiche, l'approvatore può esaminarlo CodePipeline prima dell'approvazione.

  7. CodePipeline avvia il progetto. Apply CodeBuild Questo progetto utilizza Terraform per applicare le modifiche RCP e SCP in. AWS Organizations

Il modello IaC associato a questa architettura implementa anche le seguenti risorse che supportano la pipeline di gestione delle politiche:

  • Un bucket Amazon S3 per l'archiviazione di CodePipeline artefatti e script, come e scp-policy-processor/main.py bedrock-prompt/prompt.py

  • Una chiave AWS Key Management Service (AWS KMS) che crittografa le risorse create da questa soluzione

Strumenti

Servizi AWS

  • Amazon Bedrock è un servizio di intelligenza artificiale completamente gestito che rende disponibili molti modelli di base ad alte prestazioni da utilizzare tramite un'API unificata.

  • AWS CodeBuildè un servizio di compilazione completamente gestito che ti aiuta a compilare codice sorgente, eseguire test unitari e produrre artefatti pronti per la distribuzione. 

  • AWS CodePipelineti aiuta a modellare e configurare rapidamente le diverse fasi di una versione del software e ad automatizzare i passaggi necessari per rilasciare continuamente le modifiche al software.

  • AWS Organizationsè un servizio di gestione degli account che consente di consolidare più account Account AWS in un'organizzazione creata e gestita centralmente.

  • AWS SDK per Python (Boto3)è un kit di sviluppo software che ti aiuta a integrare la tua applicazione, libreria o script Python con. Servizi AWS

  • Amazon Simple Storage Service (Amazon S3) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.

Altri strumenti

  • HashiCorp Terraform è uno strumento IaC che ti aiuta a utilizzare il codice per fornire e gestire l'infrastruttura e le risorse cloud.

Deposito di codici

Il codice per questo pattern è disponibile nel organizations-policy-pipeline GitHub repository. Di seguito sono riportati i file chiave contenuti nella sample-repository cartella:

  • Nella environments cartella, environments.json contiene un elenco di ambienti. Gli ambienti sono un gruppo di obiettivi e possono contenere Account AWS IDs o unità organizzative (OUs).

  • Nella rcp-management cartella:

    • La guardrails cartella contiene i parapetti individuali per il tuo RCPs

    • La policies cartella contiene l'individuo RCPs

    • Il file rcp-management.json manifest consente di gestire i guardrail RCP RCPs, full e gli obiettivi associati.

  • Nella cartella: scp-management

    • La guardrails cartella contiene i parapetti individuali per il tuo SCPs

    • La policies cartella contiene l'individuo SCPs

    • Il file scp-management.json manifest consente di gestire i guardrail SCP SCPs, completi e gli obiettivi associati.

  • La utils cartella contiene script che possono aiutarvi a migrare quelli attuali SCPs e RCPs a gestirli attraverso la pipeline. Per ulteriori informazioni, vedere la sezione Informazioni aggiuntive di questo modello.

Best practice

  • Prima di configurare la pipeline, ti consigliamo di verificare di non aver raggiunto i limiti delle tue AWS Organizations quote.

  • Ti consigliamo di utilizzare l'account di AWS Organizations gestione solo per le attività che devono essere eseguite in quell'account. Per ulteriori informazioni, consulta Best practice per l'account di gestione.

Epiche

AttivitàDescrizioneCompetenze richieste

Creare un repository .

Crea un repository da cui il tuo team addetto alle operazioni di sicurezza gestirà le politiche. Utilizza uno dei fornitori di repository di terze parti che AWS CodeConnections supportano.

DevOps ingegnere

Delegare l'amministrazione delle politiche.

Delega l'amministrazione delle AWS Organizations politiche all'account membro in cui stai distribuendo la pipeline. Per istruzioni, consulta Creare una politica di delega basata sulle risorse con. AWS Organizations Per una politica di esempio, vedi Esempio di politica di delega basata sulle risorse nella sezione Informazioni aggiuntive di questo modello.

Amministratore AWS

(Facoltativo) Abilita il modello di base.

Se desideri generare riepiloghi delle modifiche alle policy, abilita l'accesso al modello di base Anthropic Claude 3.5 Sonnet in Amazon Bedrock nel luogo in Account AWS cui stai distribuendo la pipeline. Per istruzioni, consulta Aggiungere o rimuovere l'accesso ai modelli Amazon Bedrock Foundation.

Informazioni generali su AWS
AttivitàDescrizioneCompetenze richieste

Clonare il repository.

Inserisci il seguente comando da cui clonare il organizations-policy-pipeline repository: GitHub

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

DevOps ingegnere

Definisci il tuo metodo di implementazione.

  1. Nel repository clonato, apri il file. variables.tf

  2. Perproject_name, inserisci il prefisso che desideri applicare ai nomi delle risorse distribuite.

  3. Perprovider_type, inserisci il provider dell'archivio remoto. Nel file vengono forniti valori validi.

  4. Perfull_repository_name, inserisci il nome del repository remoto.

  5. Perbranch_name, inserisci il nome del ramo Git che utilizzerai per distribuire le policy. Un push o un'unione in questo ramo avvia la pipeline. In genere, questo è il ramo principale.

  6. Perterraform_version, inserisci la versione di Terraform che stai utilizzando.

  7. Perenable_bedrock, inserisci true se desideri che Amazon Bedrock riassuma le modifiche. Inserisci false se non desideri generare un riepilogo delle modifiche.

  8. Pertags, inserisci le coppie chiave-valore che desideri assegnare come tag alle risorse distribuite.

  9. Salvare e chiudere il file variables.tf.

DevOps ingegnere

Implementa la pipeline.

  1. Immettete il seguente comando per creare un piano e rivedere le modifiche:

    terraform plan

  2. Immettete il seguente comando per applicare il piano e creare l'infrastruttura della pipeline:

    terraform apply
DevOps ingegnere, Terraform

Connect il repository remoto.

Nel passaggio precedente, Terraform ha creato una CodeConnections connessione al repository di terze parti. Nella console AWS Developer Tools, modifica lo stato della connessione da aPENDING. AVAILABLE Per istruzioni, consulta Aggiornare una connessione in sospeso.

AWS DevOps

Iscriviti all'argomento Amazon SNS.

Terraform ha creato un argomento Amazon SNS. Sottoscrivi un endpoint all'argomento e conferma l'iscrizione in modo che gli approvatori ricevano notifiche sulle azioni di approvazione in sospeso nella pipeline. Per istruzioni, consulta l'argomento Creazione di un abbonamento a un Amazon SNS.

Informazioni generali su AWS
AttivitàDescrizioneCompetenze richieste

Popola il repository remoto.

Dal repository clonato, copia il contenuto della sample-repository cartella nel tuo repository remoto. Sono incluse le cartelleenvironments,rcp-management, scp-management e. utils

DevOps ingegnere

Definisci i tuoi ambienti.

  1. Nella environments cartella, apri il environments.json file. Questo è il file in cui definisci l'obiettivo Account AWS e OUs per la tua RCPs mano SCPs.

  2. Eliminate gli ambienti di esempio.

  3. Aggiungi i tuoi ambienti di destinazione nel seguente formato:

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

    Dove:

    • <environment-name>è il nome che assegni al gruppo OUs e agli account AWS. Puoi usare questo nome nel file manifest per definire dove vuoi applicare le tue policy.

    • <ou-name>è il nome dell'unità organizzativa di destinazione.

    • <ou-id>è l'ID dell'unità organizzativa di destinazione.

    • <account-name>è il nome della destinazione Account AWS.

    • <account-id>è l'ID della destinazione Account AWS.

    Per esempi, consulta il repository del codice sorgente.

  4. Salvare e chiudere il file environments.json.

DevOps ingegnere

Definisci i tuoi guardrail.

  1. Vai alla rcp-management/guardrails cartella nel tuo repository remoto. Questa è la cartella in cui definisci i guardrail per il tuo file manifest RCP. Ogni guardrail deve essere contenuto in un singolo file. I file Guardrail possono contenere una o più istruzioni.

    Nota

    È possibile utilizzare lo stesso guardrail in più istruzioni nei file manifest per SCPs e. RCPs Se si modifica il guardrail, tutte le politiche che includono questo guardrail vengono influenzate.

  2. Eliminate tutti i guardrail di esempio che sono stati copiati dal repository del codice sorgente.

  3. Crea un nuovo file.json e assegnagli un nome descrittivo.

  4. Apri il file.json che hai creato.

  5. Definite il guardrail nel seguente formato:

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

    Dove:

    • <guardrail-name>è un nome univoco per il guardrail. Questo nome non può essere utilizzato per nessun altro guardrail.

    • <effect-value>deve essere o. Allow Deny Per ulteriori informazioni, consulta Effect.

    • <action-name>deve essere un nome valido di un'azione supportata dal servizio. Per ulteriori informazioni, vedere Azione.

    • <resource-arn>è l'Amazon Resource Name (ARN) della risorsa a cui si applica il guardrail. Puoi anche usare caratteri jolly, come o. * ? Per ulteriori informazioni, consulta Resource.

    • <condition-operator>è un operatore di condizione valido. Per ulteriori informazioni, vedere Operatori di condizione.

    • <condition-key>è una chiave di contesto globale valida o una chiave di contesto specifica del servizio. Per ulteriori informazioni, vedere Condizione.

    • <condition-value>è il valore specifico utilizzato in una condizione per valutare se è applicabile un guardrail. Per ulteriori informazioni, vedere Condizione.

    Ad esempio, guardrails RCP, consultate il repository del codice sorgente.

  6. Salva e chiudi il file.json.

  7. Ripeti questi passaggi per creare tutti i guardrail RCP necessari.

  8. Ripeti questi passaggi nella scp-management/guardrails cartella per creare tutti i guardrail necessari per il tuo. SCPs Ad esempio, guardrail SCP, consultate il repository del codice sorgente.

DevOps ingegnere

Definisci le tue politiche.

  1. Passa alla rcp-management/policies cartella nel tuo repository remoto. Questa è la cartella in cui definisci le politiche complete per il tuo file manifest RCP. Ogni policy deve essere un singolo file.

    Nota

    Se si modifica una politica in questa cartella, le modifiche alla politica influiscono su tutti gli account o a OUs cui viene applicata questa politica, come definito nel file manifesto.

  2. Eliminare tutte le policy di esempio che sono state copiate dal repository del codice sorgente.

  3. Crea un nuovo file.json e assegnagli un nome descrittivo.

  4. Apri il file.json che hai creato.

  5. Definisci l'RCP. Ad esempio RCPs, consulta il repository del codice sorgente o vedi Esempi di politiche di controllo delle risorse nella AWS Organizations documentazione.

  6. Salva e chiudi il file.json.

  7. Ripeti questi passaggi per crearne tutti RCPs quelli necessari.

  8. Ripeti questi passaggi nella scp-management/policies cartella per crearne SCPs il numero necessario. Ad esempio SCPs, consulta il repository del codice sorgente o vedi gli esempi di policy di controllo dei servizi nella AWS Organizations documentazione.

DevOps ingegnere
AttivitàDescrizioneCompetenze richieste

Configura i file manifest.

  1. Nella rcp-management cartella, apri il rcp-management.json file. Questo è il file in cui definisci quali guardrail RCP RCPs si applicano completamente agli ambienti di destinazione. Per un esempio di questo file, consultate il repository del codice sorgente.

  2. Eliminate l'istruzione di esempio.

  3. Aggiungere una nuova istruzione nel formato seguente:

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

    Dove:

    • <statement-name>è un nome univoco per l'istruzione.

    • <target-type>è il tipo di destinazione a cui si desidera applicare la politica. I valori validi sono Account, OU, Environment o Tag.

    • <target-name>è l'identificatore dell'obiettivo a cui si desidera applicare la politica. Immettere uno dei seguenti elementi:

      • Per un Account AWS, inserisci l'identificatore come. <account-name>:<account-id>

      • Per un'unità organizzativa, immettere l'identificatore come. <OU-name>:<ou-id>

      • Per un ambiente, immettete il nome univoco definito nel environments.json file.

      • Per un tag, inserisci la coppia chiave-valore come. <tag-key>:<tag-value>

    • <guardrail-name>è il nome univoco del guardrail RCP definito nella cartella. rcp-management/guardrails È possibile aggiungere più guardrail in questo elemento. Puoi lasciare questo campo vuoto se non vuoi applicare un guardrail.

    • <policy-name>è il nome univoco dell'RCP definito nella rcp-management/policies cartella. È possibile aggiungere solo una politica in questo elemento. È possibile lasciare vuoto questo campo se non si desidera applicare una politica.

    • <comment-text>è una descrizione che è possibile inserire a scopo di documentazione. Questo campo non viene utilizzato durante l'elaborazione della pipeline. È possibile lasciare vuoto questo campo se non si desidera aggiungere un commento.

  4. Ripeti questi passaggi per aggiungere tutte le istruzioni necessarie per la configurazione RCPs per la tua organizzazione.

  5. Salvare e chiudere il file rcp-management.json.

  6. Nella scp-management cartella, ripeti questi passaggi nel scp-management.json file. Questo è il file in cui definisci quali guardrail SCP SCPs si applicano completamente ai tuoi ambienti di destinazione. Per un esempio di questo file, consultate il repository del codice sorgente.

DevOps ingegnere

Avvia la pipeline.

Conferma e invia le modifiche al ramo del repository remoto che hai definito nel variables.tf file. In genere, questo è il main ramo. La pipeline CI/CD si avvia automaticamente. Se sono presenti errori nella pipeline, consultate la sezione Risoluzione dei problemi di questo schema.

DevOps ingegnere

Approva le modifiche.

Una volta completato il Validate-Plan CodeBuild progetto, gli approvatori delle politiche ricevono una notifica tramite l'argomento Amazon SNS che hai configurato in precedenza. Esegui questa operazione:

  1. Apri il messaggio di notifica.

  2. Se disponibile, consulta il riepilogo delle modifiche alle politiche.

  3. Segui le istruzioni riportate in Approvare o rifiutare un'azione di approvazione in. CodePipeline

AWS generale, responsabile dell'approvazione delle politiche

Convalida la distribuzione.

  1. Accedi alla AWS Organizations console con l'account di cui sei l'amministratore delegato. AWS Organizations

  2. Nella pagina Criteri di controllo del servizio, verifica che siano elencati quelli SCPs che hai creato.

  3. Scegliete un SCP gestito tramite la pipeline e confermate che si applichi agli obiettivi previsti.

  4. Nella pagina delle politiche di controllo delle risorse, verifica che quelle RCPs che hai creato siano elencate.

  5. Scegliete un RCP gestito tramite la pipeline e confermate che si applichi agli obiettivi previsti.

Informazioni generali su AWS

Risoluzione dei problemi

ProblemaSoluzione

Errori manifesti nei file nella Validate-Plan fase della pipeline

Se sono presenti errori nei file or, nell'output della pipeline viene visualizzato un messaggio «Errori della pipeline nella fase di convalida e pianificazione per i file manifest». scp-management.json rcp-management.json I possibili errori includono un nome di ambiente errato, campi o valori duplicati SIDs o non validi. Esegui questa operazione:

  1. Segui le istruzioni in Visualizza i dettagli della build in. AWS CodeBuild

  2. Nel registro di compilazione, trova l'errore di convalida. L'errore fornisce ulteriori informazioni su ciò che ha causato il fallimento della compilazione.

  3. Aggiorna il file .json corrispondente.

  4. Effettua il commit e invia il file aggiornato al repository remoto. La pipeline si riavvia.

  5. Monitora lo stato per confermare che l'errore di convalida è stato risolto.

I risultati di IAM Access Analyzer nella Validate-Plan fase della pipeline

Un messaggio «Risultati di IAM Access Analyzer durante la fase di convalida e pianificazione» viene visualizzato nell'output della pipeline in caso di errori nel guardrail o nelle definizioni delle policy. Questo modello utilizza IAM Access Analyzer per convalidare la policy finale. Esegui questa operazione:

  1. Segui le istruzioni in Visualizza i dettagli della build in. AWS CodeBuild

  2. Nel log di compilazione, trova l'errore di convalida di IAM Access Analyzer. L'errore fornisce ulteriori informazioni sulla causa del fallimento della compilazione. Per ulteriori informazioni sui tipi di risultati, consulta IAM Policy Validation Check Reference.

  3. Aggiorna il file.json corrispondente per il guardrail o la policy.

  4. Effettua il commit e invia il file aggiornato al repository remoto. La pipeline si riavvia.

  5. Monitora lo stato per confermare che l'errore di convalida è stato risolto.

Risorse correlate

Informazioni aggiuntive

Esempio di politica di delega basata sulle risorse

Di seguito è riportato un esempio di politica di delega basata sulle risorse per. AWS Organizations Consente all'account di amministrazione delegato di gestire SCPs e per l'organizzazione. RCPs Nel seguente esempio di policy, sostituiscilo <MEMBER_ACCOUNT_ID> con l'ID dell'account su cui stai distribuendo la pipeline di gestione delle policy.

{
  "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": "*"
    }
  ]
}

Migrazione delle politiche esistenti nella pipeline

Se ne hai esistenti SCPs o RCPs desideri migrare e gestire tramite questa pipeline, puoi usare gli script Python sample-repository/utils nella cartella del repository del codice. Questi script includono:

  • check-if-scp-exists-in-env.py— Questo script verifica se una politica specificata si applica a qualsiasi destinazione in un ambiente specifico, definito nel environments.json file. Immettete il seguente comando per eseguire questo script:

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

    Sostituisci quanto segue in questo comando:

    • <POLICY_TYPE> è scp o rcp

    • <POLICY_NAME>è il nome dell'SCP o dell'RCP

    • <ENV_ID>è l'ID dell'ambiente definito nel file environments.json

  • create-environments.py— Questo script crea un file environments.json basato sull'ambiente corrente SCPs e RCPs su quello esistente. Sono escluse le politiche implementate tramite. AWS Control Tower Immettere il seguente comando per eseguire questo script, dove <POLICY_TYPE> è scp o: rcp

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

  • verify-policies-capacity.py— Questo script controlla ogni ambiente definito per determinare la quantità di capacità residua per ogni quota AWS Organizations relativa alle politiche. L'utente definisce gli ambienti in cui archiviare il file inenvironments.json. Immettete il seguente comando per eseguire questo script, dove <POLICY_TYPE> è scp orcp:

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