Identity and Access Management (IAM) vous permet de fournir un accès précis à des ressources Google Cloud spécifiques tout en empêchant tout accès indésirable à d'autres ressources. En appliquant le principe du moindre privilège, vous n'accordez que les autorisations nécessaires à vos charges de travail.
IAM contrôle qui (utilisateurs) a accès (rôles) à quelles ressources via des stratégies d'autorisation, qui lient des rôles spécifiques aux utilisateurs. Pour gérer l'accès dans votre hiérarchie de ressources, vous pouvez configurer des rôles IAM et des stratégies d'autorisation au niveau de l'organisation à l'aide de l'API Cloud Resource Manager. Vous pouvez également définir des stratégies de refus pour empêcher les comptes principaux d'utiliser des autorisations spécifiques. Pour en savoir plus, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.
Autorisations et rôles
Pour contrôler l'accès aux ressources, Google Cloud exige que les comptes qui effectuent des requêtes API disposent des rôles IAM appropriés. Les rôles IAM incluent des autorisations qui permettent aux utilisateurs d'effectuer des actions spécifiques sur les ressourcesGoogle Cloud . Par exemple, l'autorisation resourcemanager.organizations.get permet à un utilisateur d'obtenir des détails sur sa ressource d'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 chaque rôle et les autorisations associées à chacun d'entre eux.
| Rôle | Autorisations |
|---|---|
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. Ressources de niveau inférieur auxquelles vous pouvez attribuer ce rôle :
|
|
Lecteur de l'organisation( Permet d'afficher une organisation. Ressources de niveau inférieur auxquelles vous pouvez attribuer ce rôle :
|
|
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. Ressources de niveau inférieur auxquelles vous pouvez attribuer ce rôle :
|
|
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. Ressources de niveau inférieur auxquelles vous pouvez attribuer ce rôle :
|
|
Créer des rôles personnalisés
En plus des rôles prédéfinis décrits dans cet article, vous pouvez également créer des rôles personnalisés, qui sont des ensembles d'autorisations que vous adaptez à 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.listetfolders.get, il doit également inclureprojects.listetprojects.get. - Sachez que l'autorisation
setIamPolicypour les ressources d'organisation, de dossier et de projet permet à l'utilisateur d'accorder toutes les autres autorisations. Elle doit donc être attribuée avec précaution.
Afficher les accès existants pour une ressource d'organisation
Vous pouvez afficher les rôles attribués à un utilisateur pour une ressource d'organisation en obtenant la stratégie d'autorisation de cette ressource. Vous pouvez afficher la stratégie d'autorisation d'une ressource d'organisation à l'aide de la console Google Cloud , de Google Cloud CLI ou de la méthode getIamPolicy().
Console
Pour afficher les rôles attribués au niveau de la ressource d'organisation à l'aide de la console Google Cloud :
Accédez à la page Gérer les ressources dans la console Google Cloud :
Dans le menu déroulant Organisation, sélectionnez votre ressource d'organisation.
Cochez la case correspondant à la ressource d'organisation.
Dans le panneau d'informations, sous Autorisations, cliquez sur Développer un rôle pour afficher tous les membres qui disposent de ce rôle.
gcloud
Obtenez la stratégie d'autorisation de la ressource d'organisation à l'aide de la commande get-iam-policy :
gcloud organizations get-iam-policy \
ORGANIZATION_ID --format json > \
FILENAME.JSON
La commande génère la stratégie d'autorisation, qui ressemble à 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 d'autorisation pour 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 d'autorisation 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 de l'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 à l'adresse e-mail d'un compte utilisateur, à un groupe Google, à un compte de service ou à un domaine G Suite. Vous pouvez utiliser la console Google Cloud , la gcloud CLI ou la méthode setIamPolicy() pour attribuer des rôles.
Console
Pour définir le contrôle des accès au niveau de la ressource d'organisation à l'aide de la console Google Cloud :
Accédez à la page Gérer les ressources dans la console Google Cloud :
Dans le menu déroulant Organisation, sélectionnez votre ressource d'organisation.
Cochez la case correspondant à la ressource d'organisation. Si vous ne disposez pas d'une ressource de dossier, la ressource d'organisation n'est pas visible. Pour continuer, consultez les instructions pour l'attribution de rôles sur la page IAM.
Si le panneau d'informations de droite est masqué, cliquez sur Afficher le panneau d'informations en haut à droite.
Dans le panneau d'informations, dans l'onglet Autorisations, cliquez sur Ajouter un membre.
Dans le champ Nouveaux membres, saisissez les membres de l'équipe que vous souhaitez ajouter. Vous pouvez spécifier l'adresse e-mail d'un compte utilisateur, d'un groupe Google, d'un compte de service ou d'un domaine G Suite.
Dans le menu déroulant Sélectionner un rôle, sélectionnez le rôle que vous souhaitez attribuer aux membres de l'équipe.
Cliquez sur Ajouter.
gcloud
Pour définir la stratégie d'autorisation d'une ressource d'organisation à l'aide de la commande gcloud :
Obtenez la stratégie d'autorisation de la ressource d'organisation à l'aide de la commande
get-iam-policyet exportez-la dans un fichier JSON :gcloud organizations get-iam-policy \ ORGANIZATION_ID \ --format json > FILENAME.JSONLe contenu du fichier JSON ressemble à 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="
}
- Ouvrez le fichier JSON dans un éditeur de texte. Ensuite, ajoutez une entrée au tableau
bindingspour définir un administrateur de l'organisation. Par exemple, pour faire deanotheradmin@gcp-test.comun administrateur de l'organisation, modifiez l'exemple précédent 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="
}
- Mettez à jour la stratégie d'autorisation de la ressource d'organisation en exécutant la commande suivante :
gcloud 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 d'autorisation à la ressource d'organisation. La stratégie d'autorisation est un ensemble de liaisons qui définissent
Lecture-modification-écriture : un modèle courant de mise à jour des métadonnées d'une ressource, comme la stratégie d'autorisation, consiste à lire son état actuel, à mettre à jour les données localement, puis à envoyer les données modifiées pour écriture. Cette approche peut provoquer un conflit si deux processus indépendants ou plus tentent de réaliser ces opérations simultanément. Par exemple, si deux propriétaires de projet tentent d'apporter simultanément des modifications conflictuelles à la stratégie d'autorisation, les modifications de l'un d'eux peuvent échouer. IAM résout ce problème en utilisant une propriété etag dans les stratégies d'autorisation. Cette propriété vérifie si la stratégie d'autorisation a été modifiée depuis la dernière requête. Lorsque vous envoyez une requête avec une valeur etag, le système compare la valeur etag de la requête à la valeur etag existante associée à la stratégie. Il n'écrit la stratégie d'autorisation que si les valeurs etag correspondent.
Lorsque vous mettez à jour une stratégie d'autorisation, commencez par l'obtenir à l'aide de getIamPolicy(), mettez-la à jour, puis écrivez la stratégie d'autorisation mise à jour à l'aide de setIamPolicy(). Lorsque vous définissez la stratégie d'autorisation, n'utilisez la valeur etag que si la stratégie d'autorisation correspondante dans GetPolicyResponse contient une valeur etag.
Python
La méthode setIamPolicy() vous permet d'associer une stratégie d'autorisation à une ressource. La méthode setIamPolicy utilise un SetIamPolicyRequest, qui contient une stratégie d'autorisation à définir et la ressource à laquelle la stratégie d'autorisation est associée. Elle renvoie la stratégie d'autorisation obtenue. Nous vous recommandons de suivre le modèle lecture-modification-écriture lorsque vous mettez à jour une stratégie d'autorisation à l'aide de setIamPolicy().
Voici un exemple de code permettant de définir une stratégie d'autorisation 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)
Limiter la visibilité des projets pour les utilisateurs
Les utilisateurs peuvent voir tous les projets auxquels ils ont accès dans la console Google Cloud et dans les requêtes de recherche, qu'ils se trouvent ou non dans la ressource d'organisation sélectionnée par l'utilisateur. Vous pouvez utiliser le service de règles d'administration pour limiter l'ensemble des projets renvoyés dans les requêtes et dans la console Google Cloud . Cela vous permet de limiter l'accès des utilisateurs aux projets de votre domaine.
La contrainte de règle d'administration constraints/resourcemanager.accessBoundaries est une contrainte de liste appliquée à votre ressource d'organisation. La contrainte accepte une liste d'ID de ressources d'organisation, qui définissent l'ensemble des ressources d'organisation qui rendent leurs ressources visibles par les utilisateurs dans une requête ou dans la console Google Cloud .
Les projets s'affichent sous No organization si l'utilisateur ne dispose pas de l'autorisation resourcemanager.organizations.get sur la ressource d'organisation parente du projet. Un projet qui ne fait pas partie de votre ressource d'organisation peut alors sembler n'être associé à aucune ressource d'organisation.
Si vous utilisez la contrainte resourcemanager.accessBoundaries pour interdire une ressource d'organisation, les projets appartenant à cette ressource d'organisation n'apparaissent pas dans les requêtes ni dans la console Google Cloud . Les projets qui n'ont pas encore été migrés vers une ressource d'organisation ne sont pas visibles si vous appliquez cette contrainte.
Nous vous recommandons de migrer les projets qui se trouvent sous No organization vers votre ressource d'organisation avant d'appliquer cette contrainte. Pour en savoir plus sur le déplacement de projets vers une ressource d'organisation, consultez Déplacer un projet.
Pour en savoir plus sur la définition d'une règle d'administration, consultez Utiliser des contraintes.
Accorder un accès conditionnel
Certains rôles IAM, tels que l'administrateur des règles d'administration (roles/orgpolicy.policyAdmin), ne peuvent être attribués que sur une ressource d'organisation.
En raison de l'héritage des règles, toutes les ressources de l'organisation héritent normalement de ce rôle.
Pour mieux contrôler les ressources sur lesquelles le rôle est accordé, vous pouvez utiliser des conditions IAM. L'utilisation de tags avec des conditions vous permet d'accorder l'accès aux ressources uniquement si elles possèdent le tag spécifié. Par exemple, la stratégie d'autorisation suivante n'accorde le rôle d'administrateur des règles d'administration que sur les ressources associées au tag environment: dev, et ne l'accorde sur aucune autre ressource :
{
"bindings": [
{
"members": [
"{dynamic print variables.examples.principal_group_api}"
],
"role": "roles/orgpolicy.policyAdmin",
"condition": {
"title": "Dev_environment_only",
"description": "Only granted in the development environment",
"expression":
"resource.matchTag('123456789012/env', 'dev')"
}
}
],
"etag": "BwWKmjvelug=",
"version": 3
}
Tester les autorisations
Vous pouvez tester les autorisations IAM d'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 d'autorisations à tester. Elle renvoie le sous-ensemble de ces autorisations auquel l'utilisateur peut accéder.
En règle générale, vous n'appelez pas testIamPermissions() si vous utilisez directement la consoleGoogle Cloud pour gérer les autorisations. testIamPermissions() est destiné à être intégré à votre logiciel propriétaire, tel qu'une interface utilisateur graphique personnalisée. Par exemple, la console Google Cloud utilise testIamPermissions() en interne pour déterminer l'interface utilisateur 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 permettant de tester les autorisations pour une ressource d'organisation :
Request:
POST https://cloudresourcemanager.googleapis.com/v3/organizations/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)