Contrôle des accès aux organisations avec IAM

Google Cloud propose Identity and Access Management (IAM), qui vous permet de définir de manière plus précise l'accès à des ressources spécifiques de Google Cloud et d'empêcher tout accès indésirable à d'autres ressources. IAM vous permet d'adopter le principe de sécurité du moindre privilège afin de n'accorder que l'accès nécessaire à vos ressources.

Grâce à l'IAM, vous pouvez contrôler qui (utilisateurs) a accès (rôles) à quelles ressources en définissant des stratégies IAM. Ces stratégies permettent d'attribuer un ou plusieurs rôles spécifiques à un utilisateur afin de lui accorder certaines autorisations.

Cette page décrit les rôles IAM disponibles au niveau de l'organisation, et explique comment créer et gérer des stratégies IAM pour les ressources d'organisation à l'aide de l'API Resource Manager. Pour une description détaillée d'IAM, consultez la documentation IAM. et en particulier la page Accorder, modifier et révoquer les accès à des ressources.

Autorisations et rôles

Pour contrôler l'accès aux ressources, Google Cloud exige que les comptes effectuant des requêtes API disposent de rôles IAM appropriés. Les rôles IAM incluent des autorisations permettant aux utilisateurs d'effectuer des actions spécifiques sur les ressources Google Cloud. Par exemple, l'autorisation resourcemanager.organizations.get permet à un utilisateur d'obtenir des informations sur la ressource de son organisation.

Vous n'accordez pas directement des autorisations aux utilisateurs, mais vous leur attribuez des rôles auxquels sont associées une ou plusieurs autorisations.

Vous pouvez attribuer un ou plusieurs rôles sur la même ressource.

Utiliser des rôles prédéfinis

Le tableau suivant répertorie les rôles que vous pouvez attribuer pour accéder aux propriétés d'une ressource d'organisation, la description de ce rôle et les autorisations associées.

Rôle Nom de rôle Description Autorisations
roles/resourcemanager.organizationAdmin Administrateur de l'organisation

Accorde un accès permettant de gérer les stratégies IAM et d'afficher les règles d'administration des organisations, des dossiers et des projets.

  • orgpolicy.constraints.list
  • orgpolicy.policies.list
  • orgpolicy.policy.get
  • resourcemanager.folders.get
  • resourcemanager.folders.getiamPolicy
  • resourcemanager.folders.list
  • resourcemanager.folders.setiamPolicy
  • resourcemanager.organizations.*
  • resourcemanager.projects.get
  • resourcemanager.projects.getIamPolicy
  • resourcemanager.projects.list
  • resourcemanager.projects.setiamPolicy
roles/resourcemanager.organizationViewer Lecteur d'organisation

Permet d'afficher une organisation.

  • resourcemanager.organizations.get
roles/orgpolicy.policyAdmin Administrateur des règles d'administration

Fournit un accès permettant de définir les restrictions qu'une organisation souhaite appliquer à la configuration des ressources cloud en définissant des règles d'administration.

  • orgpolicy.*
roles/browser Navigateur

Accès en lecture pour parcourir la hiérarchie d'un projet, y compris le dossier, l'organisation et la stratégie d'autorisation. Ce rôle ne donne pas l'autorisation d'afficher les ressources du projet.

  • resourcemanager.folders.get
  • resourcemanager.folders.list
  • resourcemanager.organizations.get
  • resourcemanager.projects.get
  • resourcemanager.projects.getIamPolicy
  • resourcemanager.projects.list

Créer des rôles personnalisés

En plus des rôles prédéfinis décrits dans cette rubrique, vous pouvez également créer des rôles personnalisés en fonction de vos besoins. Lorsque vous créez un rôle personnalisé à utiliser avec Resource Manager, tenez compte des points suivants :
  • Les autorisations de type obtenir/répertorier, telles que resourcemanager.projects.get/list, doivent toujours être accordées en tant que paire.
  • Lorsque votre rôle personnalisé inclut les autorisations folders.list et folders.get, il doit également inclure projects.list et projects.get.
  • Notez que l'autorisation setIamPolicy pour les ressources d'organisation, de dossier et de projet permet à l'utilisateur d'accorder toutes les autres autorisations. Vous devez donc l'attribuer avec précaution.

Afficher l'accès existant à une ressource d'organisation

Vous pouvez afficher les rôles attribués à un utilisateur pour une ressource d'organisation en obtenant une stratégie IAM au niveau de l'organisation. Vous pouvez afficher la règle d'une ressource d'organisation à l'aide de Google Cloud Console, de la CLI Google Cloud ou de la méthode getIamPolicy().

Console

Pour afficher les rôles attribués au niveau de l'organisation à l'aide de la console:

  1. Accédez à la page Gérer les ressources de la console:

    Accéder à la page "Gérer les ressources"

  2. Dans la liste déroulante Organisation, sélectionnez votre ressource d'organisation.

  3. Cochez la case correspondant à la ressource de l'organisation.

  4. Dans le Panneau d'informations situé à droite, sous Autorisations, cliquez pour développer un rôle et afficher tous les membres qui disposent de ce rôle.

gcloud

Obtenez la stratégie IAM pour la ressource d'organisation à l'aide de la commande get-iam-policy:

gcloud alpha organizations get-iam-policy [ORGANIZATION_ID] --format json >
[FILENAME.JSON]

La commande génère la stratégie, qui sera semblable à ce qui suit :

bindings:
- members:
- user:testuser1@gcp-test.com
role: roles/editor
- members:
- user:admin@gcp-test.com
role:roles/resourcemanager.organizationAdmin
- members:
- user:testuser2@gcp-test.com
role: roles/resourcemanager.projectCreator
etag": "BwU1aRxWk30="

API

L'extrait de code suivant renvoie la stratégie de la ressource d'organisation https://cloudresourcemanager.googleapis.com/v3/organizations/12345.

Requête :

POST
https://cloudresourcemanager.googleapis.com/v3/organizations/12345:getIamPolicy

Réponse :

{
    "bindings": [
    {
        "role": "roles/resourcemanager.organizationAdmin",
        "members": [
        "user:email1@gmail.com"
    ]
    },
    {
        "role": "roles/resourcemanager.projectCreator",
        "members": [
            "user:email2@gmail.com",
            "user:email3@gmail.com",
            "serviceAccount:my-other-app@appspot.gserviceaccount.com"
        ]
    }
    ]
    "etag": "BwUjHYKHHiQ="
}

Python

La méthode getIamPolicy() vous permet d'obtenir une stratégie précédemment définie.

crm = discovery.build(
    'cloudresourcemanager', 'v3', http=creds.authorize(httplib2.Http()))
policy = crm.organizations().getIamPolicy(
    resource=flags.organizationId, body={}).execute()
print json.dumps(policy, indent=2)

Accorder l'accès à une ressource d'organisation

Les administrateurs d'organisation peuvent attribuer des rôles IAM aux membres de l'équipe, afin qu'ils puissent accéder aux ressources et aux API d'une organisation. Vous pouvez attribuer des rôles à une adresse e-mail de compte Google, à un groupe Google, à un compte de service ou à un domaine G Suite. Vous pouvez attribuer des rôles à l'aide de la console, de la CLI gcloud ou de la méthode setIamPolicy().

Console

Pour définir le contrôle des accès au niveau de l'organisation à l'aide de la console:

  1. Accédez à la page Gérer les ressources de la console:

    Accéder à la page "Gérer les ressources"

  2. Dans la liste déroulante Organisation, sélectionnez votre ressource d'organisation.

  3. Cochez la case correspondant à la ressource de l'organisation. Si vous ne disposez pas d'une ressource "Dossier", la ressource d'organisation n'est pas visible. Pour continuer, consultez les instructions pour l'attribution de rôles sur la page IAM.

  4. Si le panneau d'informations de droite est masqué, cliquez sur Afficher le panneau d'informations en haut à droite.

  5. Dans le panneau d'informations, accédez à l'onglet Autorisations, puis cliquez sur Ajouter un membre.

  6. Dans le champ Nouveaux membres, saisissez les membres de l'équipe que vous souhaitez ajouter. Vous pouvez indiquer l'adresse e-mail d'un compte Google, un groupe Google, un compte de service ou un domaine G Suite.

  7. Dans la liste déroulante Sélectionner un rôle, sélectionnez le rôle que vous souhaitez attribuer aux membres indiqués.

  8. Cliquez sur Ajouter.

gcloud

Pour définir la stratégie IAM d'une ressource d'organisation à l'aide de la commande gcloud:

  1. Obtenez la stratégie IAM pour la ressource d'organisation à l'aide de la commande get-iam-policy et générez la stratégie dans un fichier JSON:

    gcloud alpha organizations get-iam-policy [ORGANIZATION_ID]
    --format json > [FILENAME.JSON]
    
  2. Le fichier JSON affiche un contenu similaire au texte ci-dessous :

    {
        "bindings": [
        {
            "members": [
                "user:testuser1@gcp-test.com"
            ],
            "role": "roles/editor"
        },
        {
            "members": [
                "user:admin@gcp-test.com",
            ],
            "role": "roles/resourcemanager.organizationAdmin"
        },
        {
            "members": [
                "user:testuser2@gcp-test.com"
            ],
            "role": "roles/resourcemanager.projectCreator"
        },
        ],
        "etag": "BwU1aRxWk30="
    }
    
  3. À l'aide d'un éditeur de texte, ouvrez le fichier JSON et ajoutez une nouvelle entrée au tableau de liaisons qui définit l'administrateur de l'organisation. Par exemple, pour faire de anotheradmin@gcp-test.com un administrateur de l'organisation, modifiez l'exemple ci-dessus comme suit:

    {
        "bindings": [
        {
            "members": [
                "user:testuser1@gcp-test.com"
            ],
            "role": "roles/editor"
        },
        {
            "members": [
                "user:admin@gcp-test.com",
                "user:anotheradmin@gcp-test.com"
            ],
            "role": "roles/resourcemanager.organizationAdmin"
        },
        {
            "members": [
                "user:testuser20@gcp-test.com"
            ],
            "role": "roles/resourcemanager.projectCreator"
        },
        ],
        "etag": "BwU1aRxWk30="
    }
    
  4. Pour mettre à jour la règle d'administration de la ressource d'organisation, exécutez la commande suivante:

    gcloud alpha organizations set-iam-policy [ORGANIZATION_ID] policy.json
    

API

Requête :

POST https://cloudresourcemanager.googleapis.com/v3/organizations/12345:setIamPolicy
{
    "policy": {
    "version": "0",
    "bindings": [
    {
        "role": "roles/resourcemanager.organizationAdmin",
        "members": [
            "user:email1@gmail.com"
        ]
    },
    {
        "role": "roles/resourcemanager.projectCreator",
        "members": [
        "user:email2@gmail.com",
        "user:email3@gmail.com",
        "serviceAccount:my-other-app@appspot.gserviceaccount.com"
        ]
    }
    ]
    "etag": "BwUjHYKHHiQ="
    }
}

Réponse :

{
    "bindings": [
    {
        "role": "roles/resourcemanager.organizationAdmin",
        "members": [
            "user:email1@gmail.com"
        ]
    },
    {
        "role": "roles/resourcemanager.projectCreator",
        "members": [
            "user:email2@gmail.com",
            "user:email3@gmail.com",
            "serviceAccount:my-other-app@appspot.gserviceaccount.com"
        ]
    }
    ]
    "etag": "BwUjHYKJUiQ="
}

La méthode setIamPolicy() vous permet d'attribuer des rôles aux utilisateurs en associant une stratégie IAM à la ressource d'organisation. La stratégie IAM est un ensemble d'énoncés qui définissent qui a accès à quoi.

Lecture-modification-écriture : un modèle courant de mise à jour des métadonnées d'une ressource, comme une stratégie, consiste à lire son état actuel, à mettre à jour les données localement, puis à envoyer les données modifiées en écriture. Ce modèle peut provoquer un conflit si deux processus indépendants ou plus tentent de réaliser la séquence simultanément. Prenons l'exemple de deux propriétaires d'un projet qui tentent d'apporter des modifications conflictuelles à une stratégie en même temps. Dans certains cas, les modifications apportées par l'un des propriétaires du projet pourraient ne pas être appliquées. IAM résout ce problème en utilisant une propriété etag dans des stratégies IAM. Cette propriété est utilisée pour vérifier si la stratégie a changé depuis la dernière requête. Quand vous adressez une requête à IAM avec une valeur etag, IAM compare la valeur etag de la requête à la valeur etag existante associée à la stratégie. Il écrit la stratégie uniquement si les valeurs ETag correspondent.

Lorsque vous mettez à jour une stratégie, commencez par obtenir la stratégie à l'aide de getIamPolicy(), mettez-la à jour, puis écrivez la stratégie mise à jour à l'aide de setIamPolicy(). Lors de la définition de cette stratégie, n'utilisez la valeur ETag que si la stratégie correspondante dans GetPolicyResponse contient une valeur ETag.

Python

La méthode setIamPolicy() vous permet d'associer une stratégie à une ressource. La méthode setIamPolicy accepte en entrée une requête SetIamPolicyRequest, qui contient une stratégie à définir et la ressource à laquelle cette stratégie doit être associée. Elle renvoie la stratégie qui en résulte. Il est recommandé de suivre le modèle lecture-modification-écriture lors de la mise à jour d'une stratégie à l'aide de setIamPolicy().

Voici un exemple de code permettant de définir une stratégie pour une ressource d'organisation:

crm = discovery.build(
    'cloudresourcemanager', 'v3', http=creds.authorize(httplib2.Http()))
policy = crm.organizations().getIamPolicy(
    resource=flags.organizationId, body={}).execute()

admin_binding = next(
    (binding
        for binding in policy['bindings']
        if binding['role'] == 'roles/resourcemanager.organizationAdmin'),
        None)

# Add an empty Organization Administrator binding if not present.
if not admin_binding:
    admin_binding = {
        'role': 'roles/resourcemanager.organizationAdmin',
        'members': []
    }
policy['bindings'].append(admin_binding)

# Add the new Admin (if necessary).
new_admin = 'user:' + flags.adminEmail
if new_admin not in admin_binding['members']:
    admin_binding['members'].append(new_admin)
policy = crm.organizations().setIamPolicy(
    resource=flags.organizationId,
    body={
        'resource': flags.organizationId,
        'policy': policy
    }).execute()

print json.dumps(policy, indent=2)

Restreindre la visibilité des projets pour les utilisateurs

Les utilisateurs peuvent voir tous les projets auxquels ils ont accès dans la console et dans les requêtes de recherche, qu'ils se trouvent ou non dans la ressource d'organisation actuellement sélectionnée. Vous pouvez utiliser le service de règles d'administration pour restreindre l'ensemble de projets renvoyés dans les requêtes et dans la console. Vous pouvez ainsi limiter l'accès des utilisateurs aux seuls projets de votre propre domaine.

La contrainte de règle d'administration constraints/resourcemanager.accessBoundaries est une contrainte de liste appliquée sur votre ressource d'organisation. La contrainte accepte une liste d'ID de ressources d'organisation, qui définissent l'ensemble de ressources d'organisation afin que leurs ressources soient visibles par les utilisateurs dans une requête ou dans la console.

Les projets apparaissent sous No organization si l'utilisateur ne dispose pas de l'autorisation resourcemanager.organizations.get sur la ressource d'organisation parente du projet. Vous pouvez ainsi sembler qu'un projet ne faisant pas partie de votre ressource "Organisation" n'est associé à aucune ressource "Organisation". Si vous utilisez la contrainte resourcemanager.accessBoundaries pour interdire une ressource d'organisation, les projets appartenant à cette ressource d'organisation n'apparaissent pas du tout dans les requêtes ni dans la console. Les projets qui n'ont pas encore été migrés vers une ressource d'organisation ne seront pas visibles si cette contrainte est appliquée.

Nous vous recommandons de migrer les projets inférieurs à No organization vers votre ressource d'organisation avant d'appliquer cette contrainte. Pour en savoir plus sur la migration de projets vers une ressource d'organisation, consultez la section Déplacer un projet.

Pour en savoir plus sur la définition d'une règle d'administration, consultez la page Utiliser des contraintes.

Tester les autorisations

Vous pouvez tester les autorisations IAM sur un utilisateur pour une ressource d'organisation à l'aide de la méthode testIamPermissions(). Cette méthode utilise l'URL de la ressource et l'ensemble des autorisations que vous souhaitez tester en tant que paramètres d'entrée. Elle renvoie le sous-ensemble de ces autorisations auquel l'utilisateur a accès.

En général, vous n'appelez pas testIamPermission() si vous utilisez directement la console pour gérer les autorisations. La méthode testIamPermissions() est destinée à être intégrée à votre logiciel propriétaire, comme une interface utilisateur graphique personnalisée. Par exemple, la console utilise testIamPermissions() en interne pour déterminer l'interface utilisateur qui doit être disponible pour l'utilisateur connecté.

API

Vous pouvez utiliser la méthode testIamPermissions() afin de vérifier les autorisations accordées à un appelant pour une ressource donnée. Cette méthode reçoit comme paramètres un nom de ressource et un ensemble d'autorisations, puis renvoie le sous-ensemble d'autorisations dont dispose l'appelant.

Voici un exemple de code pour tester les autorisations pour une ressource d'organisation:

Request:

POST https://cloudresourcemanager.googleapis.com/v3/organization/12345:testIamPermissions

{
    "permissions":  [
        "resourcemanager.organizations.get",
        "resourcemanager.organizations.setIamPolicy"
    ]
}

Response:

{
    "permissions": [
        "resourcemanager.organizations.get"
    ]
}

Python

crm = discovery.build(
    'cloudresourcemanager', 'v3', http=creds.authorize(httplib2.Http()))

response = crm.organizations().testIamPermissions(
    resource=flags.organizationId,
    body={
        'resource': flags.organizationId,
        'permissions': [
            'resourcemanager.organizations.setIamPolicy',
            'resourcemanager.projects.patch'
        ]
    }).execute()

print json.dumps(response, indent=2)