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à.
# Usa gli script per migrare in blocco le tue policy per utilizzare azioni IAM granulari
**Nota**
Le seguenti azioni AWS Identity and Access Management (IAM) hanno raggiunto la fine del supporto standard a luglio 2023:
Spazio dei nomi `aws-portal`
`purchase-orders:ViewPurchaseOrders`
`purchase-orders:ModifyPurchaseOrders`
Se utilizzi AWS Organizations, puoi utilizzare gli [script Bulk Policy Migrator o Bulk Policy Migrator](#migrate-iam-permissions) per aggiornare le politiche dal tuo account di pagamento. Puoi anche utilizzare il [riferimento alla mappatura dalle vecchie operazioni alle operazioni granulari](migrate-granularaccess-iam-mapping-reference.md) per verificare le operazioni IAM da aggiungere.
Se ne hai AWS Organizations creato uno Account AWS o ne fai parte a partire dal 6 marzo 2023 alle 11:00 (PDT), le azioni dettagliate sono già in vigore nella tua organizzazione.
Per facilitare la migrazione delle policy IAM in modo da utilizzare nuove azioni, note come azioni granulari, puoi utilizzare gli script del sito Web [AWS Samples](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles).
Esegui questi script dal conto pagatore della tua organizzazione per identificare le seguenti policy interessate nella tua organizzazione che utilizzano le vecchie azioni IAM:
+ Policy IAM gestite dal cliente
+ Policy IAM in linea per ruoli, gruppi e utenti
+ Politiche di controllo del servizio (SCPs) (si applicano solo all'account del pagatore)
+ Set di autorizzazioni
Gli script generano suggerimenti per nuove azioni che corrispondono alle azioni esistenti utilizzate nella policy. Quindi esamini i suggerimenti e usi gli script per aggiungere le nuove azioni a tutte le policy interessate della tua organizzazione. Non è necessario aggiornare le politiche AWS gestite o AWS gestite SCPs (ad esempio AWS Control Tower e AWS Organizations SCPs).
Utilizzare questi script per:
+ Semplificano gli aggiornamenti delle policy per aiutarti a gestire quelle interessate dall'account del pagatore.
+ Riducono il tempo necessario per aggiornare le policy. Non è necessario accedere a ciascun account membro e aggiornare manualmente le policy.
+ Raggruppano policy identiche di account membri diversi. Puoi quindi esaminare e applicare gli stessi aggiornamenti a tutte le policy identiche, anziché esaminarli singolarmente.
+ Assicurati che l'accesso degli utenti rimanga inalterato dopo il AWS ritiro delle vecchie azioni IAM il 6 luglio 2023.
Per ulteriori informazioni sulle politiche e sulle politiche di controllo dei servizi (SCPs), consulta i seguenti argomenti:
+ [Gestione di policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) nella *Guida per l'utente IAM*
+ [Politiche di controllo del servizio (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) nella *Guida AWS Organizations per l'utente*
+ [Autorizzazioni personalizzate](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetcustom.html) nella *Guida per l'utente del Centro identità IAM*
## Panoramica di
Segui questo argomento per completare i passaggi seguenti:
**Topics**
+ [Panoramica di](#overview-bulk-migrate-policies)
+ [Prerequisiti](#prerequisites-running-the-scripts)
+ [Fase 1: configurazione dell'ambiente](#set-up-your-environment-and-download-the-scripts)
+ [Fase 2: Creare il CloudFormation StackSet](#create-the-cloudformation-stack)
+ [Fase 3: Identifica le policy interessate](#identify-the-affected-policies)
+ [Fase 4: Esamina le modifiche suggerite](#review-the-affected-policies)
+ [Fase 5: aggiorna le policy interessate](#update-the-affected-policies)
+ [Fase 6: annulla le modifiche (facoltativo)](#revert-changes)
+ [Esempi di policy IAM](#examples-of-similar-policies)
## Prerequisiti
Per iniziare, devi effettuare quanto segue:
+ Scarica e installa [Python 3](https://www.python.org/downloads/)
+ Accedi al tuo account pagatore e verifica di disporre di un principale IAM con le seguenti autorizzazioni IAM:
```
"iam:GetAccountAuthorizationDetails",
"iam:GetPolicy",
"iam:GetPolicyVersion",
"iam:GetUserPolicy",
"iam:GetGroupPolicy",
"iam:GetRole",
"iam:GetRolePolicy",
"iam:CreatePolicyVersion",
"iam:DeletePolicyVersion",
"iam:ListAttachedRolePolicies",
"iam:ListPolicyVersions",
"iam:PutUserPolicy",
"iam:PutGroupPolicy",
"iam:PutRolePolicy",
"iam:SetDefaultPolicyVersion",
"organizations:ListAccounts",
"organizations:ListPolicies",
"organizations:DescribePolicy",
"organizations:UpdatePolicy",
"organizations:DescribeOrganization",
"sso:DescribePermissionSet",
"sso:DescribePermissionSetProvisioningStatus",
"sso:GetInlinePolicyForPermissionSet",
"sso:ListInstances",
"sso:ListPermissionSets",
"sso:ProvisionPermissionSet",
"sso:PutInlinePolicyToPermissionSet",
"sts:AssumeRole"
```
**Suggerimento**
Per iniziare, ti consigliamo di usare un sottoinsieme di account, come gli account di prova, per verificare che le modifiche suggerite siano previste.
Puoi quindi eseguire ancora gli script per gli account rimanenti della tua organizzazione.
## Fase 1: configurazione dell'ambiente
Per iniziare, scarica i file richiesti dal sito Web [AWS Samples](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles). Quindi esegui i comandi per configurare il tuo ambiente.
**Come configurare l'ambiente**
1. Clona il repository dal sito Web [AWS Samples](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles) In una finestra a riga di comando, puoi usare il seguente comando:
```
git clone https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles.git
```
1. Passare alla directory in cui hai scaricato i file. Utilizzare il seguente comando:
```
cd bulk-policy-migrator-scripts-for-account-cost-billing-consoles
```
Nel repository, puoi trovare i seguenti script e risorse:
+ `billing_console_policy_migrator_role.json`— Il CloudFormation modello che crea il ruolo `BillingConsolePolicyMigratorRole` IAM negli account dei membri dell'organizzazione. Questo ruolo consente agli script di assumere il ruolo e quindi di leggere e aggiornare le policy interessate.
+ `action_mapping_config.json`— Contiene la one-to-many mappatura delle vecchie azioni con le nuove azioni. Gli script utilizzano questo file per suggerire le nuove azioni per ogni policy interessata che contiene le vecchie azioni.
Ogni vecchia azione corrisponde a più azioni granulari. Le nuove azioni suggerite nel file consentono agli utenti di accedervi Servizi AWS prima della migrazione.
+ `identify_affected_policies.py` — Scansiona e identifica le policy interessate nella tua organizzazione. Questo script genera un file `affected_policies_and_suggestions.json` che elenca le policy interessate insieme alle nuove azioni suggerite.
Le policy interessate che utilizzano lo stesso set di vecchie azioni sono raggruppate nel file JSON, in modo da poter rivedere o aggiornare le nuove azioni suggerite.
+ `update_affected_policies.py` — Aggiorna le policy interessate nella tua organizzazione. Lo script immette il file `affected_policies_and_suggestions.json` e quindi aggiunge le nuove azioni suggerite alle policy.
+ `rollback_affected_policies.py` — (Facoltativo) Annulla le modifiche apportate alle policy interessate. Questo script rimuove le nuove azioni granulari dalle policy interessate.
1. Per configurare e attivare l'ambiente virtuale, esegui i comandi seguenti.
```
python3 -m venv venv
```
```
source venv/bin/activate
```
1. Esegui il comando seguente per installare la AWS SDK per Python (Boto3) dipendenza.
```
pip install -r requirements.txt
```
**Nota**
È necessario configurare AWS le credenziali per utilizzare AWS Command Line Interface ()AWS CLI. Per ulteriori informazioni, consulta [AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html).
Per ulteriori informazioni, consulta il file [README.md](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles#readme).
## Fase 2: Creare il CloudFormation StackSet
Segui questa procedura per creare un *set di CloudFormation stack*. Questo set di stack crea quindi il ruolo IAM `BillingConsolePolicyMigratorRole` per tutti gli account membri nell'organizzazione.
**Nota**
È necessario completare questo passaggio solo una volta dall'account di gestione (account pagatore).
**Per creare il CloudFormation StackSet**
1. In un editor di testo, apri il `billing_console_policy_migrator_role.json` file e sostituisci ogni istanza di *``* con l'ID dell'account del pagatore (ad esempio,*123456789012*).
1. Salvare il file.
1. Accedi all'account Console di gestione AWS come pagatore.
1. Nella CloudFormation console, crea uno stack set con il `billing_console_policy_migrator_role.json` file che hai aggiornato.
Per ulteriori informazioni, consulta [Creazione di un set di stack sulla AWS CloudFormation console nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-getting-started-create.html) per l'*AWS CloudFormation utente*.
Dopo aver CloudFormation creato lo stack set, ogni account membro dell'organizzazione ha un ruolo `BillingConsolePolicyMigratorRole` IAM.
Il ruolo IAM contiene le seguenti autorizzazioni:
```
"iam:GetAccountAuthorizationDetails",
"iam:GetPolicy",
"iam:GetPolicyVersion",
"iam:GetUserPolicy",
"iam:GetGroupPolicy",
"iam:GetRolePolicy",
"iam:CreatePolicyVersion",
"iam:DeletePolicyVersion",
"iam:ListPolicyVersions",
"iam:PutUserPolicy",
"iam:PutGroupPolicy",
"iam:PutRolePolicy",
"iam:SetDefaultPolicyVersion"
```
**Note**
Per ogni account membro, gli script richiamano l'operazione [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API per ottenere credenziali temporanee per assumere il `BillingConsolePolicyMigratorRole` ruolo IAM.
Gli script richiamano l'operazione [ListAccounts](https://docs.aws.amazon.com/organizations/latest/APIReference/API_ListAccounts.html)API per ottenere tutti gli account dei membri.
Gli script richiamano anche le operazioni dell'API IAM per eseguire le autorizzazioni di lettura e scrittura delle policy.
## Fase 3: Identifica le policy interessate
Dopo aver creato il set di stack e scaricato i file, esegui lo script `identify_affected_policies.py`. Questo script assume il ruolo IAM `BillingConsolePolicyMigratorRole` per ogni account membro e quindi identifica le policy interessate.
**Per identificare le policy interessate**
1. Passa alla directory in cui hai scaricato gli script.
```
cd policy_migration_scripts/scripts
```
1. Eseguire lo script `identify_affected_policies.py`.
Puoi inoltre utilizzare i seguenti parametri di input:
+ Account AWS che vuoi che lo script scansioni. Per specificare gli account, utilizza i seguenti parametri di input:
+ `--all` — Esamina tutti gli account membri nell'organizzazione.
```
python3 identify_affected_policies.py --all
```
+ `--accounts` — Esamina un sottoinsieme di account membri nell'organizzazione.
```
python3 identify_affected_policies.py --accounts 111122223333, 444455556666, 777788889999
```
+ `--exclude-accounts` — Sono esclusi gli account membri specifici nell'organizzazione.
```
python3 identify_affected_policies.py --all --exclude-accounts 111111111111, 222222222222, 333333333333
```
+ ` –-action-mapping-config-file` — (Facoltativo) Specificare il percorso del file `action_mapping_config.json`. Lo script utilizza questo file per generare aggiornamenti suggeriti per le policy interessate. Se non specifichi il percorso, lo script utilizza il file `action_mapping_config.json` nella cartella.
```
python3 identify_affected_policies.py –-action-mapping-config-file c:\Users\username\Desktop\Scripts\action_mapping_config.json –-all
```
**Nota**
Non è possibile specificare unità organizzative (OUs) con questo script.
Dopo aver eseguito lo script, crea due file JSON in una `Affected_Policies_` cartella:
+ `affected_policies_and_suggestions.json`
+ `detailed_affected_policies.json`
**`affected_policies_and_suggestions.json`**
Elenca le policy interessate con le nuove azioni suggerite. Le policy interessate che utilizzano lo stesso set di vecchie azioni vengono raggruppate nel file.
Questo file contiene le sezioni seguenti:
+ Metadati che forniscono una panoramica degli account specificati nello script, tra cui:
+ Account scansionati e parametro di input utilizzato per lo script `identify_affected_policies.py`
+ Numero di account interessati
+ Numero di policy interessate
+ Numero di gruppi di policy simili
+ Gruppi di policy simili: include l'elenco degli account e dei dettagli delle policy, incluse le seguenti sezioni:
+ `ImpactedPolicies` — Specifica quali policy sono interessate e incluse nel gruppo
+ `ImpactedPolicyStatements` — Fornisce informazioni sui blocchi `Sid` che attualmente utilizzano le vecchie azioni nella policy interessata. Questa sezione include le azioni e gli elementi IAM precedenti, come `Effect`, `Principal`, `NotPrincipal`, `NotAction` e `Condition`.
+ `SuggestedPolicyStatementsToAppend` — Fornisce le nuove azioni suggerite che vengono aggiunte come nuovo blocco `SID`.
Quando si aggiornano le policy, questo blocco viene aggiunto alla fine delle policy.
**Example Esempio di file `affected_policies_and_suggestions.json`**
Questo file raggruppa policy simili in base ai seguenti criteri:
+ Vengono utilizzate le stesse azioni precedenti: policy con le stesse vecchie azioni in tutti i blocchi `SID`.
+ Dettagli corrispondenti: oltre alle azioni interessate, le policy hanno elementi IAM identici, come:
+ `Effect` (`Allow`/`Deny`)
+ `Principal` (a chi è consentito o negato l'accesso)
+ `NotAction` (quali azioni non sono consentite)
+ `NotPrincipal` (a chi viene negato esplicitamente l'accesso)
+ `Resource`(a quali AWS risorse si applica la politica)
+ `Condition` (eventuali condizioni specifiche in base alle quali si applica la policy)
Per ulteriori informazioni, consulta [Esempi di policy IAM](#examples-of-similar-policies).
**Example Esempio `affected_policies_and_suggestions.json`**
```
[{
"AccountsScanned": [
"111111111111",
"222222222222"
],
"TotalAffectedAccounts": 2,
"TotalAffectedPolicies": 2,
"TotalSimilarPolicyGroups": 2
},
{
"GroupName": "Group1",
"ImpactedPolicies": [{
"Account": "111111111111",
"PolicyType": "UserInlinePolicy",
"PolicyName": "Inline-Test-Policy-Allow",
"PolicyIdentifier": "1111111_1-user:Inline-Test-Policy-Allow"
},
{
"Account": "222222222222",
"PolicyType": "UserInlinePolicy",
"PolicyName": "Inline-Test-Policy-Allow",
"PolicyIdentifier": "222222_1-group:Inline-Test-Policy-Allow"
}
],
"ImpactedPolicyStatements": [
[{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccounts"
],
"Resource": "*"
}]
],
"SuggestedPolicyStatementsToAppend": [{
"Sid": "BillingConsolePolicyMigrator0",
"Effect": "Allow",
"Action": [
"account:GetAccountInformation",
"account:GetAlternateContact",
"account:GetChallengeQuestions",
"account:GetContactInformation",
"billing:GetContractInformation",
"billing:GetIAMAccessPreference",
"billing:GetSellerOfRecord",
"payments:ListPaymentPreferences"
],
"Resource": "*"
}]
},
{
"GroupName": "Group2",
"ImpactedPolicies": [{
"Account": "111111111111",
"PolicyType": "UserInlinePolicy",
"PolicyName": "Inline-Test-Policy-deny",
"PolicyIdentifier": "1111111_2-user:Inline-Test-Policy-deny"
},
{
"Account": "222222222222",
"PolicyType": "UserInlinePolicy",
"PolicyName": "Inline-Test-Policy-deny",
"PolicyIdentifier": "222222_2-group:Inline-Test-Policy-deny"
}
],
"ImpactedPolicyStatements": [
[{
"Sid": "VisualEditor0",
"Effect": "deny",
"Action": [
"aws-portal:ModifyAccount"
],
"Resource": "*"
}]
],
"SuggestedPolicyStatementsToAppend": [{
"Sid": "BillingConsolePolicyMigrator1",
"Effect": "Deny",
"Action": [
"account:CloseAccount",
"account:DeleteAlternateContact",
"account:PutAlternateContact",
"account:PutChallengeQuestions",
"account:PutContactInformation",
"billing:PutContractInformation",
"billing:UpdateIAMAccessPreference",
"payments:UpdatePaymentPreferences"
],
"Resource": "*"
}]
}
]
```
**`detailed_affected_policies.json`**
Contiene la definizione di tutte le policy interessate identificate dallo script `identify_affected_policies.py` per gli account membri.
Il file raggruppa policy simili. Puoi utilizzare questo file come riferimento, in modo da poter rivedere e gestire le modifiche alle policy senza dover accedere a ciascun account membro per rivedere gli aggiornamenti di ogni policy e account singolarmente.
È possibile cercare nel file il nome della policy (ad esempio, `YourCustomerManagedReadOnlyAccessBillingUser`) e quindi rivedere le definizioni delle policy interessate.
**Example Ad esempio: `detailed_affected_policies.json`**
## Fase 4: Esamina le modifiche suggerite
Dopo che lo script ha creato il file `affected_policies_and_suggestions.json`, esaminalo e apporta le modifiche.
**Per esaminare le policy interessate**
1. In un editor di testo, aprire il file `affected_policies_and_suggestions.json`.
1. Nella sezione `AccountsScanned`, verifica che sia previsto il numero di gruppi simili identificati negli account scansionati.
1. Esamina le azioni granulari suggerite che verranno aggiunte alle policy interessate.
1. Aggiorna il file in base alle esigenze e quindi salvalo.
### Esempio 1: aggiorna il file `action_mapping_config.json`
È possibile aggiornare le mappature suggerite in `action_mapping_config.json`. Dopo aver aggiornato il file, è possibile eseguire nuovamente lo script `identify_affected_policies.py`. Questo script genera suggerimenti aggiornati per le policy interessate.
Puoi creare più versioni del file `action_mapping_config.json` per modificare le policy per diversi account con autorizzazioni diverse. Ad esempio, potresti creare un file denominato `action_mapping_config_testing.json` per migrare le autorizzazioni per i tuoi account di prova e `action_mapping_config_production.json` per i tuoi account di produzione.
### Esempio 2: aggiorna il file `affected_policies_and_suggestions.json`
Per apportare modifiche alle sostituzioni suggerite per uno specifico gruppo di policy interessato, puoi modificare direttamente la sezione delle sostituzioni suggerite all'interno del file `affected_policies_and_suggestions.json`.
Tutte le modifiche apportate in questa sezione vengono applicate a tutte le policy all'interno di quello specifico gruppo di policy interessato.
### Esempio 3: personalizza una policy specifica
Se trovi che una policy all'interno di un gruppo di policy interessato richiede modifiche diverse rispetto agli aggiornamenti suggeriti, puoi procedere come segue:
+ Escludi account specifici dallo script `identify_affected_policies.py`. Puoi quindi rivedere separatamente gli account esclusi.
+ Aggiorna i blocchi `Sid` interessati rimuovendo le policy e gli account interessati che richiedono autorizzazioni diverse. Crea un blocco JSON che includa solo gli account specifici o li escluda dall'esecuzione della policy interessata dall'aggiornamento corrente.
Quando esegui nuovamente lo script `identify_affected_policies.py`, nel blocco aggiornato vengono visualizzati solo gli account pertinenti. Quindi puoi perfezionare le sostituzioni suggerite per quel blocco `Sid` specifico.
## Fase 5: aggiorna le policy interessate
Dopo aver esaminato e perfezionato le sostituzioni suggerite, esegui lo script `update_affected_policies.py`. Lo script accetta il file `affected_policies_and_suggestions.json` come input. Questo script assume il ruolo IAM `BillingConsolePolicyMigratorRole` per aggiornare le policy interessate elencate nel file `affected_policies_and_suggestions.json`.
**Per aggiornare le policy interessate**
1. Se non l'hai già fatto, apri una finestra della riga di comando per AWS CLI.
1. Inserisci il comando seguente per eseguire lo script `update_affected_policies.py`. Puoi inserire il seguente parametro di input:
+ Il percorso della directory del file `affected_policies_and_suggestions.json` che contiene un elenco delle policy interessate da aggiornare. Questo file è un output del passaggio precedente.
```
python3 update_affected_policies.py --affected-policies-directory Affected_Policies_
```
Lo script `update_affected_policies.py` aggiorna le policy interessate all'interno del file `affected_policies_and_suggestions.json` con le nuove azioni suggerite. Lo script aggiunge un `Sid` blocco alle politiche, identificato come`BillingConsolePolicyMigrator#`, dove *\$1* corrisponde a un contatore incrementale (ad esempio, 1, 2, 3).
Ad esempio, se nella policy interessata sono presenti più blocchi `Sid` che utilizzano azioni obsolete, lo script aggiunge più blocchi `Sid` che sembrano corrispondere a `BillingConsolePolicyMigrator#` a ciascun blocco `Sid`.
**Importante**
Lo script non rimuove le vecchie azioni IAM dalle policy né modifica i blocchi `Sid` esistenti nelle policy. Invece, crea blocchi `Sid` e li aggiunge alla fine della policy. Questi nuovi blocchi `Sid` contengono le nuove azioni suggerite dal file JSON. Ciò garantisce che le autorizzazioni delle policy originali non vengano modificate.
Ti consigliamo di non modificare il nome dei blocchi `BillingConsolePolicyMigrator#` `Sid` nel caso in cui sia necessario annullare le modifiche.
**Example Esempio: policy con blocchi `Sid` aggiunti**
Guarda i blocchi `Sid` aggiunti nei blocchi `BillingConsolePolicyMigrator1` e `BillingConsolePolicyMigrator2`.
Lo script genera un rapporto sullo stato che contiene operazioni non riuscite e restituisce il file JSON localmente.
**Example Esempio: rapporto sullo stato**
```
[{
"Account": "111111111111",
"PolicyType": "Customer Managed Policy"
"PolicyName": "AwsPortalViewPaymentMethods",
"PolicyIdentifier": "identifier",
"Status": "FAILURE", // FAILURE or SKIPPED
"ErrorMessage": "Error message details"
}]
```
**Importante**
Se esegui nuovamente gli script `identify_affected_policies.py` e `update_affected_policies.py`, questi ignorano tutte le policy che contengono il blocco `BillingConsolePolicyMigratorRole#``Sid`. Gli script presuppongono che tali policy siano state precedentemente scansionate e aggiornate e che non richiedano aggiornamenti aggiuntivi. Questo impedisce allo script di duplicare le stesse azioni nella policy.
Dopo aver aggiornato le policy interessate, puoi utilizzare il nuovo IAM utilizzando lo strumento per le policy interessate. Se riscontri problemi, puoi utilizzare lo strumento per tornare alle azioni precedenti. Puoi anche utilizzare uno script per ripristinare gli aggiornamenti delle policy.
Per ulteriori informazioni, consulta il [Come utilizzare lo strumento policy interessate](migrate-security-iam-tool.md) post sul blog [Modifiche alle autorizzazioni di AWS fatturazione, gestione dei costi e console dell'account](https://aws.amazon.com/blogs/aws-cloud-financial-management/changes-to-aws-billing-cost-management-and-account-consoles-permissions/).
Per gestire gli aggiornamenti, è possibile:
Esegui gli script per ogni account singolarmente.
Esegui lo script in batch per account simili (come account di test, controllo qualità e produzione).
Esegui lo script per tutti gli account.
Scegli una combinazione tra l'aggiornamento di alcuni account in batch e l'aggiornamento di altri singolarmente.
## Fase 6: annulla le modifiche (facoltativo)
Lo script `rollback_affected_policies.py` ripristina le modifiche applicate a ciascuna policy interessata per gli account specificati. Lo script rimuove tutti i blocchi `Sid` che lo script `update_affected_policies.py` ha aggiunto. Questi blocchi `Sid` hanno il formato `BillingConsolePolicyMigratorRole#`.
**Per annullare le modifiche**
1. Se non l'hai già fatto, apri una finestra della riga di comando per AWS CLI.
1. Inserisci il comando seguente per eseguire lo script `rollback_affected_policies.py`. Puoi inserire i seguenti parametri di input:
+ `--accounts`
+ Specificate un elenco separato da virgole dei file Account AWS IDs che desiderate includere nel rollback.
+ L'esempio seguente analizza le politiche specificate Account AWS e rimuove tutte le istruzioni con il blocco. `BillingConsolePolicyMigrator#` `Sid`
```
python3 rollback_affected_policies.py –-accounts 111122223333, 555555555555, 666666666666
```
+ `--all`
+ Include tutto ciò che Account AWS IDs fa parte dell'organizzazione.
+ L'esempio seguente analizza tutte le policy nell'organizzazione e rimuove tutte le istruzioni con il blocco `BillingConsolePolicyMigratorRole#` `Sid`.
```
python3 rollback_affected_policies.py –-all
```
+ `--exclude-accounts`
+ Specificate un elenco separato da virgole degli elementi Account AWS IDs che desiderate escludere dal rollback.
Puoi utilizzare questo parametro solo quando specifichi il parametro `--all`.
+ L'esempio seguente analizza le politiche per tutti gli utenti dell'organizzazione, ad Account AWS eccezione degli account specificati.
```
python3 rollback_affected_policies.py --all --exclude-accounts 777777777777, 888888888888, 999999999999
```
## Esempi di policy IAM
Le policy sono considerate simili se hanno simili:
+ Azioni interessate in tutti i blocchi `Sid`.
+ Dettagli nei seguenti elementi IAM:
+ `Effect` (`Allow`/`Deny`)
+ `Principal` (a chi è consentito o negato l'accesso)
+ `NotAction` (quali azioni non sono consentite)
+ `NotPrincipal` (a chi viene negato esplicitamente l'accesso)
+ `Resource`(a quali AWS risorse si applica la politica)
+ `Condition` (eventuali condizioni specifiche in base alle quali si applica la policy)
Gli esempi seguenti mostrano policy che IAM potrebbe considerare simili o meno in base alle differenze.
**Example Esempio 1: le policy sono considerate simili**
Ogni tipo di policy è diverso, ma entrambe contengono un blocco `Sid` con la stessa `Action` interessata.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccount",
"aws-portal:*Billing"
],
"Resource": "*"
}]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccount",
"aws-portal:*Billing"
],
"Resource": "*"
}]
}
```
**Example Esempio 2: le policy sono considerate simili**
Entrambe le policy contengono un blocco `Sid` con la stessa `Action` interessata. La policy 2 contiene azioni aggiuntive, ma queste azioni non sono interessate.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccount",
"aws-portal:*Billing"
],
"Resource": "*"
}]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccount",
"aws-portal:*Billing",
"athena:*"
],
"Resource": "*"
}]
}
```
**Example Esempio 3: le policy non sono considerate simili**
Entrambe le policy contengono un blocco `Sid` con la stessa `Action` interessata. Tuttavia, la policy 2 contiene un elemento `Condition` che non è presente nella policy 1.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccount",
"aws-portal:*Billing"
],
"Resource": "*"
}]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:ViewAccount",
"aws-portal:*Billing",
"athena:*"
],
"Resource": "*",
"Condition": {
"BoolIfExists": {
"aws:MultiFactorAuthPresent": "true"
}
}
}]
}
```
**Example Esempio 4: le policy sono considerate simili**
La Policy 1 prevede un singolo blocco `Sid` con una `Action` interessata. La Policy 2 ha più `Sid` blocchi, ma la `Action` interessata viene visualizzata in un solo blocco.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:View*"
],
"Resource": "*"
}]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:View*"
],
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"cloudtrail:Get*"
],
"Resource": "*"
}
]
}
```
**Example Esempio 5: le policy non sono considerate simili**
La Policy 1 prevede un singolo blocco `Sid` con una `Action` interessata. La Policy 2 ha più `Sid` blocchi e la `Action` interessata viene visualizzata in più blocchi.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:View*"
],
"Resource": "*"
}]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:View*"
],
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Deny",
"Action": [
"aws-portal:Modify*"
],
"Resource": "*"
}
]
}
```
**Example Esempio 6: le policy sono considerate simili**
Entrambe le policy hanno più `Sid` blocchi, con la stessa `Action` interessata in ogni blocco `Sid`.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:*Account",
"iam:Get*"
],
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Deny",
"Action": [
"aws-portal:Modify*",
"iam:Update*"
],
"Resource": "*"
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:*Account",
"athena:Get*"
],
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Deny",
"Action": [
"aws-portal:Modify*",
"athena:Update*"
],
"Resource": "*"
}
]
}
```
**Example Esempio 7**
Le due policy seguenti non sono considerate simili.
La Policy 1 prevede un singolo blocco `Sid` con una `Action` interessata. La Policy 2 presenta un blocco `Sid` con la stessa `Action` interessata. Tuttavia, la policy 2 contiene anche un altro blocco `Sid` con azioni diverse.
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:*Account",
"iam:Get*"
],
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Deny",
"Action": [
"aws-portal:Modify*",
"iam:Update*"
],
"Resource": "*"
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"aws-portal:*Account",
"athena:Get*"
],
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Deny",
"Action": [
"aws-portal:*Billing",
"athena:Update*"
],
"Resource": "*"
}
]
}
```