AWS IAM

Service de gestion des identités et des accès qui permet de contrôler de manière sécurisée qui est authentifié et autorisé à utiliser les ressources AWS.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce que AWS IAM ?

Imaginez AWS comme un immense immeuble de bureaux contenant des ressources précieuses (serveurs, bases de données, stockage, etc.). Dans ce contexte, AWS IAM (Identity and Access Management) est à la fois le système de sécurité, les badges d'accès et le gardien qui contrôle qui peut entrer dans l'immeuble et ce qu'ils sont autorisés à faire.

En termes simples, IAM est le service qui vous permet de définir qui peut faire quoi sur votre compte AWS. C'est la pierre angulaire de la sécurité de votre infrastructure cloud.

Comment fonctionne IAM ?

Identités

IAM vous permet de créer des utilisateurs (personnes), des groupes (équipes) et des rôles (fonctions temporaires), puis de gérer leurs accès de façon centralisée.

Permissions

Avec IAM, vous contrôlez exactement ce que chaque utilisateur peut faire - comme accéder à certaines données ou lancer des serveurs, mais pas les supprimer.

En résumé, IAM est comme le système de sécurité complet de votre entreprise cloud : il vérifie les identités (authentification) et détermine ce que ces identités sont autorisées à faire (autorisation). Cette approche permet de sécuriser vos ressources en appliquant le principe du "moindre privilège" - donner aux utilisateurs uniquement les accès dont ils ont besoin pour faire leur travail, pas plus.

Pour les développeurs

Fonctionnement technique

AWS IAM est un service fondamental qui fournit un contrôle d'accès granulaire sur les ressources AWS, avec une forte intégration à tous les services AWS. Comprendre IAM est essentiel pour sécuriser correctement votre infrastructure cloud.

Composants fondamentaux

Utilisateurs IAM

Les utilisateurs IAM sont des identités individuelles créées au sein de votre compte AWS, représentant généralement des personnes ou des applications.

Informations d'identification à long terme : nom d'utilisateur et mot de passe pour la console AWS
Clés d'accès : ID de clé d'accès et clé d'accès secrète pour les appels programmatiques API
Authentification multi-facteur (MFA) possible pour une sécurité renforcée
Permissions : définies par les politiques IAM attachées
ARN : Identification unique au format arn:aws:iam::account-id:user/username

Groupes IAM

Les groupes IAM sont des collections d'utilisateurs IAM qui permettent de gérer plus facilement les permissions pour plusieurs utilisateurs.

Organisation logique basée sur les fonctions ou les équipes
Gestion simplifiée des permissions - attachez une politique à un groupe au lieu de plusieurs utilisateurs
Appartenance multiple : un utilisateur peut appartenir à plusieurs groupes
Limites : un groupe ne peut pas être membre d'un autre groupe
Portée : les groupes existent uniquement dans le compte AWS où ils sont créés

Rôles IAM

Les rôles IAM sont des identités destinées à être assumées par des personnes, des applications ou des services qui n'ont pas normalement accès à vos ressources AWS.

Informations d'identification temporaires : contrairement aux utilisateurs, pas d'identifiants à long terme
Délégation d'accès : permet d'accorder des accès sans partager de clés d'accès
Politique d'approbation : définit qui peut assumer le rôle
Politiques de permission : définissent les actions que le rôle peut exécuter
Idéal pour : accès cross-account, services AWS, applications web, authentification fédérée

Politiques IAM

Les politiques IAM sont des documents JSON qui définissent les permissions qui s'appliquent aux identités ou ressources auxquelles elles sont attachées.

Politiques basées sur l'identité : attachées aux utilisateurs, groupes ou rôles
Politiques basées sur les ressources : attachées directement à des ressources
Politiques AWS gérées : créées et gérées par AWS pour des cas d'usage courants
Politiques gérées par le client : créées et gérées par vous
Politiques en ligne : intégrées directement dans un utilisateur, groupe ou rôle
Boundaries de permissions : définit les permissions maximales qu'une entité peut avoir

Structure des politiques

Une politique IAM est un document JSON avec une structure formalisée qui suit une syntaxe spécifique.

Version : version de la syntaxe de la politique (généralement "2012-10-17")
Statement : tableau d'instructions qui définissent les permissions
Sid (facultatif) : identifiant de l'instruction
Effect : "Allow" ou "Deny" pour autoriser ou refuser des actions
Action : liste des actions autorisées ou refusées
Resource : liste des ressources sur lesquelles les actions s'appliquent
Condition (facultatif) : conditions qui limitent quand la politique s'applique

Implémentation technique

Voyons maintenant comment mettre en œuvre IAM dans différents scénarios avec des exemples de code.

1. Création d'un utilisateur IAM

Comment créer un utilisateur IAM et lui attacher une politique standard :

Création d'un utilisateur IAM

// Création d'un utilisateur IAM avec SDK AWS v3
const { IAMClient, CreateUserCommand, AttachUserPolicyCommand } = require("@aws-sdk/client-iam");

const client = new IAMClient({ region: "us-east-1" });

async function createIAMUser(username) {
  try {
    // 1. Créer l'utilisateur
    const createCommand = new CreateUserCommand({
      UserName: username,
      Tags: [
        {
          Key: "Department",
          Value: "Development"
        },
        {
          Key: "Environment",
          Value: "Production"
        }
      ]
    });
    
    const createResponse = await client.send(createCommand);
    console.log("Utilisateur IAM créé avec succès:", createResponse);
    
    // 2. Attacher une politique à l'utilisateur
    const attachCommand = new AttachUserPolicyCommand({
      UserName: username,
      PolicyArn: "arn:aws:iam::aws:policy/ReadOnlyAccess" // Politique AWS gérée pour l'accès en lecture seule
    });
    
    const attachResponse = await client.send(attachCommand);
    console.log("Politique attachée avec succès:", attachResponse);
    
    return createResponse;
  } catch (error) {
    console.error("Erreur lors de la création de l'utilisateur IAM:", error);
    throw error;
  }
}

// Appel de la fonction
createIAMUser("nouveau-developpeur");

2. Création d'un rôle IAM pour Lambda

Configuration d'un rôle pour permettre à Lambda d'accéder à d'autres services AWS :

Création d'un rôle IAM pour Lambda

// Création d'un rôle IAM pour services AWS avec SDK AWS v3
const { IAMClient, CreateRoleCommand, AttachRolePolicyCommand } = require("@aws-sdk/client-iam");

const client = new IAMClient({ region: "us-east-1" });

async function createLambdaExecutionRole(roleName) {
  try {
    // Document de politique d'approbation pour permettre à Lambda d'assumer ce rôle
    const trustRelationship = {
      Version: "2012-10-17",
      Statement: [
        {
          Effect: "Allow",
          Principal: {
            Service: "lambda.amazonaws.com"
          },
          Action: "sts:AssumeRole"
        }
      ]
    };
    
    // 1. Créer le rôle
    const createCommand = new CreateRoleCommand({
      RoleName: roleName,
      AssumeRolePolicyDocument: JSON.stringify(trustRelationship),
      Description: "Rôle d'exécution pour fonctions Lambda",
      MaxSessionDuration: 3600, // Durée en secondes (1 heure)
      Tags: [
        {
          Key: "Purpose",
          Value: "LambdaExecution"
        }
      ]
    });
    
    const createResponse = await client.send(createCommand);
    console.log("Rôle IAM créé avec succès:", createResponse);
    
    // 2. Attacher les politiques nécessaires
    const basicExecutionPolicy = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole";
    const attachCommand = new AttachRolePolicyCommand({
      RoleName: roleName,
      PolicyArn: basicExecutionPolicy
    });
    
    const attachResponse = await client.send(attachCommand);
    console.log("Politique attachée avec succès:", attachResponse);
    
    return createResponse;
  } catch (error) {
    console.error("Erreur lors de la création du rôle IAM:", error);
    throw error;
  }
}

// Appel de la fonction
createLambdaExecutionRole("lambda-processing-role");

3. Création d'une politique personnalisée

Définition d'une politique IAM personnalisée avec des permissions spécifiques pour S3 :

Création d'une politique IAM personnalisée

// Création d'une politique IAM personnalisée avec SDK AWS v3
const { IAMClient, CreatePolicyCommand } = require("@aws-sdk/client-iam");

const client = new IAMClient({ region: "us-east-1" });

async function createCustomPolicy(policyName, bucketName) {
  try {
    // Définition du document de politique qui autorise des actions spécifiques sur un bucket S3
    const policyDocument = {
      Version: "2012-10-17",
      Statement: [
        {
          Sid: "AllowS3BucketAccess",
          Effect: "Allow",
          Action: [
            "s3:GetObject",
            "s3:PutObject",
            "s3:ListBucket"
          ],
          Resource: [
            `arn:aws:s3:::${bucketName}`,
            `arn:aws:s3:::${bucketName}/*`
          ]
        },
        {
          Sid: "AllowS3ListAllBuckets",
          Effect: "Allow",
          Action: "s3:ListAllMyBuckets",
          Resource: "*"
        },
        {
          Sid: "DenyDeleteOperations",
          Effect: "Deny",
          Action: [
            "s3:DeleteObject",
            "s3:DeleteBucket"
          ],
          Resource: [
            `arn:aws:s3:::${bucketName}`,
            `arn:aws:s3:::${bucketName}/*`
          ]
        }
      ]
    };
    
    const command = new CreatePolicyCommand({
      PolicyName: policyName,
      PolicyDocument: JSON.stringify(policyDocument),
      Description: `Politique personnalisée pour l'accès au bucket S3 ${bucketName}`
    });
    
    const response = await client.send(command);
    console.log("Politique IAM personnalisée créée avec succès:", response);
    return response;
  } catch (error) {
    console.error("Erreur lors de la création de la politique IAM:", error);
    throw error;
  }
}

// Appel de la fonction
createCustomPolicy("s3-app-data-access-policy", "app-data-bucket-prod");

4. Configuration IAM complète avec AWS CDK

Exemple d'infrastructure qui met en place des utilisateurs, groupes, rôles et politiques avec CDK :

Configuration IAM avec AWS CDK

// Configuration IAM avec AWS CDK (TypeScript)
import * as cdk from 'aws-cdk-lib';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';

export class SecureDataProcessingStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Création d'un bucket S3 pour les données
    const dataBucket = new s3.Bucket(this, 'DataBucket', {
      bucketName: 'secure-data-processing-bucket',
      encryption: s3.BucketEncryption.S3_MANAGED,
      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
      versioned: true,
      enforceSSL: true
    });

    // Création d'un groupe IAM pour les data scientists
    const dataScientistGroup = new iam.Group(this, 'DataScientistGroup', {
      groupName: 'data-scientists'
    });

    // Création d'une politique personnalisée pour l'accès au bucket
    const bucketAccessPolicy = new iam.ManagedPolicy(this, 'BucketAccessPolicy', {
      managedPolicyName: 'data-scientist-bucket-access',
      description: 'Accès limité au bucket de données pour les data scientists',
      statements: [
        new iam.PolicyStatement({
          effect: iam.Effect.ALLOW,
          actions: [
            's3:GetObject',
            's3:PutObject',
            's3:ListBucket'
          ],
          resources: [
            dataBucket.bucketArn,
            `${dataBucket.bucketArn}/*`
          ],
          conditions: {
            'StringEquals': {
              's3:x-amz-server-side-encryption': 'AES256'
            }
          }
        }),
        new iam.PolicyStatement({
          effect: iam.Effect.DENY,
          actions: [
            's3:DeleteObject',
            's3:DeleteBucket'
          ],
          resources: [
            dataBucket.bucketArn,
            `${dataBucket.bucketArn}/*`
          ]
        })
      ]
    });

    // Attacher la politique au groupe
    dataScientistGroup.addManagedPolicy(bucketAccessPolicy);

    // Création d'un rôle IAM pour une fonction Lambda
    const lambdaRole = new iam.Role(this, 'DataProcessingRole', {
      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
      description: 'Rôle pour la fonction Lambda de traitement de données',
      managedPolicies: [
        iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')
      ]
    });

    // Ajouter des permissions supplémentaires au rôle Lambda
    lambdaRole.addToPolicy(
      new iam.PolicyStatement({
        effect: iam.Effect.ALLOW,
        actions: [
          's3:GetObject',
          's3:PutObject'
        ],
        resources: [`${dataBucket.bucketArn}/processed/*`]
      })
    );

    // Créer un utilisateur avec accès limité
    const analyticsUser = new iam.User(this, 'AnalyticsUser', {
      userName: 'analytics-user',
      managedPolicies: [
        iam.ManagedPolicy.fromAwsManagedPolicyName('ReadOnlyAccess')
      ]
    });

    // Définir une politique de mot de passe personnalisée pour le compte AWS
    const passwordPolicy = new iam.CfnAccountPasswordPolicy(this, 'PasswordPolicy', {
      minimalAllowedPasswordLength: 12,
      requireLowercaseCharacters: true,
      requireNumbers: true,
      requireSymbols: true,
      requireUppercaseCharacters: true,
      passwordReusePrevention: 24,
      maxPasswordAge: 90
    });

    // Sorties utiles
    new cdk.CfnOutput(this, 'DataBucketName', {
      value: dataBucket.bucketName
    });
    
    new cdk.CfnOutput(this, 'DataScientistGroupName', {
      value: dataScientistGroup.groupName
    });
    
    new cdk.CfnOutput(this, 'LambdaRoleArn', {
      value: lambdaRole.roleArn
    });
  }
}

5. Conditions IAM avancées

Exemples de conditions complexes pour contrôler l'accès de manière précise :

Conditions IAM avancées

// Exemples de conditions IAM avancées
// Politique qui autorise des actions S3 uniquement depuis une plage d'adresses IP spécifique
const ipRestrictedS3Policy = {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowS3AccessFromCorporateIP",
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::entreprise-app-bucket",
        "arn:aws:s3:::entreprise-app-bucket/*"
      ],
      "Condition": {
        "IpAddress": {
          "aws:SourceIp": [
            "203.0.113.0/24",
            "198.51.100.0/24"
          ]
        }
      }
    }
  ]
};

// Politique qui n'autorise les actions qu'avec l'authentification MFA
const mfaRequiredPolicy = {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowActionsWithMFAOnly",
      "Effect": "Allow",
      "Action": [
        "ec2:StopInstances",
        "ec2:TerminateInstances",
        "rds:StopDBInstance"
      ],
      "Resource": "*",
      "Condition": {
        "Bool": {
          "aws:MultiFactorAuthPresent": "true"
        }
      }
    }
  ]
};

// Politique qui restreint l'accès en fonction des tags de ressource
const tagBasedPolicy = {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowActionsOnTaggedResources",
      "Effect": "Allow",
      "Action": [
        "ec2:StartInstances",
        "ec2:StopInstances",
        "ec2:RebootInstances"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/Department": "Development",
          "aws:ResourceTag/Environment": "Test"
        }
      }
    }
  ]
};

// Politique qui limite l'accès en fonction de l'heure de la journée
const timeWindowPolicy = {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowActionsOnlyDuringBusinessHours",
      "Effect": "Allow",
      "Action": "dynamodb:*",
      "Resource": "*",
      "Condition": {
        "DateGreaterThan": {
          "aws:CurrentTime": "2023-01-01T08:00:00Z"
        },
        "DateLessThan": {
          "aws:CurrentTime": "2023-01-01T18:00:00Z"
        },
        "Bool": {
          "aws:ViaAWSService": "false"
        }
      }
    }
  ]
};

Bonnes pratiques de sécurité

Privilège minimum : Accordez uniquement les permissions nécessaires pour accomplir une tâche
Utilisation limitée de l'utilisateur root : Réservez-le aux tâches qui le nécessitent explicitement
Exigez l'authentification MFA pour tous les utilisateurs humains
Rotation régulière des clés d'accès : Changez les clés au moins tous les 90 jours
Utilisation des rôles pour les applications plutôt que des identifiants à long terme
Définition de politiques de mot de passe fortes pour le compte
Audit régulier des permissions avec IAM Access Analyzer
Organisation des utilisateurs en groupes pour une gestion simplifiée
Documentation des politiques avec des commentaires et des identifiants clairs
Implémentation de barrières de sécurité avec les boundaries de permission

Applications concrètes

Cas d'usage

Gestion d'équipes dans une entreprise

Structuration des accès AWS pour différentes équipes (développement, test, production) avec des niveaux d'accès appropriés pour chacune. Les développeurs peuvent avoir un accès complet aux environnements de développement mais un accès en lecture seule aux environnements de production.

Architecture multi-comptes

Mise en place d'une organisation AWS avec des comptes séparés pour différentes charges de travail (dev, test, prod) ou unités commerciales. Les rôles IAM permettent l'accès entre ces comptes tout en maintenant une séparation claire des ressources et des responsabilités.

Authentification d'applications

Pour les applications déployées sur AWS (EC2, Lambda, ECS), les rôles IAM fournissent un moyen sécurisé d'accéder aux services AWS sans stocker de clés d'accès dans le code. L'application assume automatiquement un rôle qui lui donne uniquement les permissions nécessaires.

Fédération d'identité

Intégration avec des fournisseurs d'identité externes comme Active Directory, Okta ou Google pour permettre aux utilisateurs de se connecter à AWS avec leurs identifiants d'entreprise existants, sans avoir à créer des utilisateurs IAM distincts.

Intégration avec d'autres services AWS

IAM s'intègre avec pratiquement tous les services AWS. Voici quelques intégrations particulièrement importantes :

AWS Organizations

Permet la gestion centralisée des politiques IAM à travers plusieurs comptes AWS avec les Service Control Policies (SCPs).

AWS CloudTrail

Enregistre toutes les actions des utilisateurs, rôles et services IAM pour l'audit et la conformité.

AWS Security Hub

Surveille et évalue les bonnes pratiques de sécurité IAM, signalant les configurations à risque.

AWS Resource Access Manager

Permet de partager des ressources AWS entre comptes avec des contrôles d'accès IAM.

Ressources complémentaires

Toutes les compétences

Technologies associées

Lambda

EC2

S3

CloudFormation

Cognito

Explorer toutes mes compétences