Accorder aux utilisateurs l'accès aux ressources de balises et aux ID de service

En tant que propriétaire du compte, vous pouvez déléguer une partie de la responsabilité du marquage des ressources et des identifiants de service. Pour que les utilisateurs puissent attacher des balises à une ressource ou à un identifiant de service, vous devez leur accorder l'accès approprié. Utilisez des règles d'accès IBM Cloud® IAM (Identity and Access Management) pour affecter aux utilisateurs l'accès aux ressources d'un groupe de ressources.

Les balises sont visibles à l'échelle du compte et peuvent être répliquées dans les régions géographiques. Les balises n'étant pas des renseignements réglementés, évitez de créer des balises qui utilisent des renseignements personnels, comme votre nom, votre adresse, votre numéro de téléphone, votre adresse électronique ou tout autre renseignement d'identification ou de propriété.

Droits d'étiquetage

Tout utilisateur d'un compte peut afficher les étiquettes. Lorsqu'une ressource est étiquetée, tous les utilisateurs ayant un accès read à la ressource peuvent voir l'étiquette. Pour attacher ou détacher une balise sur une ressource ou un identifiant de service, certains rôles ou autorisations d'accès sont nécessaires en fonction du type de ressource et du type de balise. Consultez le tableau suivant pour savoir quel rôle est requis pour chaque type de ressource :

Type de ressource Rôle
Compatible avec IAM Pour associer ou dissocier des balises utilisateur, de l'éditeur ou de l'administrateur sur la ressource
Pour associer ou dissocier des balises de gestion d'accès, administrateur sur la ressource
Pour afficher les règles affectées sur la ressource ayant une balise de gestion d'accès qui est connectée, rôle de l'afficheur
Bare metal sur l'infrastructure classique Affichage des détails matériels et accès à un ensemble spécifique de services ou à tous les serveurs bare metal
Hôtes dédiés sur l'infrastructure classique Affichage des détails des hôtes dédiés virtuels et accès à un ensemble spécifique de services ou à tous les hôtes dédiés
Serveur virtuel sur l'infrastructure classique Affichage des détails des serveurs virtuels et accès à un ensemble spécifique de services ou à tous les serveurs virtuels
Cloud Object Storage S3 sur l'infrastructure classique Droits de gestion de stockage
File Storage sur l'infrastructure classique Droits de gestion de stockage
Sauvegarde EVault sur l'infrastructure classique Droits de gestion de stockage
Content Delivery Network sur l'infrastructure classique Gestion des droits sur un compte CDN
Direct Link sur l'infrastructure classique Membre du compte
Hardware Firewall Gérer les pare-feu
FortiGate Security Appliance Gérer les pare-feu
IBM Cloud Load Balancer Gérer les équilibreurs de charge
Gateway Appliance Gérer les passerelles réseau
ID de service Pour attacher ou détacher des balises utilisateur, éditeur ou administrateur sur le service IAM Identity
Pour attacher ou détacher des balises de gestion des accès, administrateur sur le service IAM Identity

Octroi aux utilisateurs de l'accès leur permettant d'étiqueter des ressources activées par IAM

Procédez comme suit pour affecter le rôle Editeur afin qu'un utilisateur puisse étiqueter les ressources avec IAM activé :

  1. Dans la console IBM Cloud, cliquez sur Gérer > Accès (IAM), puis sélectionnez Groupes d'accès.
  2. Cliquez sur Créer.
  3. Entrez un nom de groupe et une description, puis cliquez sur Créer.
  4. Ajoutez des utilisateurs au groupe d'accès en cliquant sur Ajouter des utilisateurs, en sélectionnant un ou plusieurs utilisateurs dans le tableau, puis en cliquant sur Ajouter au groupe.
  5. Cliquez sur Accès > Attribuer un accès.
  6. Sélectionnez Tous les services activés pour l'identité et l'accès ou un service spécifique.
  7. Sélectionnez un emplacement spécifique.
  8. Sélectionnez Editeur dans la liste des rôles d'accès à la plateforme, puis cliquez sur Réviser.
  9. Cliquez sur Ajouter pour ajouter votre configuration de règles à votre récapitulatif de règles.
  10. Cliquez sur Affecter.

Octroi aux utilisateurs de l'accès leur permettant d'étiqueter des ressources activées par IAM à l'aide de l'API

Pour attribuer le rôle d'éditeur à un utilisateur afin de baliser les ressources activées par IAM, appelez l'API de gestion des politiques IAM, comme indiqué dans l'exemple de demande suivant. Remplacez les variables par le service cible et le nom de la ressource.

curl -X POST 'https://iam.cloud.ibm.com/v1/policies' -H 'Authorization: Bearer $TOKEN' -H 'Content-Type: application/json' -d '{
  "type": "access",
  "description": "Editor role for SERVICE_NAME's RESOURCE_NAME",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }'
  ],
  "roles":[
    {
      "role_id": "crn:v1:bluemix:public:iam::::role:Editor"
    }
  ],
  "resources":[
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "$ACCOUNT_ID"
        },
        {
          "name": "serviceName",
          "value": "$SERVICE_NAME"
        },
        {
          "name": "resource",
          "value": "$RESOURCE_NAME",
          "operator": "stringEquals"
        }
      ]
    }
  ]
}'

SubjectAttribute subjectAttribute = new SubjectAttribute.Builder()
              .name("iam_id")
              .value(EXAMPLE_USER_ID)
              .build();
      PolicySubject policySubjects = new PolicySubject.Builder()
              .addAttributes(subjectAttribute)
              .build();
      PolicyRole policyRoles = new PolicyRole.Builder()
              .roleId("crn:v1:bluemix:public:iam::::role:Editor")
              .build();
      ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
              .name("accountId")
              .value(exampleAccountId)
              .operator("stringEquals")
              .build();
      ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
              .name("serviceType")
              .value("service")
              .operator("stringEquals")
              .build();
      PolicyResource policyResources = new PolicyResource.Builder()
              .addAttributes(accountIdResourceAttribute)
              .addAttributes(serviceNameResourceAttribute)
              .build();
      CreatePolicyOptions options = new CreatePolicyOptions.Builder()
              .type("access")
              .subjects(Arrays.asList(policySubjects))
              .roles(Arrays.asList(policyRoles))
              .resources(Arrays.asList(policyResources))
              .build();
      Response<Policy> response = service.createPolicy(options).execute();
      Policy policy = response.getResult();
      System.out.println(policy);

const policySubjects = [
      {
        attributes: [
          {
            name: 'iam_id',
            value: exampleUserId,
          },
        ],
      },
    ];
    const policyRoles = [
      {
        role_id: 'crn:v1:bluemix:public:iam::::role:Editor',
      },
    ];
    const accountIdResourceAttribute = {
      name: 'accountId',
      value: exampleAccountId,
      operator: 'stringEquals',
    };
    const serviceNameResourceAttribute = {
      name: 'serviceType',
      value: 'service',
      operator: 'stringEquals',
    };
    const policyResources = [
      {
        attributes: [accountIdResourceAttribute, serviceNameResourceAttribute],
      },
    ];
    const params = {
      type: 'access',
      subjects: policySubjects,
      roles: policyRoles,
      resources: policyResources,
    };
    iamPolicyManagementService.createPolicy(params)
      .then(res => {
        examplePolicyId = res.result.id;
        console.log(JSON.stringify(res.result, null, 2));
      })
      .catch(err => {
        console.warn(err)
      });

policy_subjects = PolicySubject(
                attributes=[SubjectAttribute(name='iam_id', value=example_user_id)])
            policy_roles = PolicyRole(
                role_id='crn:v1:bluemix:public:iam::::role:Editor')
            account_id_resource_attribute = ResourceAttribute(
                name='accountId', value=example_account_id)
            service_name_resource_attribute = ResourceAttribute(
                name='serviceType', value='service')
            policy_resources = PolicyResource(
                attributes=[account_id_resource_attribute,
                            service_name_resource_attribute])
            policy = iam_policy_management_service.create_policy(
                type='access',
                subjects=[policy_subjects],
                roles=[policy_roles],
                resources=[policy_resources]
            ).get_result()
            print(json.dumps(policy, indent=2))

subjectAttribute := &iampolicymanagementv1.SubjectAttribute{
				Name:  core.StringPtr("iam_id"),
				Value: &exampleUserID,
			}
			policySubjects := &iampolicymanagementv1.PolicySubject{
				Attributes: []iampolicymanagementv1.SubjectAttribute{*subjectAttribute},
			}
			policyRoles := &iampolicymanagementv1.PolicyRole{
				RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Editor"),
			}
			accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
				Name:     core.StringPtr("accountId"),
				Value:    core.StringPtr(exampleAccountID),
				Operator: core.StringPtr("stringEquals"),
			}
			serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
				Name:     core.StringPtr("serviceType"),
				Value:    core.StringPtr("service"),
				Operator: core.StringPtr("stringEquals"),
			}
			policyResources := &iampolicymanagementv1.PolicyResource{
				Attributes: []iampolicymanagementv1.ResourceAttribute{
					*accountIDResourceAttribute, *serviceNameResourceAttribute},
			}
			options := iamPolicyManagementService.NewCreatePolicyOptions(
				"access",
				[]iampolicymanagementv1.PolicySubject{*policySubjects},
				[]iampolicymanagementv1.PolicyRole{*policyRoles},
				[]iampolicymanagementv1.PolicyResource{*policyResources},
			)
			policy, response, err := iamPolicyManagementService.CreatePolicy(options)
			if err != nil {
				panic(err)
			}
			b, _ := json.MarshalIndent(policy, "", "  ")
			fmt.Println(string(b))

Octroi aux utilisateurs de l'accès leur permettant d'étiqueter d'infrastructure classique

Les ressources pouvant être étiquetées dans l'infrastructure classique sont les suivantes : Invité virtuel, Hôte virtuel dédié, Contrôleur de livraison d'applications réseau, Membre de passerelle, Sous-réseau, VLAN et Pare-feu VLAN (dédié). Procédez comme suit pour affecter le rôle d'accès Responsable pour qu'un utilisateur puisse étiqueter les services de l'infrastructure classique :

  1. Cliquez sur Gérer > Accès (IAM) puis sélectionnez Utilisateurs.
  2. Cliquez sur le nom de l'utilisateur dans le tableau.
  3. Cliquez sur Infrastructure classique.
  4. Dans l'onglet Droits, développez la catégorie Périphériques.
  5. Sélectionnez Afficher les informations détaillées sur le matériel et Afficher les détails du serveur virtuel. Si vous devez affecter l'accès à Cloud Object Storage S3, File Storage ou Evault Backup, affectez le droit Gestion de stockage. Si vous devez affecter un accès au réseau Content Delivery Network, affectez le droit Gérer un compte CDN.
  6. Cliquez sur Sauvegarder.
  7. Cliquez sur l'onglet Périphériques.
  8. Sélectionnez Tous les serveurs métalliques nus ou Tous les serveurs virtuels, en fonction de la ressource que vous souhaitez que l'utilisateur puisse marquer.

Accorder aux utilisateurs l'accès aux ID de service de balises

Effectuez les étapes suivantes pour attribuer le rôle d'administrateur sur leIAM Identity Service pour un utilisateur :

  1. Cliquez sur Gérer > Accès (IAM) puis sélectionnez Utilisateurs.
  2. Cliquez sur le nom de l'utilisateur dans le tableau.
  3. Sélectionnez le service IAM Identity et cliquez sur Next.
  4. Sélectionner Toutes les ressources et cliquez Suivant.
  5. Sélectionnez le rôle d' administrateur.
  6. Cliquez sur Revoir >Ajouter.
  7. Cliquez sur Affecter.

Permettre aux utilisateurs d'accéder aux identifiants des services de balises en utilisant l'API

Pour attribuer le rôle d'administrateur sur leIAM Identity Service pour un utilisateur, appelez le API de gestion des stratégies IAM comme le montre l’exemple de demande suivant. Remplacez les valeurs par l'ID IAM et l'ID de compte de votre utilisateur cible.

curl -X POST 'https://iam.cloud.ibm.com/v1/policies' -H 'Authorization: Bearer $TOKEN' -H 'Content-Type: application/json' -d '{
  "type": "access",
  "description": "Administrator role for the IAM Identity Service so that user can tag service IDs",
  "subjects": [
    {
      "attributes": [
        {
          "name": "iam_id",
          "value": "IBMid-123453user"
        }
      ]
    }'
  ],
  "roles":[
    {
      "role_id": "crn:v1:bluemix:public:iam::::role:Administrator"
    }
  ],
  "resources":[
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "$ACCOUNT_ID"
        },
        {
          "name": "serviceName",
          "value": "iam-identity"
        }
      ]
    }
  ]
}'

SubjectAttribute subjectAttribute = new SubjectAttribute.Builder()
              .name("iam_id")
              .value(EXAMPLE_USER_ID)
              .build();
      PolicySubject policySubjects = new PolicySubject.Builder()
              .addAttributes(subjectAttribute)
              .build();
      PolicyRole policyRoles = new PolicyRole.Builder()
              .roleId("crn:v1:bluemix:public:iam::::role:Administrator")
              .build();
      ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
              .name("accountId")
              .value(exampleAccountId)
              .operator("stringEquals")
              .build();
      ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
              .name("serviceType")
              .value("iam-identity")
              .operator("stringEquals")
              .build();
      PolicyResource policyResources = new PolicyResource.Builder()
              .addAttributes(accountIdResourceAttribute)
              .addAttributes(serviceNameResourceAttribute)
              .build();
      CreatePolicyOptions options = new CreatePolicyOptions.Builder()
              .type("access")
              .subjects(Arrays.asList(policySubjects))
              .roles(Arrays.asList(policyRoles))
              .resources(Arrays.asList(policyResources))
              .build();
      Response<Policy> response = service.createPolicy(options).execute();
      Policy policy = response.getResult();
      System.out.println(policy);

const policySubjects = [
      {
        attributes: [
          {
            name: 'iam_id',
            value: exampleUserId,
          },
        ],
      },
    ];
    const policyRoles = [
      {
        role_id: 'crn:v1:bluemix:public:iam::::role:Administrator',
      },
    ];
    const accountIdResourceAttribute = {
      name: 'accountId',
      value: exampleAccountId,
      operator: 'stringEquals',
    };
    const serviceNameResourceAttribute = {
      name: 'serviceType',
      value: 'iam-identity',
      operator: 'stringEquals',
    };
    const policyResources = [
      {
        attributes: [accountIdResourceAttribute, serviceNameResourceAttribute],
      },
    ];
    const params = {
      type: 'access',
      subjects: policySubjects,
      roles: policyRoles,
      resources: policyResources,
    };
    iamPolicyManagementService.createPolicy(params)
      .then(res => {
        examplePolicyId = res.result.id;
        console.log(JSON.stringify(res.result, null, 2));
      })
      .catch(err => {
        console.warn(err)
      });

policy_subjects = PolicySubject(
                attributes=[SubjectAttribute(name='iam_id', value=example_user_id)])
            policy_roles = PolicyRole(
                role_id='crn:v1:bluemix:public:iam::::role:Administrator')
            account_id_resource_attribute = ResourceAttribute(
                name='accountId', value=example_account_id)
            service_name_resource_attribute = ResourceAttribute(
                name='serviceType', value='iam-identity')
            policy_resources = PolicyResource(
                attributes=[account_id_resource_attribute,
                            service_name_resource_attribute])
            policy = iam_policy_management_service.create_policy(
                type='access',
                subjects=[policy_subjects],
                roles=[policy_roles],
                resources=[policy_resources]
            ).get_result()
            print(json.dumps(policy, indent=2))

subjectAttribute := &iampolicymanagementv1.SubjectAttribute{
				Name:  core.StringPtr("iam_id"),
				Value: &exampleUserID,
			}
			policySubjects := &iampolicymanagementv1.PolicySubject{
				Attributes: []iampolicymanagementv1.SubjectAttribute{*subjectAttribute},
			}
			policyRoles := &iampolicymanagementv1.PolicyRole{
				RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Administrator"),
			}
			accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
				Name:     core.StringPtr("accountId"),
				Value:    core.StringPtr(exampleAccountID),
				Operator: core.StringPtr("stringEquals"),
			}
			serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
				Name:     core.StringPtr("serviceType"),
				Value:    core.StringPtr("iam-identity"),
				Operator: core.StringPtr("stringEquals"),
			}
			policyResources := &iampolicymanagementv1.PolicyResource{
				Attributes: []iampolicymanagementv1.ResourceAttribute{
					*accountIDResourceAttribute, *serviceNameResourceAttribute},
			}
			options := iamPolicyManagementService.NewCreatePolicyOptions(
				"access",
				[]iampolicymanagementv1.PolicySubject{*policySubjects},
				[]iampolicymanagementv1.PolicyRole{*policyRoles},
				[]iampolicymanagementv1.PolicyResource{*policyResources},
			)
			policy, response, err := iamPolicyManagementService.CreatePolicy(options)
			if err != nil {
				panic(err)
			}
			b, _ := json.MarshalIndent(policy, "", "  ")
			fmt.Println(string(b))