Création d'une autorisation dans la console

Vous devez avoir accès au service cible pour créer une autorisation entre des services. Vous ne pouvez accorder que le niveau d'accès dont vous disposez en tant qu'utilisateur du service cible. Par exemple, si vous avez un accès Afficheur sur le service cible, vous ne pouvez accorder que le rôle Afficheur pour l'autorisation.

1. Dans la console IBM Cloud, cliquez sur Gérer > Accès (IAM), puis sélectionnez Autorisations.

2. Cliquez sur Créer.

3. Sélectionnez un compte source.

   • Si la source qui doit accéder à la cible se trouve dans ce compte, sélectionnez Ce compte.
   • Si la source qui doit accéder à la cible se trouve dans un autre compte, sélectionnez Autre compte. Entrez ensuite l'ID de compte du compte source.

4. Sélectionnez le ou les services qui ont besoin d'un accès.

   • Vous pouvez sélectionner un service individuel et spécifier si vous voulez que la source inclue toutes les ressources, les instances seulement dans un certain groupe de ressources, ou seulement une instance spécifique dans le compte.
   • Nouveau Vous pouvez également sélectionner Tous les services d'identité et d'accès et sélectionner ou saisir un ID de groupe de ressources.

   Nouveau L'entrée d'un groupe de ressources comme source permet aux instances de service d'un groupe de ressources d'accéder à la ressource cible dans votre compte. Vous pouvez définir ce niveau d'accès si vous ne souhaitez pas donner un accès direct à une ressource.

5. Sélectionnez une cible.

6. Indiquez si vous souhaitez que la cible inclue toutes les ressources ou des ressources spécifiques. Si vous avez choisi des ressources spécifiques comme cible, vous pouvez ajouter des attributs pour mieux délimiter l'accès. Le type d'attributs dépend du service cible que vous avez sélectionné.

7. (Facultatif) Sélectionnez Activer l'autorisation déléguée par les services source et dépendants pour permettre au service source de déléguer son accès à tous les services dépendants. Cette option s'affiche uniquement si le service source a des services dépendants. Lorsque vous sélectionnez cette option, des règles sont automatiquement créées par le service source pour les services dépendants.

8. Sélectionnez un rôle pour affecter l'accès au service source qui accède au service cible.

9. Cliquez sur Autoriser.

Si vous créez une autorisation entre un service d'un autre compte et un service cible de votre compte actuel, vous ne devez avoir accès qu'à la ressource cible. Pour le compte source, vous n'avez besoin que du numéro de compte.

Création d'une autorisation à l'aide de l'interface de ligne de commande

Pour permettre à un service source d'accéder à un service cible, exécutez la commande ibmcloud iam authorization-policy-create.

L'exemple suivant utilise des données fictives pour créer une règle dans laquelle une instance de service source spécifique d'IBM Cloud Object Storage est autorisée à accéder à une instance de service cible spécifique d'IBM Key Protect :

ibmcloud iam authorization-policy-create cloud-object-storage kms Reader --source-service-instance-id 123123 --target-service-instance-id 456456

Pour plus de détails sur les paramètres disponibles de cette commande, voir ibmcloud iam authorization-policy-create.

Création d'une autorisation à l'aide de Terraform

Vous devez avoir accès au service cible pour créer une autorisation entre des services. Vous ne pouvez accorder que le niveau d'accès dont vous disposez en tant qu'utilisateur du service cible. Par exemple, si vous avez un accès Afficheur sur le service cible, vous ne pouvez accorder que le rôle Afficheur pour l'autorisation.

Avant de pouvoir créer une autorisation à l'aide de Terraform, assurez-vous d'avoir effectué les opérations suivantes :

• Installez le CLI Terraform et configurez le plug-in IBM Cloud Provider pour Terraform. Pour plus d'informations, voir le tutoriel Getting started with Terraform sur IBM Cloud®. Ce plug-in résume les API IBM Cloud utilisées pour effectuer cette tâche.
• Créez un fichier de configuration Terraform nommé main.tf. Dans ce fichier, vous définissez les ressources en utilisant le langage de configuration HashiCorp. Pour plus d'informations, voir la documentation de Terraform.

Suivez les étapes suivantes pour créer une autorisation à l'aide de Terraform :

1. Créez une politique d'autorisation entre les services en utilisant l'argument de ressource ibm_iam_authorization_policy dans votre fichier main.tf.

   L'exemple suivant crée une autorisation entre les services :

   resource "ibm_iam_authorization_policy" "policy" {
   source_service_name = "cloud-object-storage"
   target_service_name = "kms"
   roles               = ["Reader"]
   description         = "Authorization Policy"
   transaction_id     = "terraformAuthorizationPolicy"
   }
   

   La ressource ibm_iam_authorization_policy nécessite le service source, le service cible et le rôle. Le service source est autorisé à accéder au service cible, et le rôle est le niveau de permission que l'accès autorise. En option, vous pouvez ajouter une description de l'autorisation et un numéro d'identification de la transaction.

   Pour plus d'exemples, voir la documentation Terraform sur les ressources d'autorisation.

2. Une fois que vous avez fini de construire votre fichier de configuration, initialisez le CLI Terraform. Pour plus d'informations, voir Initialisation des répertoires de travail.

   terraform init
   

3. Fournir les ressources à partir du fichier main.tf. Pour plus d'informations, voir Provisionnement de l'infrastructure avec Terraform.

   1. Exécutez terraform plan pour générer un plan d'exécution Terraform afin de prévisualiser les actions proposées.

      terraform plan
      

   2. Exécutez le site terraform apply pour créer les ressources définies dans le plan.

      terraform apply
      

Création d'une autorisation à l'aide de l'API

Pour permettre à un service source d'accéder à un service cible, utilisez l'API de gestion des règles IAM. Consultez l'exemple d'API suivant de création d'une méthode de règle avec l'élément type=authorization spécifié.

Les attributs pris en charge pour la création d'une règle d'autorisation dépendent des éléments pris en charge par chaque service. Pour plus d'informations sur les attributs pris en charge pour chaque service, consultez la documentation relative aux services que vous utilisez.

curl --request POST \
  --url https://iam.cloud.ibm.com/v1/policies \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "type": "authorization",
    "subjects": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<account-id>"
                },
                {
                    "name": "serviceName",
                    "value": "<service-name>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<instance-id>"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:iam::::serviceRole:Reader"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<account-id>"
                },
                {
                    "name": "serviceName",
                    "value": "<service-name>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<instance-id>"
                },
                {
                    "name": "resourceType",
                    "value": "<resource-type>"
                },
                {
                    "name": "resource",
                    "value": "<id>"
                }
            ]
        }
    ]
}'

SubjectAttribute accountSubjectAttribute = new SubjectAttribute.Builder()
      .name("accountId")
      .value(exampleAccountId)
      .build();

SubjectAttribute serviceNameSubjectAttribute = new SubjectAttribute.Builder()
      .name("serviceName")
      .value(exampleSourceServiceName)
      .build();

SubjectAttribute serviceInstanceSubjectAttribute = new SubjectAttribute.Builder()
      .name("serviceInstance")
      .value(exampleSourceServiceInstanceId)
      .build();

PolicySubject policySubjects = new PolicySubject.Builder()
      .addAttributes(accountSubjectAttribute)
      .addAttributes(serviceNameSubjectAttribute)
      .addAttributes(serviceInstanceSubjectAttribute)
      .build();

PolicyRole policyRoles = new PolicyRole.Builder()
      .roleId("crn:v1:bluemix:public:iam::::serviceRole:Reader")
      .build();

ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
      .name("accountId")
      .value(exampleAccountId)
      .operator("stringEquals")
      .build();

ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
      .name("serviceName")
      .value(exampleTargetServiceName)
      .operator("stringEquals")
      .build();

ResourceAttribute serviceInstanceResourceAttribute = new ResourceAttribute.Builder()
      .name("serviceInstance")
      .value(exampleTargetInstanceId)
      .operator("stringEquals")
      .build();

ResourceAttribute resourceTypeResourceAttribute = new ResourceAttribute.Builder()
      .name("resourceType")
      .value(exampleResourceType)
      .operator("stringEquals")
      .build();

ResourceAttribute resourceResourceAttribute = new ResourceAttribute.Builder()
      .name("resource")
      .value(exampleResourceId)
      .operator("stringEquals")
      .build();

PolicyResource policyResources = new PolicyResource.Builder()
      .addAttributes(accountIdResourceAttribute)
      .addAttributes(serviceNameResourceAttribute)
      .addAttributes(serviceInstanceResourceAttribute)
      .addAttributes(resourceTypeResourceAttribute)
      .addAttributes(resourceResourceAttribute)
      .build();

CreatePolicyOptions options = new CreatePolicyOptions.Builder()
      .type("authorization")
      .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: 'accountId',
        value: exampleAccounId,
      },
      {
        name: 'serviceName',
        value: exampleSourceServiceName,
      },
      {
        name: 'serviceInstance',
        value: exampleSourceServiceInstaceId,
      },
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:iam::::serviceRole:Reader',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: exampleAccountId,
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceName',
  value: exampleTargetServiceName,
  operator: 'stringEquals',
};
const serviceInstanceResourceAttribute = {
  name: 'serviceInstance',
  value: exampleTargetServiceInstanceId,
  operator: 'stringEquals',
};
const resourceTypeResourceAttribute = {
  name: 'resourceType',
  value: exampleResourceType,
  operator: 'stringEquals',
};
const resourceResourceAttribute = {
  name: 'resource',
  value: exampleResourceId,
  operator: 'stringEquals',
};

const policyResources = [
  {
    attributes: [
      accountIdResourceAttribute,
      serviceNameResourceAttribute,
      serviceInstanceResourceAttribute,
      resourceTypeResourceAttribute,
      resourceResourceAttribute,
    ],
  },
];
const params = {
  type: 'authorization',
  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='accountId', value=example_account_id),
                SubjectAttribute(name='serviceName', value=example_source_service_name),
                SubjectAttribute(name='serviceInstance', value=example_source_service_instance_id)])
policy_roles = PolicyRole(
    role_id='crn:v1:bluemix:public:iam::::serviceRole:Reader')
account_id_resource_attribute = ResourceAttribute(
    name='accountId', value=example_account_id)
service_name_resource_attribute = ResourceAttribute(
    name='serviceName', value=example_target_service_name)
service_instance_resource_attribute = ResourceAttribute(
    name='serviceInstance', value=example_target_service_instance_id)
resource_type_resource_attribute = ResourceAttribute(
    name='resourceType', value=example_resource_type)
resource_resource_attribute = ResourceAttribute(
    name='resource', value=example_resource_id)
policy_resources = PolicyResource(
    attributes=[account_id_resource_attribute,
                service_name_resource_attribute,
                service_instance_resource_attribute,
                resource_type_resource_attribute,
                resource_resource_attribute])

policy = iam_policy_management_service.create_policy(
    type='authorization',
    subjects=[policy_subjects],
    roles=[policy_roles],
    resources=[policy_resources]
).get_result()

print(json.dumps(policy, indent=2))

accountSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("accountId"),
    Value: &exampleAccountID,
}
serviceNameSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("serviceName"),
    Value: &exampleSourceServiceName,
}
serviceInstanceSubjectAttribute := &iampolicymanagementv1.SubjectAttribute{
    Name:  core.StringPtr("serviceInstance"),
    Value: &exampleSourceServiceInstanceId,
}
policySubjects := &iampolicymanagementv1.PolicySubject{
    Attributes: []iampolicymanagementv1.SubjectAttribute{*accountSubjectAttribute,
        *serviceNameSubjectAttribute, *serviceInstanceSubjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
    RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::serviceRole:Reader"),
}
accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("accountId"),
    Value:    core.StringPtr(exampleAccountID),
    Operator: core.StringPtr("stringEquals"),
}
serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("serviceName"),
    Value:    core.StringPtr(exampleTargetServiceName),
    Operator: core.StringPtr("stringEquals"),
}
serviceInstanceResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("serviceInstance"),
    Value:    core.StringPtr(exampleTargetServiceInstanceId),
    Operator: core.StringPtr("stringEquals"),
}
resourceTypeResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("resourceType"),
    Value:    core.StringPtr(exampleResourceType),
    Operator: core.StringPtr("stringEquals"),
}
resourceResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
    Name:     core.StringPtr("resource"),
    Value:    core.StringPtr(exampleResourceId),
    Operator: core.StringPtr("stringEquals"),
}
policyResources := &iampolicymanagementv1.PolicyResource{
    Attributes: []iampolicymanagementv1.ResourceAttribute{
        *accountIDResourceAttribute, *serviceNameResourceAttribute,
        *serviceInstanceResourceAttribute, *resourceTypeResourceAttribute,
        *resourceResourceAttribute},
}

options := iamPolicyManagementService.NewCreatePolicyOptions(
    "authorization",
    []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))

Tous les services ne prennent pas en charge les règles au niveau resourceType et resource individuel. IBM Cloud Object Storage et IBM Key Protect sont des exemples de services prenant en charge ces attributs. Dans ces services, les compartiments et les clés correspondent au type de ressource et l'ID est répertorié afin d'indiquer la ressource spécifique.

{
 "type": "authorization",
    "subjects": [
        {
            "attributes": [
                {
                    "name": "resourceGroupId",
                    "value": "<rgId>"
                },
                {
                    "name": "accountId",
                    "value": "<sourceAccountId>"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:iam::::role:Viewer"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<targetAccountId>"
                },
                {
                    "name": "serviceName",
                    "value": "<targetService>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<targetServiceInstance>"
                }
            ]
        }
    ]
}

{
 "type": "authorization",
    "subjects": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<sourceAccountId>"
                },
                {
                    "name": "serviceName",
                    "value": "<sourceService>"
                },
                {
                    "name": "serviceInstance",
                    "value": "<sourceServiceInstance>"
                }
            ]
        }
    ],
    "roles": [
        {
            "role_id": "crn:v1:bluemix:public:iam::::role:Viewer"
        }
    ],
    "resources": [
        {
            "attributes": [
                {
                    "name": "accountId",
                    "value": "<targetAccountId>"
                },
                {
                    "name": "resourceType",
                    "value": "resource-group"
                }
            ]
        }
    ]
}

Suppression d'une autorisation dans la console

Vous pouvez supprimer toute autorisation entre les services du compte si vous disposez du rôle Administrateur sur le service cible. Si vous retirez des règles d'accès créées par le service source pour ses services dépendants, le service source ne parvient pas à compléter le flux de travaux ou à accéder au service cible.

1. Dans la console IBM Cloud, cliquez sur Gérer > Accès (IAM), puis sélectionnez Autorisations.
2. Identifiez la ligne contenant l'autorisation que vous voulez retirer du compte.
3. Cliquez sur l'icône Actions > Supprimer.
4. Sélectionnez Retirer.

Si le service source est supprimé du compte, toutes les règles créées par ce service pour ses services dépendants sont automatiquement supprimées. De même, si le service dépendant est supprimé du compte, toutes les règles d'accès qui sont déléguées à ce service sont également supprimées.

Suppression d'une autorisation à l'aide de l'interface de ligne de commande

Vous pouvez supprimer toute autorisation entre les services du compte si vous disposez du rôle Administrateur sur le service cible. Si vous retirez des règles d'accès créées par le service source pour ses services dépendants, le service source ne parvient pas à compléter le flux de travaux ou à accéder au service cible.

Pour autoriser un service source à accéder à un service cible, exécutez la commande ibmcloud iam authorization-policy-create.

L'exemple suivant supprime une règle d'autorisation :

ibmcloud iam authorization-policy-delete 12345678-abcd-1a2b-a1b2-1234567890ab

Pour plus d'informations sur les paramètres disponibles de cette commande, voir ibmcloud iam authorization-policy-delete.

Si le service source est supprimé du compte, toutes les règles créées par ce service pour ses services dépendants sont automatiquement supprimées. De même, si le service dépendant est supprimé du compte, toutes les règles d'accès qui sont déléguées à ce service sont également supprimées.

Suppression d'une autorisation à l'aide de l'API

Vous pouvez supprimer toute autorisation entre les services du compte si vous disposez du rôle Administrateur sur le service cible. Si vous retirez des règles d'accès créées par le service source pour ses services dépendants, le service source ne parvient pas à compléter le flux de travaux ou à accéder au service cible.

Pour supprimer une règle d'autorisation, utilisez l'API de gestion des règles IAM, comme indiqué dans l'exemple de demande suivant :

curl -X DELETE 'https://iam.cloud.ibm.com/v1/policies/$POLICY_ID' \
-H 'Authorization: Bearer $TOKEN' \
-H 'Content-Type: application/json'

DeletePolicyOptions options = new DeletePolicyOptions.Builder()
        .policyId(examplePolicyId)
        .build();

service.deletePolicy(options).execute();

const params = {
  policyId: examplePolicyId,
};

iamPolicyManagementService.deletePolicy(params)
  .then(res => {
    console.log(JSON.stringify(res, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

response = iam_policy_management_service.delete_policy(
  policy_id=example_policy_id
).get_result()

print(json.dumps(response, indent=2))

options := iamPolicyManagementService.NewDeletePolicyOptions(
  examplePolicyID,
)

response, err := iamPolicyManagementService.DeletePolicy(options)
if err != nil {
  panic(err)
}

Si le service source est supprimé du compte, toutes les règles créées par ce service pour ses services dépendants sont automatiquement supprimées. De même, si le service dépendant est supprimé du compte, toutes les règles d'accès qui sont déléguées à ce service sont également supprimées.

Suppression d'une autorisation à l'aide de Terraform

Si vous souhaitez supprimer une autorisation en utilisant Terraform, vous devez supprimer l'argument du fichier main.tf. Après avoir supprimé l'argument, provisionnez votre fichier en suivant les étapes suivantes :

1. Exécutez terraform plan pour générer un plan d'exécution Terraform afin de prévisualiser les actions proposées.

   terraform plan
   

2. Exécutez le site terraform apply pour créer les ressources définies dans le plan.

   terraform apply