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.
# Utilisation de scripts pour migrer vos politiques en bloc afin d'utiliser des actions IAM précises
**Note**
Les actions Gestion des identités et des accès AWS (IAM) suivantes ont atteint la fin du support standard en juillet 2023 :
Espace de noms `aws-portal`
`purchase-orders:ViewPurchaseOrders`
`purchase-orders:ModifyPurchaseOrders`
Si vous en utilisez AWS Organizations, vous pouvez utiliser les [scripts de migration de politiques par lots ou le migrateur](#migrate-iam-permissions) de politiques par lots pour mettre à jour les politiques depuis votre compte payeur. Vous pouvez également utiliser la [référence du mappage entre les anciennes et les nouvelles actions détaillées](migrate-granularaccess-iam-mapping-reference.md) pour vérifier les actions IAM qui doivent être ajoutées.
Si vous en avez AWS Organizations créé un ou en faites partie le 6 mars 2023 ou après cette date, 11 h 00 (PDT), les actions détaillées sont déjà en vigueur dans votre organisation. Compte AWS
Pour faciliter la migration de vos politiques IAM afin d'utiliser les nouvelles actions, appelées actions détaillées, vous pouvez utiliser les scripts disponibles sur le site Web [Exemples AWS](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles) (langue française non garantie).
Vous exécutez ces scripts à partir du compte payeur de votre organisation pour identifier les stratégies concernées suivantes de votre organisation qui utilisent les anciennes actions IAM :
+ Politiques IAM gérées par le client
+ Politiques IAM en ligne relatives aux rôles, aux groupes et aux utilisateurs
+ Politiques de contrôle des services (SCPs) (s'applique uniquement au compte du payeur)
+ Ensembles d'autorisations
Les scripts génèrent des suggestions de nouvelles actions qui correspondent aux actions existantes utilisées dans la politique. Vous passez ensuite en revue les suggestions et utilisez les scripts pour ajouter les nouvelles actions à toutes les stratégies concernées de votre organisation. Il n'est pas nécessaire de mettre à jour les politiques AWS AWS gérées ou gérées SCPs (par exemple, AWS Control Tower et AWS Organizations SCPs).
Ces scripts sont utilisés pour :
+ Simplifiez les mises à jour des politiques pour vous aider à gérer les stratégies concernées depuis le compte payeur.
+ Réduisez la durée de mise à jour des politiques. Vous n'avez pas besoin de vous connecter à chaque compte membre et de mettre à jour manuellement les politiques.
+ Regroupez des politiques identiques provenant de différents comptes membres. Vous pouvez ensuite vérifier et appliquer les mêmes mises à jour à toutes les politiques identiques, au lieu de les examiner une par une.
+ Assurez-vous que l'accès des utilisateurs reste inchangé après le AWS retrait des anciennes actions IAM le 6 juillet 2023.
Pour plus d'informations sur les politiques et les politiques de contrôle des services (SCPs), consultez les rubriques suivantes :
+ [Gestion des politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) dans le *Guide de l’utilisateur IAM*
+ [Politiques de contrôle des services (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) dans le *guide de AWS Organizations l'utilisateur*
+ [Autorisations personnalisées](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetcustom.html) dans le *Guide de l'utilisateur IAM Identity Center*
## Présentation de
Suivez cette rubrique pour effectuer les étapes suivantes :
**Topics**
+ [Présentation de](#overview-bulk-migrate-policies)
+ [Conditions préalables](#prerequisites-running-the-scripts)
+ [Étape 1 : configuration de votre environnement](#set-up-your-environment-and-download-the-scripts)
+ [Étape 2 : Création du CloudFormation StackSet](#create-the-cloudformation-stack)
+ [Étape 3 : identification des stratégies concernées](#identify-the-affected-policies)
+ [Étape 4 : examen des modifications suggérées](#review-the-affected-policies)
+ [Étape 5 : mise à jour des stratégies concernées](#update-the-affected-policies)
+ [Étape 6 : annulation de vos modifications (Facultatif)](#revert-changes)
+ [Exemples de politique IAM](#examples-of-similar-policies)
## Conditions préalables
Pour commencer, vous devez réaliser l'action suivante :
+ Télécharger et installer [Python 3](https://www.python.org/downloads/)
+ Connectez-vous à votre compte payeur et vérifiez que vous disposez d'un principal IAM disposant des autorisations IAM suivantes :
```
"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"
```
**Astuce**
Pour commencer, nous vous recommandons d'utiliser un sous-ensemble d'un compte, tel qu'un compte de test, afin de vérifier que les modifications suggérées sont attendues.
Vous pouvez ensuite réexécuter les scripts pour les autres comptes de votre organisation.
## Étape 1 : configuration de votre environnement
Pour commencer, téléchargez les fichiers requis sur le site Web [AWS Samples](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles). Exécutez ensuite des commandes pour configurer votre environnement.
**Configuration de votre environnement**
1. Clonez le référentiel depuis le site Web [AWS Samples](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles). Dans une fenêtre de ligne de commande, vous pouvez utiliser la commande suivante :
```
git clone https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles.git
```
1. Accédez au répertoire où vous avez téléchargé les fichiers. Vous pouvez utiliser la commande suivante :
```
cd bulk-policy-migrator-scripts-for-account-cost-billing-consoles
```
Le référentiel contient les scripts et les ressources suivants :
+ `billing_console_policy_migrator_role.json`— Le CloudFormation modèle qui crée le rôle `BillingConsolePolicyMigratorRole` IAM dans les comptes membres de votre organisation. Ce rôle permet aux scripts d'endosser le rôle, puis de lire et de mettre à jour les stratégies concernées.
+ `action_mapping_config.json`— Contient le one-to-many mappage des anciennes actions aux nouvelles actions. Les scripts utilisent ce fichier pour suggérer les nouvelles actions pour chaque politique affectée qui contient les anciennes actions.
Chaque ancienne action correspond à plusieurs actions détaillées. Les nouvelles actions proposées dans le fichier permettent aux utilisateurs d'y accéder Services AWS avant la migration.
+ `identify_affected_policies.py` : analyse et identifie les stratégies concernées au sein de votre organisation. Ce script génère un fichier `affected_policies_and_suggestions.json` qui répertorie les stratégies concernées ainsi que les nouvelles actions suggérées.
Les stratégies concernées qui utilisent le même ensemble d'anciennes actions sont regroupées dans le fichier JSON, afin que vous puissiez consulter ou mettre à jour les nouvelles actions suggérées.
+ `update_affected_policies.py` : met à jour les stratégies concernées dans votre organisation. Le script saisit le fichier `affected_policies_and_suggestions.json`, puis ajoute les nouvelles actions suggérées aux politiques.
+ `rollback_affected_policies.py` : (Facultatif) annule les modifications apportées aux stratégies concernées. Ce script supprime les nouvelles actions détaillées des stratégies concernées.
1. Exécutez les commandes suivantes pour configurer et activer l'environnement virtuel.
```
python3 -m venv venv
```
```
source venv/bin/activate
```
1. Exécutez la commande suivante pour installer la AWS SDK pour Python (Boto3) dépendance.
```
pip install -r requirements.txt
```
**Note**
Vous devez configurer vos AWS informations d'identification pour utiliser le AWS Command Line Interface (AWS CLI). Pour de plus amples informations, veuillez consulter [AWS SDK pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html).
Pour plus d'informations, veuillez consulter le fichier [README.md](https://github.com/aws-samples/bulk-policy-migrator-scripts-for-account-cost-billing-consoles#readme).
## Étape 2 : Création du CloudFormation StackSet
Suivez cette procédure pour créer un *ensemble de CloudFormation piles*. Cet ensemble de piles crée ensuite le rôle IAM `BillingConsolePolicyMigratorRole` pour tous les comptes membres de votre organisation.
**Note**
Vous devez effectuer cette étape une seule fois depuis le compte de gestion (compte payeur).
**Pour créer le CloudFormation StackSet**
1. Dans un éditeur de texte, ouvrez le `billing_console_policy_migrator_role.json` fichier et remplacez chaque instance de *``* par le numéro de compte du compte payeur (par exemple,*123456789012*).
1. Enregistrez le fichier.
1. Connectez-vous au AWS Management Console compte payeur.
1. Dans la CloudFormation console, créez un ensemble de piles avec le `billing_console_policy_migrator_role.json` fichier que vous avez mis à jour.
Pour plus d'informations, consultez la section [Création d'un ensemble de piles sur la AWS CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-getting-started-create.html) dans le *Guide de AWS CloudFormation l'utilisateur*.
Une fois CloudFormation le stack set créé, chaque compte membre de votre organisation possède un rôle `BillingConsolePolicyMigratorRole` IAM.
Le rôle IAM contient les autorisations suivantes :
```
"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"
```
**Remarques**
Pour chaque compte membre, les scripts appellent l'opération [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API pour obtenir des informations d'identification temporaires afin d'assumer le rôle `BillingConsolePolicyMigratorRole` IAM.
Les scripts appellent l'opération [ListAccounts](https://docs.aws.amazon.com/organizations/latest/APIReference/API_ListAccounts.html)API pour obtenir tous les comptes des membres.
Les scripts appellent également des opérations d'API IAM pour accorder les autorisations de lecture et d'écriture aux politiques.
## Étape 3 : identification des stratégies concernées
Après avoir créé l'ensemble de piles et téléchargé les fichiers, exécutez le script `identify_affected_policies.py`. Ce script endosse le rôle IAM `BillingConsolePolicyMigratorRole` pour chaque compte membre, puis identifie les stratégies concernées.
**Pour identifier les stratégies concernées**
1. Accédez au répertoire où vous avez téléchargé les scripts.
```
cd policy_migration_scripts/scripts
```
1. Exécutez le script `identify_affected_policies.py`.
Vous pouvez utiliser les paramètres d'entrée suivants :
+ Comptes AWS que vous souhaitez que le script scanne. Pour spécifier des comptes, utilisez les paramètres d'entrée suivants :
+ `--all` : analyse tous les comptes membres de votre organisation.
```
python3 identify_affected_policies.py --all
```
+ `--accounts` : analyse un sous-ensemble des comptes membres de votre organisation.
```
python3 identify_affected_policies.py --accounts 111122223333, 444455556666, 777788889999
```
+ `--exclude-accounts` : exclut des membres comptes spécifiques de votre organisation.
```
python3 identify_affected_policies.py --all --exclude-accounts 111111111111, 222222222222, 333333333333
```
+ ` –-action-mapping-config-file` : (Facultatif) spécifiez le chemin d'accès au fichier `action_mapping_config.json`. Le script utilise ce fichier pour générer des suggestions de mises à jour pour les stratégies concernées. Si vous ne spécifiez pas le chemin, le script utilise le fichier `action_mapping_config.json` du dossier.
```
python3 identify_affected_policies.py –-action-mapping-config-file c:\Users\username\Desktop\Scripts\action_mapping_config.json –-all
```
**Note**
Vous ne pouvez pas spécifier d'unités organisationnelles (OUs) avec ce script.
Après avoir exécuté le script, il crée deux fichiers JSON dans un dossier `Affected_Policies_` :
+ `affected_policies_and_suggestions.json`
+ `detailed_affected_policies.json`
**`affected_policies_and_suggestions.json`**
Répertorie les stratégies concernées avec les nouvelles actions suggérées. Les stratégies concernées qui utilisent le même ensemble d'anciennes actions sont regroupées dans le fichier.
Ce fichier comprend les sections suivantes :
+ Des métadonnées qui fournissent une vue d'ensemble des comptes que vous avez spécifiés dans le script, notamment :
+ Les comptes analysés et le paramètre d'entrée utilisé pour le script `identify_affected_policies.py`
+ Le nombre de comptes concernés
+ Le nombre de stratégies concernées
+ Le nombre de groupes de politiques similaires
+ Groupes de politiques similaires : inclut la liste des comptes et les détails des politiques, y compris les sections suivantes :
+ `ImpactedPolicies` : spécifie quelles politiques sont concernées et incluses dans le groupe
+ `ImpactedPolicyStatements` : fournit des informations sur les blocs `Sid` qui utilisent actuellement les anciennes actions de la politique concernée. Cette section inclut les anciennes actions et les éléments IAM, tels que `Effect`, `Principal`, `NotPrincipal`, `NotAction` et `Condition`.
+ `SuggestedPolicyStatementsToAppend` : fournit les nouvelles actions suggérées qui sont ajoutées en tant que nouveau bloc `SID`.
Lorsque vous mettez à jour les politiques, ce bloc est ajouté à la fin des politiques.
**Example Exemple de fichier `affected_policies_and_suggestions.json`**
Ce fichier regroupe les politiques similaires en fonction des critères suivants :
+ Anciennes actions utilisées : politiques qui comportent les mêmes anciennes actions dans tous les blocs `SID`.
+ Détails correspondants : outre les actions concernées, les politiques comportent des éléments IAM identiques, tels que :
+ `Effect` (`Allow`/`Deny`)
+ `Principal` (à qui l'accès est autorisé ou refusé)
+ `NotAction` (quelles sont les actions non autorisées)
+ `NotPrincipal` (à qui l'accès est explicitement refusé)
+ `Resource`(à quelles AWS ressources s'applique la politique)
+ `Condition` (toutes les conditions spécifiques en vertu desquelles la politique s'applique)
Pour de plus amples informations, veuillez consulter [Exemples de politique IAM](#examples-of-similar-policies).
**Example `affected_policies_and_suggestions.json` exemple**
```
[{
"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`**
Contient la définition de toutes les stratégies concernées que le script `identify_affected_policies.py` a identifiées pour les comptes membres.
Le fichier regroupe des politiques similaires. Vous pouvez utiliser ce fichier comme référence, afin de pouvoir consulter et gérer les modifications des politiques sans avoir à vous connecter à chaque compte membre pour consulter les mises à jour de chaque politique et de chaque compte individuellement.
Vous pouvez rechercher le nom de la politique dans le fichier (par exemple, `YourCustomerManagedReadOnlyAccessBillingUser`), puis consulter les définitions des politiques concernées.
**Example Exemple : `detailed_affected_policies.json`**
## Étape 4 : examen des modifications suggérées
Une fois que le script a créé le fichier `affected_policies_and_suggestions.json`, examinez-le et apportez les modifications nécessaires.
**Pour examiner les stratégies concernées**
1. Dans un éditeur de texte, ouvrez le fichier `affected_policies_and_suggestions.json`.
1. Dans la section `AccountsScanned`, vérifiez que le nombre de groupes similaires identifiés dans les comptes analysés est attendu.
1. Examinez les actions détaillées suggérées qui seront ajoutées aux stratégies concernées.
1. Mettez à jour votre fichier selon vos besoins, puis enregistrez-le.
### Exemple 1 : mise à jour du fichier `action_mapping_config.json`
Vous pouvez mettre à jour les mappages suggérés dans le `action_mapping_config.json`. Après avoir mis à jour le fichier, vous pouvez réexécuter le script `identify_affected_policies.py`. Ce script génère des suggestions mises à jour pour les stratégies concernées.
Vous pouvez créer plusieurs versions du fichier `action_mapping_config.json` pour modifier les politiques de différents comptes dotés d'autorisations différentes. Par exemple, vous pouvez créer un fichier nommé `action_mapping_config_testing.json` pour migrer les autorisations de vos comptes de test, et un nommé `action_mapping_config_production.json` pour vos comptes de production.
### Exemple 2 : mise à jour du fichier `affected_policies_and_suggestions.json`
Pour apporter des modifications aux remplacements suggérés pour un groupe de politiques concernées spécifique, vous pouvez directement modifier la section des remplacements suggérés dans le fichier `affected_policies_and_suggestions.json`.
Toutes les modifications que vous apportez à cette section s'appliquent à toutes les politiques du groupe de politiques concernées.
### Exemple 3 : personnalisation d'une politique spécifique
Si vous trouvez qu'une politique au sein d'un groupe de politiques concernées nécessite des modifications différentes des mises à jour suggérées, vous pouvez procéder comme suit :
+ Excluez des comptes spécifiques du script `identify_affected_policies.py`. Vous pouvez ensuite examiner ces comptes exclus séparément.
+ Mettez à jour les blocs `Sid` concernés en supprimant les politiques et les comptes concernés qui nécessitent des autorisations différentes. Créez un bloc JSON qui inclut uniquement les comptes spécifiques ou qui les exclut de l'exécution actuelle de politiques concernées mises à jour.
Lorsque vous réexécutez le script `identify_affected_policies.py`, seuls les comptes concernés apparaissent dans le bloc mis à jour. Vous pouvez ensuite affiner les suggestions de remplacement pour ce bloc spécifique `Sid`.
## Étape 5 : mise à jour des stratégies concernées
Après avoir examiné et affiné les suggestions de remplacement, exécutez le script `update_affected_policies.py`. Le script prend le fichier `affected_policies_and_suggestions.json` comme entrée. Ce script endosse le rôle IAM `BillingConsolePolicyMigratorRole` pour mettre à jour les stratégies concernées répertoriées dans le `affected_policies_and_suggestions.json` fichier.
**Pour mettre à jour les politiques concernées**
1. Si vous ne l'avez pas déjà fait, ouvrez une fenêtre de ligne de commande pour l' AWS CLI.
1. Saisissez la commande suivante pour exécuter le script `update_affected_policies.py`. Vous pouvez saisir le paramètre d'entrée suivant :
+ Le chemin de répertoire du fichier `affected_policies_and_suggestions.json` qui contient une liste des stratégies concernées à mettre à jour. Ce fichier est le résultat de l'étape précédente.
```
python3 update_affected_policies.py --affected-policies-directory Affected_Policies_
```
Le script `update_affected_policies.py` met à jour les stratégies concernées dans le fichier `affected_policies_and_suggestions.json` avec les nouvelles actions suggérées. Le script ajoute un `Sid` bloc aux politiques, identifié comme`BillingConsolePolicyMigrator#`, où *\$1* correspond à un compteur incrémentiel (par exemple, 1, 2, 3).
Par exemple, si plusieurs blocs `Sid` de la politique concernée utilisent d'anciennes actions, le script ajoute plusieurs blocs `Sid`, qui apparaissent comme `BillingConsolePolicyMigrator#`, en correspondance à chaque bloc `Sid`.
**Important**
Le script ne supprime pas les anciennes actions IAM des politiques et ne modifie pas les blocs `Sid` existants dans les politiques. Au lieu de cela, il crée des blocs `Sid` et les ajoute à la fin de la politique. Ces nouveaux blocs `Sid` contiennent les nouvelles actions suggérées dans le fichier JSON. Cela garantit que les autorisations des politiques d'origine ne sont pas modifiées.
Nous vous déconseillons de modifier le nom des blocs `Sid` `BillingConsolePolicyMigrator#` au cas où vous auriez besoin d'annuler vos modifications.
**Example Exemple : politique avec blocs `Sid` ajoutés**
Consultez les blocs `Sid` ajoutés dans les blocs `BillingConsolePolicyMigrator1` et `BillingConsolePolicyMigrator2`.
Le script génère un rapport d'état qui contient les opérations ayant échoué et génère le fichier JSON localement.
**Example Exemple : rapport d'état**
```
[{
"Account": "111111111111",
"PolicyType": "Customer Managed Policy"
"PolicyName": "AwsPortalViewPaymentMethods",
"PolicyIdentifier": "identifier",
"Status": "FAILURE", // FAILURE or SKIPPED
"ErrorMessage": "Error message details"
}]
```
**Important**
Si vous réexécutez les scripts `identify_affected_policies.py` et `update_affected_policies.py`, ils ignorent toutes les politiques contenant le bloc `Sid` `BillingConsolePolicyMigratorRole#`. Les scripts supposent que ces politiques ont déjà été analysées et mises à jour et qu'elles ne nécessitent aucune mise à jour supplémentaire. Cela empêche le script de dupliquer les mêmes actions dans la politique.
Après avoir mis à jour les stratégies concernées, vous pouvez utiliser le nouvel IAM à l'aide de l'outil des politiques concernées. Si vous identifiez des problèmes, vous pouvez utiliser l'outil pour revenir aux actions précédentes. Vous pouvez également utiliser un script pour annuler les mises à jour de votre politique.
Pour plus d'informations, consultez le billet [Comment utiliser l'outil relatif aux politiques concernées](migrate-security-iam-tool.md) de blog sur les [modifications apportées à la AWS facturation, à la gestion des coûts et aux autorisations des consoles de compte](https://aws.amazon.com/blogs/aws-cloud-financial-management/changes-to-aws-billing-cost-management-and-account-consoles-permissions/).
Pour gérer vos mises à jour, vous pouvez :
exécuter les scripts pour chaque compte individuellement ;
exécuter le script par lots pour des comptes similaires, tels que les comptes de test, d'assurance qualité et de production ;
exécuter le script pour tous les comptes ;
opter pour un mélange entre la mise à jour de certains comptes par lots et la mise à jour individuelle d'autres comptes.
## Étape 6 : annulation de vos modifications (Facultatif)
Le script `rollback_affected_policies.py` annule les modifications appliquées à chaque politique concernée pour les comptes spécifiés. Le script supprime tous les blocs `Sid` ajoutés par le script `update_affected_policies.py`. Ces blocs `Sid` ont le format `BillingConsolePolicyMigratorRole#`.
**Pour annuler vos modifications**
1. Si vous ne l'avez pas déjà fait, ouvrez une fenêtre de ligne de commande pour l' AWS CLI.
1. Saisissez la commande suivante pour exécuter le script `rollback_affected_policies.py`. Vous pouvez saisir les paramètres d'entrée suivants :
+ `--accounts`
+ Spécifie une liste séparée par des virgules des éléments Compte AWS IDs que vous souhaitez inclure dans le rollback.
+ L'exemple suivant analyse les politiques spécifiées Comptes AWS et supprime toutes les instructions associées au `BillingConsolePolicyMigrator#` `Sid` bloc.
```
python3 rollback_affected_policies.py –-accounts 111122223333, 555555555555, 666666666666
```
+ `--all`
+ Inclut tout Compte AWS IDs le personnel de votre organisation.
+ L'exemple suivant analyse toutes les politiques de votre organisation et supprime toutes les instructions contenant le bloc `Sid` `BillingConsolePolicyMigratorRole#`.
```
python3 rollback_affected_policies.py –-all
```
+ `--exclude-accounts`
+ Spécifie une liste séparée par des virgules des Compte AWS IDs éléments que vous souhaitez exclure de la restauration.
Vous ne pouvez utiliser ce paramètre que si vous spécifiez également le paramètre `--all`.
+ L'exemple suivant analyse les politiques de tous les Comptes AWS membres de votre organisation, à l'exception des comptes spécifiés.
```
python3 rollback_affected_policies.py --all --exclude-accounts 777777777777, 888888888888, 999999999999
```
## Exemples de politique IAM
Les politiques sont considérées comme similaires si leurs caractéristiques suivantes sont identiques :
+ Actions affectées sur tous les blocs `Sid`.
+ Détails dans les éléments IAM suivants :
+ `Effect` (`Allow`/`Deny`)
+ `Principal` (à qui l'accès est autorisé ou refusé)
+ `NotAction` (quelles sont les actions non autorisées)
+ `NotPrincipal` (à qui l'accès est explicitement refusé)
+ `Resource`(à quelles AWS ressources s'applique la politique)
+ `Condition` (toutes les conditions spécifiques en vertu desquelles la politique s'applique)
Les exemples suivants montrent des politiques qu'IAM pourrait ou non considérer comme similaires en fonction de leurs différences.
**Example Exemple 1 : les politiques sont considérées comme similaires**
Chaque type de politique est différent, mais les deux politiques contiennent un bloc `Sid` avec la même `Action` concernée.
****
```
{
"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 Exemple 2 : les politiques sont considérées comme similaires**
Les deux politiques contiennent un seul bloc `Sid` avec la même `Action` concernée. La politique 2 contient des actions supplémentaires, mais celles-ci ne sont pas affectées.
****
```
{
"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 Exemple 3 : les politiques ne sont pas considérées comme similaires**
Les deux politiques contiennent un seul bloc `Sid` avec la même `Action` concernée. Toutefois, la politique 2 contient un élément `Condition` qui n'est pas présent dans la politique 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 Exemple 4 : les politiques sont considérées comme similaires**
La politique 1 comporte un seul bloc `Sid` avec une `Action` concernée. La politique 2 comporte plusieurs blocs `Sid`, mais l'`Action` concernée n'apparaît que dans un seul bloc.
****
```
{
"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 Exemple 5 : les politiques ne sont pas considérées comme similaires**
La politique 1 comporte un seul bloc `Sid` avec une `Action` concernée. La politique 2 comporte plusieurs blocs `Sid` et l'`Action` concernée apparaît dans plusieurs blocs.
****
```
{
"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 Exemple 6 : les politiques sont considérées comme similaires**
Les deux politiques comportent plusieurs blocs `Sid`, avec la même `Action` concernée dans chaque bloc `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 Exemple 7**
Les deux politiques suivantes ne sont pas considérées comme similaires.
La politique 1 comporte un seul bloc `Sid` avec une `Action` concernée. La politique 2 comporte un bloc `Sid` avec la même `Action` concernée. Cependant, la politique 2 contient également un autre bloc `Sid` avec différentes actions.
****
```
{
"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": "*"
}
]
}
```