Aller au contenu

AWS IAM Policy Generator: Politiques IAM, de bucket S3 et d’approbation au moindre privilège — en JSON ou Terraform.

S’exécute dans votre navigateur — rien de ce que vous collez ne quitte cette page. Comment nous le prouvons

Playground AWS IAM Policy Generator

Presets

s3:ListBucket acts on the bucket ARN and s3:GetObject on object ARNs (bucket/*), so they need separate resources — granting both on one ARN leaves one of them with no effect.

Policy type
Effect

Selected: s3:ListBucket

Filled from the AWS ARN format of each action's resource type until you edit it. Replace every ${…} placeholder.

Conditions (optional)

Results update as you type — press Enter to run now.

fig. 42 — aws-iam-policy-generator · security Valid policy, 248 of 6,144 characters, no warnings.
Result
Size248 / 6,144Customer managed policy, characters without whitespace
Errors0
Warnings0

Policy JSON

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListBucket",
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::example-bucket"
    },
    {
      "Sid": "ReadObjects",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::example-bucket/*"
    }
  ]
}

Action data: AWS Service Reference, retrieved 2026-10-04

Choisissez un service, les actions et les ressources sur lesquelles elles agissent, ajoutez des conditions et obtenez une politique d’identité IAM, une politique de bucket S3 ou une politique d’approbation de rôle valide, en JSON et en aws_iam_policy_document Terraform — avec une taille vérifiée par rapport au quota AWS et un avertissement sur chaque caractère générique, le tout calculé dans votre navigateur, sans inscription.

Le fossé

"Action" : "*" fonctionne. C’est bien le problème.

AWS évalue trois types de politiques que vous écrirez à la main. Une politique d’identité est attachée à un utilisateur, un groupe ou un rôle et dit ce que ce principal peut faire, elle n’a donc pas d’élément Principal. Une politique basée sur les ressources — politique de bucket S3, politique de clé KMS, politique de file SQS — est attachée à la ressource et doit nommer dans Principal à qui elle s’applique. Une politique d’approbation (trust policy) est la politique basée sur les ressources d’un rôle : elle décide qui peut assumer le rôle, généralement avec sts:AssumeRole ou, pour GitHub Actions et les autres fournisseurs OIDC, avec sts:AssumeRoleWithWebIdentity.

Le moindre privilège consiste à n’accorder que les actions qu’une charge de travail appelle, et seulement sur les ressources qu’elle touche. Une politique à caractères génériques passe tous les tests et échoue à l’audit : les requêtes sont refusées par défaut, un Deny explicite l’emporte sur tout Allow, et tout ce qu’une politique autorise, un identifiant divulgué peut le faire. Restreindre est délicat parce que les actions agissent sur des types de ressources différents — s3:ListBucket sur l’ARN du bucket, s3:GetObject sur bucket/*.

Les politiques ont aussi des limites de taille, comptées sans les espaces : 6 144 caractères pour une politique gérée par le client ; pour les politiques intégrées, 2 048 caractères au total par utilisateur, 5 120 par groupe et 10 240 par rôle ; et 20 Ko pour une politique de bucket S3. Une politique qui a grossi déclaration après déclaration échoue au déploiement, pas en revue.

Le générateur vérifie la grammaire, les quotas et les excès de droits courants ; il ne simule pas l’évaluation par AWS. Confirmez l’accès effectif avec IAM Access Analyzer ou le simulateur de politiques IAM avant la production.

Le pipeline

Comment ça marche.

Quatre étapes déterministes s’exécutent à chaque changement — toutes dans l’onglet de votre navigateur, avec des données d’actions issues de l’AWS Service Reference.

  1. Choisissez les actions.

    Choisissez un service et filtrez ses actions par niveau d’accès — List, Read, Write, Permissions management, Tagging. La liste des actions provient de l’AWS Service Reference et est livrée avec la page.

  2. Restreignez les ressources.

    Chaque action indique les types de ressources sur lesquels elle agit ; le format d’ARN de ce type est prérempli, vous remplacez des espaces réservés au lieu de taper des ARN de mémoire.

  3. Assemblez et vérifiez.

    Les déclarations forment un document en Version 2012-10-17. Les Sid doivent être alphanumériques et uniques, une politique de bucket exige un Principal et une politique d’identité ne doit pas en avoir, et chaque opérateur de condition est contrôlé.

  4. Mesurez et avertissez.

    La politique minifiée est mesurée par rapport au quota choisi, et les actions génériques, Resource "*" sur des actions d’écriture, les actions de gestion des autorisations et un Principal "*" sans condition sont signalés. Rien ne quitte l’onglet.

Référence des politiques

Un bucket, lecture seule, deux formats.

Le premier preset tel que le panneau le génère : les deux mêmes déclarations en JSON de politique et en source de données Terraform.

Politique d’identité en JSON

s3:ListBucket agit sur le bucket et s3:GetObject sur ses objets, chaque déclaration porte donc son propre ARN. Minifiée, elle occupe 248 des 6 144 caractères qu’autorise une politique gérée.

fig. 42.1 — s3-read-only.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListBucket",
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::example-bucket"
    },
    {
      "Sid": "ReadObjects",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::example-bucket/*"
    }
  ]
}

La même politique en Terraform

Passez data.aws_iam_policy_document.policy.json à une ressource aws_iam_policy ou aws_iam_role_policy.

fig. 42.2 — s3-read-only.tf
data "aws_iam_policy_document" "policy" {
  statement {
    sid       = "ListBucket"
    effect    = "Allow"
    actions   = ["s3:ListBucket"]
    resources = ["arn:aws:s3:::example-bucket"]
  }
  statement {
    sid       = "ReadObjects"
    effect    = "Allow"
    actions   = ["s3:GetObject"]
    resources = ["arn:aws:s3:::example-bucket/*"]
  }
}

Étape suivante

Vous déployez depuis GitHub Actions ? Abandonnez les clés d’accès.

Une politique d’approbation OIDC permet à un workflow d’assumer un rôle avec des identifiants de courte durée, limité à un dépôt et une branche. Le guide (en anglais) couvre le fournisseur d’identité, la politique d’approbation, configure-aws-credentials et la même configuration en Terraform.

trust-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::123456789012:oidc-provider/token.actions.githubusercontent.com"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "token.actions.githubusercontent.com:aud": "sts.amazonaws.com"
        },
        "StringLike": {
          "token.actions.githubusercontent.com:sub": "repo:my-org/my-repo:ref:refs/heads/main"
        }
      }
    }
  ]
}

FAQ

Vos questions, nos réponses.

Appuyez sur une question pour afficher la réponse.

Une politique IAM est un document JSON qui indique quelles actions sont autorisées ou refusées sur quelles ressources, éventuellement sous conditions. Une politique basée sur l'identité est attachée à un utilisateur, un groupe ou un rôle et accorde ses autorisations à cette identité : elle n'a donc pas d'élément Principal. Une politique basée sur les ressources est attachée à la ressource elle-même — un compartiment S3, une file SQS, une clé KMS — et doit nommer le Principal auquel elle s'applique. Quand les deux s'appliquent à une requête dans le même compte, AWS les combine, et un Deny explicite dans l'une ou l'autre l'emporte toujours.

L'élément Principal. Une politique IAM est attachée à un utilisateur, un groupe ou un rôle : le principal est implicite et l'élément n'est pas autorisé. Une politique de compartiment est attachée au compartiment : chaque instruction doit donc dire à qui elle s'applique — un autre compte, l'ARN d'un rôle, un service comme cloudfront.amazonaws.com ou "*" pour tout le monde. Le générateur l'impose dans les deux sens : il exige un Principal en mode compartiment, le refuse en mode identité, et avertit quand une instruction de compartiment accorde Principal "*" sans Condition.

N'accordez que les actions que la charge de travail appelle réellement, et uniquement sur les ressources qu'elle touche : des actions précises plutôt que s3:* ou *, de vrais ARN dans Resource plutôt que "*". Ajoutez des conditions là où elles restreignent davantage l'accès, par exemple aws:SourceVpce, aws:PrincipalOrgID ou une balise de ressource. Faites ensuite vérifier le résultat par AWS : IAM Access Analyzer valide une politique au regard des bonnes pratiques AWS et peut générer une politique à partir des actions qu'un rôle a réellement utilisées, d'après son historique CloudTrail. Le générateur signale les actions génériques, Resource "*" sur les actions d'écriture et de gestion des autorisations, et Allow avec NotAction.

Une politique gérée par le client compte au plus 6 144 caractères. Les politiques en ligne sont limitées par identité, en cumulant toutes les politiques en ligne qui y sont attachées : 2 048 caractères pour un utilisateur, 10 240 pour un rôle et 5 120 pour un groupe. IAM ne compte pas les espaces blancs dans ces limites, c'est pourquoi la jauge de taille mesure le JSON minifié. Une politique de compartiment S3 a sa propre limite de 20 Ko, et aucune de ces limites de caractères ne peut être relevée par une demande de quota.

L'onglet Terraform écrit les mêmes instructions sous forme de bloc data "aws_iam_policy_document", que Terraform convertit en JSON au moment du plan. Référencez son attribut json partout où une politique est attendue : policy = data.aws_iam_policy_document.example.json dans une aws_iam_policy pour une politique gérée, dans une aws_iam_role_policy pour une politique en ligne de rôle, ou dans une aws_s3_bucket_policy pour une politique de compartiment. Si vous préférez garder le JSON brut, jsonencode() ou un heredoc conviennent aussi, mais la source de données garde la politique en HCL, où les diffs restent lisibles.

De l'AWS Service Reference, les fichiers JSON lisibles par machine qu'AWS publie pour chaque service avec ses actions, types de ressources et clés de condition. La page indique la date de récupération des données, et la liste couvre 12 services courants : S3, EC2, Lambda, DynamoDB, IAM, CloudWatch Logs, SQS, SNS, KMS, STS, Secrets Manager et ECR. Chaque action porte son niveau d'accès — Read, List, Write, Permissions management ou Tagging — et les types de ressources auxquels elle peut être restreinte, ce qui alimente les modèles d'ARN et les avertissements. Pour tout autre service, la liste de référence est la Service Authorization Reference de la documentation AWS.

Une politique d'approbation est la politique basée sur les ressources attachée à un rôle IAM qui indique qui peut l'assumer ; les politiques d'autorisation du rôle disent ensuite ce que ce principal peut faire une fois le rôle assumé. Pour GitHub Actions avec OIDC, la politique d'approbation autorise sts:AssumeRoleWithWebIdentity pour le principal fédéré token.actions.githubusercontent.com, avec des conditions qui exigent que la revendication aud soit égale à sts.amazonaws.com et que la revendication sub corresponde à votre dépôt, par exemple repo:my-org/my-repo:ref:refs/heads/main — ou, pour les dépôts créés après le 15 juillet 2026, la forme immuable repo:my-org@<owner-id>/my-repo@<repo-id>:ref:refs/heads/main. Sans la condition sur sub, n'importe quel dépôt GitHub pourrait assumer le rôle. La politique d'approbation d'un rôle est limitée par défaut à 2 048 caractères, ajustable jusqu'à 8 192.

Non. Le générateur s'exécute à 100 % côté client : le catalogue d'actions est livré avec la page et chaque politique est construite dans l'onglet de votre navigateur. Rien n'est envoyé à un serveur, il n'y a ni compte ni inscription, et le lien de partage encode votre politique dans le fragment de l'URL, que les navigateurs n'envoient jamais à un serveur.

More free, private DevOps tools.

L’AWS IAM Policy Generator est l’un des outils de OpsCanopy — une canopée grandissante de validateurs, convertisseurs et testeurs dans le navigateur qui ne touchent jamais un serveur.

Vous débutez avec AWS ?  Lire le guide AWS →

42 outils gratuits, tous utilisables hors ligne — opscanopy.com fonctionne sans inscription et sans rien téléverser.

Pour sécuriser un pipeline : le JWT Decoder et le Certificate Decoder, ou parcourez le répertoire des outils.

Le générateur vérifie la structure, les quotas et les excès de droits courants, mais n’évalue ni les SCP, ni les limites d’autorisations, ni les politiques de session — testez avec IAM Access Analyzer avant de déployer. OpsCanopy est gratuit et ouvert.