Limitation de l'accès par des conditions basées sur les attributs de temps et de ressources

Vous pouvez définir des conditions temporelles pour désigner un accès temporaire aux ressources de votre compte ou autoriser l'accès aux ressources pendant des fenêtres temporelles spécifiques, ainsi que des conditions basées sur les attributs des ressources pour éviter de créer plusieurs politiques d'accès afin de répondre à vos besoins en matière d'accès.

Vous pouvez créer des conditions temporelles qui accordent un accès temporaire unique pour une période et une date spécifiques, ou vous pouvez mettre en place un accès hebdomadaire récurrent. Par exemple, vous pourriez vouloir donner à un utilisateur l'accès aux ressources du compte uniquement pendant ses heures de travail en spécifiant un accès récurrent, ou vous pourriez avoir un contractant ou un utilisateur qui a besoin de démonstrations de fonctionnalités d'un service et qui n'a besoin que d'un accès temporaire.

Les conditions basées sur le temps ne tiennent pas compte des changements de l'heure d'été (DST) pour les fuseaux horaires qui observent le DST. Les administrateurs doivent mettre à jour les règles en fonction des changements d'heure d'été et d'hiver afin d'appliquer correctement les conditions basées sur l'heure. Par exemple, le fuseau horaire de l'Est est de UTC-4 heures pendant l'heure d'été et non de -5 heures comme c'est le cas pendant l'heure normale. L'heure normale commence en novembre et se termine en mars, lorsque l'heure d'été commence.

Le site Kubernetes Service n'est pas soumis à des conditions temporelles. Par exemple, une politique assortie d'une condition temporelle qui accorde l'accès à tous les services d'identité et d'accès inclut l'accès aux ressources Kubernetes Service. Le sujet de la politique a accès à certaines ressources Kubernetes Service en dehors des conditions temporelles spécifiées.

Les conditions temporelles des politiques d'accès vous permettent d'appliquer le principe du moindre privilège pour l'attribution des accès et de réduire la surface d'attaque en cas de violation de la sécurité.

Lorsque vous créez une politique avec des conditions basées sur des attributs de ressources, vous pouvez éviter de créer plusieurs politiques d'accès pour répondre à vos besoins d'accès. Au lieu de cela, vous pouvez créer une politique unique en utilisant une combinaison d'opérateurs OR/AND qui sont appliqués aux attributs des ressources avec des valeurs littérales ou des caractères génériques. Vous pouvez accorder l'accès à une ressource qui répond simultanément à plusieurs critères (ET) ou accorder l'accès si l'une des conditions est remplie (OU). Par exemple, avec les conditions basées sur les attributs de ressources, vous pouvez créer une politique unique qui autorise l'accès sur la base de Service instance: abc, OU attribute-1: xyz, OU (attribute-2: def ET attribute-3: hij).

Vous devez avoir au moins 2 conditions qui utilisent OR/AND et des conditions basées sur des attributs de ressources. Si vous devez ajouter une seule condition, reportez-vous à la section Attribution de l'accès aux ressources dans la console et ajoutez la condition après avoir sélectionné Ressources spécifiques.

Pour revoir l'accès d'un utilisateur, voir Révision de l'accès attribué dans la console.

Modèles d'état

Modèles de conditions basés sur le temps

Les schémas suivants représentent les permutations de conditions autorisées :

Modèles de conditions autorisés pour les conditions basées sur le temps.
Schéma Exemple
conditions basées sur le temps : une fois Accès temporaire un jour donné, de 9 heures à 17 heures UTC-5.
conditions basées sur le temps:hebdomadaire:toute la journée Accès récurrent du lundi au vendredi UTC-5 toute la journée.
conditions basées sur le temps:hebdomadaire:heures personnalisées Accès récurrent du lundi au vendredi de 9h00 à 17h00 UTC-5.

IAM empêche de combiner des conditions temporaires uniques avec des conditions hebdomadaires récurrentes dans la même définition de politique.

Modèles de conditions basés sur les attributs des ressources

Les schémas suivants représentent les permutations de conditions autorisées :

Modèles de conditions autorisés pour les conditions basées sur les attributs des ressources.
Schéma Exemple
attribute-based-condition:resource:literal-and-wildcard Conditions basées sur des attributs de ressources avec des valeurs littérales ou des valeurs génériques (en fonction de l'opérateur utilisé)

Création d'une condition temporaire basée sur le temps à l'aide de la console

Vous pouvez attribuer un accès pour une durée déterminée en spécifiant une date et une plage horaire qui déterminent quand la condition accorde l'accès et y met fin. Par exemple, un utilisateur peut avoir besoin de présenter une démonstration sur votre compte pendant quelques heures ou un entrepreneur peut avoir besoin d'un accès temporaire à un service pendant quelques jours. Effectuez les étapes suivantes pour attribuer une politique d'accès avec une condition temporaire basée sur le temps :

  1. Dans la console IBM Cloud, allez dans Gérer > Accès (IAM)

  2. Sélectionnez Utilisateurs, Profils de confiance, ID de service ou Groupes d'accès, en fonction de l'entité à laquelle vous souhaitez attribuer un accès.

  3. Cliquez sur le nom de l'entité dans la liste et accédez à Accès.

  4. Cliquez sur Affecter un accès.

  5. Sélectionnez un service et cliquez sur Suivant.

    • Si vous souhaitez que l'utilisateur puisse créer un service, sélectionnez Tous les services avec l'offre Identity and Access activée.
    • Si vous souhaitez affecter à l'utilisateur l'accès à un service spécifique, sélectionnez-le dans la liste.

  6. Sélectionnez la ressource à laquelle vous souhaitez attribuer l'accès à l'utilisateur ou sélectionnez Toutes les ressources. Cliquez sur Suivant.

  7. (Facultatif) Sélectionnez un rôle d'accès au groupe de ressources. Cliquez sur Suivant.

  8. Sélectionnez n'importe quelle combinaison de rôles d'accès aux services et d'accès à la plate-forme, puis cliquez sur Suivant.

  9. Cliquez sur Ajouter une condition et sélectionnez Une fois.

  10. Sélectionnez le fuseau horaire.

    Supposons par exemple que vous créiez une politique conditionnelle pour un développeur basé à Dublin. Dans ce cas, sélectionnez UTC+1 pour que la plage de dates et d'heures que vous sélectionnez à l'étape suivante impose l'accès à l'heure exacte pour ce lieu.

  11. Complétez les champs relatifs à la date et à l'intervalle de temps qui déterminent quand la condition accorde et met fin à l'accès.

  12. Cliquez sur Créer.

  13. Cliquez sur Vérifier.

  14. Cliquez sur Ajouter pour ajouter votre configuration de règles à votre récapitulatif de règles.

  15. Cliquez sur Affecter.

Les politiques temporaires ne sont pas automatiquement supprimées. Pour éviter d'atteindre la limite de la politique dans le compte, les administrateurs peuvent supprimer la politique manuellement après son expiration.

Pour plus d'informations sur les conditions temporelles des politiques d'accès, voir Conditions dans les politiques d'accès.

Avant de commencer

Assurez-vous que vous disposez de la dernière version de l'interface CLI IBM Cloud afin de pouvoir utiliser des conditions dans vos politiques d'accès.

Pour déterminer la version de votre interface de ligne de commande IBM Cloud, exécutez la commande suivante :

ibmcloud -v

Vous devez utiliser la dernière version de l'interface de ligne de commande. Si vous n'utilisez pas la dernière version, exécutez la commande suivante pour mettre à jour votre interface de ligne de commande :

ibmcloud update

Si vous exécutez l'édition en cours, le résultat suivant s'affiche :

Checking for updates...
No update required. Your CLI is already up-to-date.

Pour plus d'informations, voir Installation du CLI autonome IBM Cloud.

Création d'une condition temporaire basée sur le temps à l'aide de l'ILC

Vous pouvez attribuer un accès pour une durée déterminée en spécifiant une date et une plage horaire qui déterminent quand la condition accorde l'accès et y met fin. Par exemple, un utilisateur peut avoir besoin de présenter une démonstration sur votre compte pendant quelques heures ou un entrepreneur peut avoir besoin d'un accès temporaire à un service pendant quelques jours. L'exemple suivant vous montre comment créer une condition unique basée sur le temps pour votre compte en accordant à l'utilisateur un accès temporaire en tant qu'opérateur pour tous les services de gestion de compte.

  1. Connectez-vous à l'interface de ligne de commande IBM Cloud®. Si vous possédez plusieurs comptes, vous êtes invité à sélectionner le compte à utiliser. Si vous n'indiquez pas de région avec l'option -r, vous devez également sélectionner une région.

    ibmcloud login

    Si vos données d'identification sont rejetées, vous pouvez utiliser un ID fédéré. Pour vous connecter avec un ID fédéré, utilisez l'indicateur --sso. Voir Connexion à l'aide d'un ID fédéré pour plus de détails.

    Si c'est la première fois que vous utilisez le CLI IBM Cloud, consultez le tutoriel de démarrage.

  2. Créez une politique d'accès et attribuez-la à un utilisateur ou à un identifiant de service à l'aide de la commande ibmcloud iam user-policy-create.

  3. Attribuer l'accès aux services de gestion de tous les comptes avec le rôle Operator:

    ibmcloud iam service-policy-create [your service ID here] --roles Operator --account-management --api-version v2

  4. Utilisez l'exemple suivant de schéma JSON de politique temporaire basée sur le temps pour créer vos propres conditions :

    {
  "type": "access",
  "description": "time-based conditions policy example restricting access to the full day of 2022-12-23 UTC",
  "control": {
    "grant": {
      "roles": [
        {
          "role_id": "crn:v1:bluemix:public:iam::::role:Operator"
        }
      ]
    }
  },
  "resource": {
    "attributes": [
      {
        "operator": "stringEquals",
        "value": "d4b763ad0cbd4dca8dd1edb427d7a77e",
        "key": "accountId"
      },
      {
        "value": "platform_service",
        "operator": "stringEquals",
        "key": "serviceType"
      }
    ]
  },
  "pattern": "time-based-conditions:once",
  "rule": {
    "operator": "and",
    "conditions": [
      {
        "key": "{{environment.attributes.current_date_time}}",
        "operator": "dateTimeGreaterThanOrEquals",
        "value": "2022-12-23T00:00:00+00:00"
      },
      {
        "key": "{{environment.attributes.current_date_time}}",
        "operator": "dateTimeLessThanOrEquals",
        "value": "2022-12-23T23:59:59+00:00"
      }
    ]
  },
  "subject": {
    "attributes": [
      {
        "key": "iam_id",
        "operator": "stringEquals",
        "value": "IBMid-550000HFVV"
      }
    ]
  }
}

Les politiques temporaires, qui utilisent le modèle time-based-conditions:once, ne sont pas automatiquement supprimées. Pour éviter d'atteindre la limite de la politique dans le compte, les administrateurs peuvent supprimer la politique manuellement après son expiration.

Pour plus d'informations sur les conditions temporelles des politiques d'accès, voir Conditions dans les politiques d'accès.

Avant de commencer

Veillez à appeler l'URI v2/policies, c'est-à-dire https://iam.coud.ibm.com/v2/policies, afin de pouvoir utiliser des conditions dans vos politiques d'accès. Pour plus d'informations, voir l'API de gestion des politiques IAM et le journal des modifications.

Création d'une condition temporaire basée sur le temps à l'aide de l'API

Vous pouvez attribuer un accès pour une durée déterminée en spécifiant une date et une plage horaire qui déterminent quand la condition accorde l'accès et y met fin. Par exemple, un utilisateur peut avoir besoin de présenter une démonstration sur votre compte pendant quelques heures ou un entrepreneur peut avoir besoin d'un accès temporaire à un service pendant quelques jours. Les exemples suivants vous montrent comment créer une condition unique basée sur le temps pour votre compte en accordant à l'utilisateur un accès temporaire en tant qu'opérateur pour tous les services de gestion de compte.

	subjectAttribute := &iampolicymanagementv1.V2PolicyAttribute{
				Key:  core.StringPtr("iam_id"),
				Operator: core.StringPtr("stringEquals"),
				Value: &exampleUserID,
			}
			policySubject := &iampolicymanagementv1.V2PolicyBaseSubject{
				Attributes: []iampolicymanagementv1.V2PolicyAttribute{*subjectAttribute},
			}
			policyRole := &iampolicymanagementv1.PolicyRole{
				RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Operator"),
			}
			v2PolicyGrant := &iampolicymanagementv1.V2PolicyBaseControlGrant{
				Roles: []iampolicymanagementv1.PolicyRole{*policyRole},
			}
			v2PolicyControl := &iampolicymanagementv1.V2PolicyBaseControl{
				Grant: v2PolicyGrant,
			}
			accountIDResourceAttribute := &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("accountId"),
				Operator: core.StringPtr("stringEquals"),
				Value:    core.StringPtr(exampleAccountID),
			}
			serviceNameResourceAttribute := &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("serviceType"),
				Operator: core.StringPtr("stringEquals"),
				Value:    core.StringPtr("service"),
			}
			policyResource := &iampolicymanagementv1.V2PolicyBaseResource{
				Attributes: []iampolicymanagementv1.V2PolicyAttribute{
					*accountIDResourceAttribute, *serviceNameResourceAttribute},
			}
			startConditionAttribute :=  &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("{{environment.attributes.current_time}}"),
				Operator: core.StringPtr("dateTimeGreaterThanOrEquals"),
				Value:    core.StringPtr("2022-12-23T00:00:00+00:00"),
			}
			endConditionAttribute :=  &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("{{environment.attributes.current_time}}"),
				Operator: core.StringPtr("dateTimeLessThanOrEquals"),
				Value:    core.StringPtr("2022-12-23T23:59:59+00:00"),
			}
			policyRule := &iampolicymanagementv1.V2PolicyBaseRule{
				Operator: core.StringPtr("and"),
				Conditions: []iampolicymanagementv1.V2PolicyAttribute{
					*startConditionAttribute, *endConditionAttribute},
			}
			options := iamPolicyManagementService.NewV2CreatePolicyOptions(
				"access",
				v2PolicyControl,
			)
			options.SetSubject(policySubject)
			options.SetResource(policyResource)
			options.SetRule(policyRule)
			options.SetPattern(*core.StringPtr("time-based-conditions:once"))
			policy, response, err := iamPolicyManagementService.V2CreatePolicy(options)
			if err != nil {
				panic(err)
			}
			b, _ := json.MarshalIndent(policy, "", "  ")
			fmt.Println(string(b))

V2PolicyAttribute subjectAttribute = new V2PolicyAttribute.Builder()
              .key("iam_id")
              .value(EXAMPLE_USER_ID)
              .operator("stringEquals")
              .build();
      V2PolicyBaseSubject policySubject = new V2PolicyBaseSubject.Builder()
              .addAttributes(subjectAttribute)
              .build();
      V2PolicyAttribute accountIdResourceAttribute = new V2PolicyAttribute.Builder()
              .key("accountId")
              .value(exampleAccountId)
              .operator("stringEquals")
              .build();
      V2PolicyAttribute serviceNameResourceAttribute = new V2PolicyAttribute.Builder()
              .key("serviceName")
              .value("iam-groups")
              .operator("stringEquals")
              .build();
      V2PolicyBaseResource policyResource = new V2PolicyBaseResource.Builder()
              .addAttributes(accountIdResourceAttribute)
              .addAttributes(serviceNameResourceAttribute)
              .build();
      PolicyRole policyRoles = new PolicyRole.Builder()
              .roleId("crn:v1:bluemix:public:iam::::role:Operator")
              .build();
      V2PolicyBaseControlGrant policyGrant = new V2PolicyBaseControlGrant.Builder()
              .roles(Arrays.asList(policyRoles))
              .build();
      V2PolicyBaseControl policyControl = new V2PolicyBaseControl.Builder()
              .grant(policyGrant)
              .build();
      V2PolicyAttribute startConditionAttribute = new V2PolicyAttribute.Builder()
              .key("{{environment.attributes.current_time}}")
              .value("2022-12-23T00:00:00+00:00")
              .operator("dateTimeGreaterThanOrEquals")
              .build();
      V2PolicyAttribute endConditionAttribute = new V2PolicyAttribute.Builder()
              .key("{{environment.attributes.current_time}}")
              .value("2022-12-23T23:59:59+00:00")
              .operator("dateTimeLessThanOrEquals")
              .build();
      V2PolicyBaseRuleV2RuleWithConditions policyRule = new V2PolicyBaseRuleV2RuleWithConditions.Builder()
              .operator("and")
              .conditions(new ArrayList<V2PolicyAttribute>(Arrays.asList(startConditionAttribute, endConditionAttribute)))
              .build();
      V2CreatePolicyOptions options = new V2CreatePolicyOptions.Builder()
              .type("access")
              .subject(policySubject)
              .control(policyControl)
              .resource(policyResource)
              .rule(policyRule)
              .pattern("time-based-conditions:once")
              .build();
      Response<V2Policy> response = service.v2CreatePolicy(options).execute();
      V2Policy policy = response.getResult();

const policySubject = {
      attributes: [
        {
          key: 'iam_id',
          operator: 'stringEquals',
          value: exampleUserId,
        },
      ],
    };
    const policyResourceAccountAttribute = {
      key: 'accountId',
      value: exampleAccountId,
      operator: 'stringEquals',
    };
    const policyResourceServiceAttribute = {
      key: 'serviceName',
      operator: 'stringEquals',
      value: 'iam-groups',
    };
    const policyResource = {
      attributes: [policyResourceAccountAttribute, policyResourceServiceAttribute]
    };
    const policyControl = {
      grant: {
        roles: [{
          role_id: 'crn:v1:bluemix:public:iam::::role:Operator',
        }],
      }
    };
    const policyRule = {
      operator: 'and',
      conditions: [
          {
              key: '{{environment.attributes.current_time}}',
              operator: 'dateTimeGreaterThanOrEquals',
              value: '2022-12-23T00:00:00+00:00',
          },
          {
              key: '{{environment.attributes.current_time}}',
              operator: 'dateTimeLessThanOrEquals',
              value: '2022-12-23T23:59:59+00:00',
          },
      ],
    }
    const policyPattern = 'time-based-conditions:once'
    const params = {
      type: 'access',
      subject: policySubject,
      control: policyControl,
      resource: policyResource,
      rule: policyRule,
      pattern: policyPattern,
    };
    try {
      const res = await iamPolicyManagementService.v2CreatePolicy(params);
      examplePolicyId = res.result.id;
      console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
      console.warn(err)
    }

policy_subject = V2PolicyBaseSubject(
                attributes=[V2PolicyAttribute(key='iam_id', value=example_user_id, operator='stringEquals')]
            )
            policy_role = PolicyRole(role_id='crn:v1:bluemix:public:iam::::role:Operator')
            account_id_resource_attribute = V2PolicyAttribute(
                key='accountId', value=example_account_id, operator='stringEquals'
            )
            service_name_resource_attribute = V2PolicyAttribute(
                key='serviceType', value='service', operator='stringEquals'
            )
            policy_resource = PolicyResource(
                attributes=[account_id_resource_attribute, service_name_resource_attribute],
            )
            policy_control = V2PolicyBaseControl(grant=V2PolicyBaseControlGrant(roles=[policy_role]))
            policy_rule = V2PolicyBaseRuleV2RuleWithConditions(
                operator='and',
                conditions=[
                    V2PolicyAttribute(
                        key='{{environment.attributes.current_time}}',
                        operator='dateTimeGreaterThanOrEquals',
                        value='2022-12-23T00:00:00+00:00',
                    ),
                    V2PolicyAttribute(
                        key='{{environment.attributes.current_time}}',
                        operator='dateTimeLessThanOrEquals',
                        value='2022-12-23T23:59:59+00:00',
                    ),
                ],
            )
            policy_pattern = 'time-based-conditions:once'
            policy = iam_policy_management_service.v2_create_policy(
                type='access',
                subject=policy_subject,
                control=policy_control,
                resource=policy_resource,
                rule=policy_rule,
                pattern=policy_pattern,
            ).get_result()
            print(json.dumps(policy, indent=2))

Les politiques temporaires, qui utilisent le modèle time-based-conditions:once, ne sont pas automatiquement supprimées. Pour éviter d'atteindre la limite de la politique dans le compte, les administrateurs peuvent supprimer la politique manuellement après son expiration.

Pour plus d'informations sur les conditions temporelles des politiques d'accès, voir Conditions dans les politiques d'accès.

Création d'une condition récurrente basée sur le temps à l'aide de la console

Vous pouvez attribuer des accès récurrents à une fréquence hebdomadaire. Il se peut que vous souhaitiez donner aux utilisateurs l'accès aux ressources du compte uniquement pendant leurs heures de travail. Effectuez les étapes suivantes pour attribuer une politique d'accès avec une condition récurrente basée sur le temps :

  1. Dans la console IBM Cloud, allez dans Gérer > Accès (IAM)

  2. Sélectionnez Utilisateurs, Profils de confiance, ID de service ou Groupes d'accès, en fonction de l'entité à laquelle vous souhaitez attribuer un accès.

  3. Cliquez sur le nom de l'identité dans la liste et accédez à Accès.

  4. Cliquez sur Affecter un accès.

  5. Sélectionnez un service et cliquez sur Suivant.

    • Si vous souhaitez que l'utilisateur puisse créer un service, sélectionnez Tous les services avec l'offre Identity and Access activée.
    • Si vous souhaitez affecter à l'utilisateur l'accès à un service spécifique, sélectionnez-le dans la liste.

  6. Sélectionnez la ressource à laquelle vous souhaitez attribuer l'accès à l'utilisateur ou sélectionnez Toutes les ressources. Cliquez sur Suivant.

  7. (Facultatif) Sélectionnez un rôle d'accès au groupe de ressources. Cliquez sur Suivant.

  8. Sélectionnez n'importe quelle combinaison de rôles d'accès aux services et d'accès à la plate-forme, puis cliquez sur Suivant.

  9. Cliquez sur Ajouter une condition et sélectionnez Hebdomadaire.

  10. Sélectionnez le fuseau horaire pour la politique conditionnelle.

    Supposons par exemple que vous créiez une politique conditionnelle pour un développeur basé à Dublin. Dans ce cas, sélectionnez UTC+1 pour que la plage de dates et d'heures que vous sélectionnez ensuite soit appliquée à l'heure correcte pour ce lieu.

  11. Sélectionnez les jours de la semaine auxquels la condition doit donner accès.

    • (Facultatif) Réglez la case à cocher Tous les jours sur Non pour spécifier un délai pour les jours que vous sélectionnez.

  12. Cliquez sur Créer.

  13. Cliquez sur Vérifier.

  14. Cliquez sur Ajouter pour ajouter votre configuration de règles à votre récapitulatif de règles.

  15. Cliquez sur Affecter.

Pour plus d'informations sur les conditions temporelles des politiques d'accès, voir Conditions dans les politiques d'accès.

Création d'une condition récurrente basée sur le temps à l'aide de l'interface de programmation

Vous pouvez attribuer des accès récurrents à une fréquence hebdomadaire. Il se peut que vous souhaitiez donner aux utilisateurs l'accès aux ressources du compte uniquement pendant leurs heures de travail. L'exemple suivant montre comment créer une condition récurrente basée sur le temps pour un utilisateur. La politique attribue un accès pendant les heures de travail, du lundi au vendredi, en tant qu'éditeur pour tous les services de gestion de comptes.

  1. Connectez-vous à l'interface de ligne de commande IBM Cloud®. Si vous possédez plusieurs comptes, vous êtes invité à sélectionner le compte à utiliser. Si vous n'indiquez pas de région avec l'option -r, vous devez également sélectionner une région.

    ibmcloud login

    Si vos données d'identification sont rejetées, vous pouvez utiliser un ID fédéré. Pour vous connecter avec un ID fédéré, utilisez l'indicateur --sso. Voir Connexion à l'aide d'un ID fédéré pour plus de détails.

    Si c'est la première fois que vous utilisez l'interface de ligne de commande IBM Cloud, consultez la rubrique Tutoriel d'initiation.

  2. Créez une politique d'accès et attribuez-la à un utilisateur ou à un identifiant de service à l'aide de la commande ibmcloud iam user-policy-create.

  3. Attribuer l'accès aux services de gestion de tous les comptes avec le rôle Editor:

    ibmcloud iam service-policy-create [your service ID here] --roles Editor --account-management --api-version v2

  4. Utilisez l'exemple suivant de schéma JSON d'une politique récurrente basée sur le temps pour créer vos propres conditions :

    ibmcloud iam service-policy-create [your service ID here] --file [your JSON file name]

    {
  "type": "access",
  "description": "time-based conditions policy example restricting access to the full day of 2022-12-23 UTC",
  "control": {
    "grant": {
      "roles": [
        {
          "role_id": "crn:v1:bluemix:public:iam::::role:Editor"
        }
      ]
    }
  },
  "resource": {
    "attributes": [
      {
        "operator": "stringEquals",
        "value": "d4b763ad0cbd4dca8dd1edb427d7a77e",
        "key": "accountId"
      },
      {
        "value": "platform_service",
        "operator": "stringEquals",
        "key": "serviceType"
      }
    ]
  },
  "pattern": "time-based-conditions:weekly",
  "rule": {
    "operator": "and",
    "conditions": [
      {
        "key": "{{environment.attributes.day_of_week}}",
        "operator": "dayOfWeekAnyOf",
        "value": [
          1,
          2,
          3,
          4,
          5
        ]
      },
      {
        "key": "{{environment.attributes.current_time}}",
        "operator": "timeGreaterThanOrEquals",
        "value": "00:00:00+00:00"
      },
      {
        "key": "{{environment.attributes.current_time}}",
        "operator": "timeLessThanOrEquals",
        "value": "23:59:59+00:00"
      }
    ]
  },
  "subject": {
    "attributes": [
      {
        "key": "iam_id",
        "operator": "stringEquals",
        "value": "IBMid-550000HFVV"
      }
    ]
  }
}

Pour plus d'informations sur les conditions temporelles des politiques d'accès, voir Conditions dans les politiques d'accès.

Création d'une condition récurrente basée sur le temps à l'aide de l'API

Vous pouvez attribuer des accès récurrents à une fréquence hebdomadaire. Il se peut que vous souhaitiez donner aux utilisateurs l'accès aux ressources du compte uniquement pendant leurs heures de travail. Les exemples suivants montrent comment créer une condition récurrente basée sur le temps pour un utilisateur. La politique attribue un accès pendant les heures de travail, du lundi au vendredi, en tant qu'éditeur pour tous les services de gestion de comptes.

subjectAttribute := &iampolicymanagementv1.V2PolicyAttribute{
				Key:  core.StringPtr("iam_id"),
				Operator: core.StringPtr("stringEquals"),
				Value: &exampleUserID,
			}
			policySubject := &iampolicymanagementv1.V2PolicyBaseSubject{
				Attributes: []iampolicymanagementv1.V2PolicyAttribute{*subjectAttribute},
			}
			policyRole := &iampolicymanagementv1.PolicyRole{
				RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Editor"),
			}
			v2PolicyGrant := &iampolicymanagementv1.V2PolicyBaseControlGrant{
				Roles: []iampolicymanagementv1.PolicyRole{*policyRole},
			}
			v2PolicyControl := &iampolicymanagementv1.V2PolicyBaseControl{
				Grant: v2PolicyGrant,
			}
			accountIDResourceAttribute := &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("accountId"),
				Operator: core.StringPtr("stringEquals"),
				Value:    core.StringPtr(exampleAccountID),
			}
			serviceNameResourceAttribute := &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("serviceType"),
				Operator: core.StringPtr("stringEquals"),
				Value:    core.StringPtr("service"),
			}
			policyResource := &iampolicymanagementv1.V2PolicyBaseResource{
				Attributes: []iampolicymanagementv1.V2PolicyAttribute{
					*accountIDResourceAttribute, *serviceNameResourceAttribute},
			}
			weeklyConditionAttribute :=  &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("{{environment.attributes.day_of_week}}"),
				Operator: core.StringPtr("dayOfWeekAnyOf"),
				Value:    []int{1,2,3,4,5},
			}
			startConditionAttribute :=  &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("{{environment.attributes.current_time}}"),
				Operator: core.StringPtr("timeGreaterThanOrEquals"),
				Value:    core.StringPtr("09:00:00+00:00"),
			}
			endConditionAttribute :=  &iampolicymanagementv1.V2PolicyAttribute{
				Key:     core.StringPtr("{{environment.attributes.current_time}}"),
				Operator: core.StringPtr("timeLessThanOrEquals"),
				Value:    core.StringPtr("17:00:00+00:00"),
			}
			policyRule := &iampolicymanagementv1.V2PolicyBaseRule{
				Operator: core.StringPtr("and"),
				Conditions: []iampolicymanagementv1.V2PolicyAttribute{
					*weeklyConditionAttribute, *startConditionAttribute, *endConditionAttribute},
			}
			options := iamPolicyManagementService.NewV2CreatePolicyOptions(
				"access",
				v2PolicyControl,
			)
			options.SetSubject(policySubject)
			options.SetResource(policyResource)
			options.SetRule(policyRule)
			options.SetPattern(*core.StringPtr("time-based-conditions:weekly"))
			policy, response, err := iamPolicyManagementService.V2CreatePolicy(options)
			if err != nil {
				panic(err)
			}
			b, _ := json.MarshalIndent(policy, "", "  ")
			fmt.Println(string(b))

V2PolicyAttribute subjectAttribute = new V2PolicyAttribute.Builder()
              .key("iam_id")
              .value(EXAMPLE_USER_ID)
              .operator("stringEquals")
              .build();
      V2PolicyBaseSubject policySubject = new V2PolicyBaseSubject.Builder()
              .addAttributes(subjectAttribute)
              .build();
      V2PolicyAttribute accountIdResourceAttribute = new V2PolicyAttribute.Builder()
              .key("accountId")
              .value(exampleAccountId)
              .operator("stringEquals")
              .build();
      V2PolicyAttribute serviceNameResourceAttribute = new V2PolicyAttribute.Builder()
              .key("serviceName")
              .value("iam-groups")
              .operator("stringEquals")
              .build();
      V2PolicyBaseResource policyResource = new V2PolicyBaseResource.Builder()
              .addAttributes(accountIdResourceAttribute)
              .addAttributes(serviceNameResourceAttribute)
              .build();
      PolicyRole policyRoles = new PolicyRole.Builder()
              .roleId("crn:v1:bluemix:public:iam::::role:Editor")
              .build();
      V2PolicyBaseControlGrant policyGrant = new V2PolicyBaseControlGrant.Builder()
              .roles(Arrays.asList(policyRoles))
              .build();
      V2PolicyBaseControl policyControl = new V2PolicyBaseControl.Builder()
              .grant(policyGrant)
              .build();
      V2PolicyAttribute weeklyConditionAttribute = new V2PolicyAttribute.Builder()
              .key("{{environment.attributes.day_of_week}}")
              .value(new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5)))
              .operator("dayOfWeekAnyOf")
              .build();
      V2PolicyAttribute startConditionAttribute = new V2PolicyAttribute.Builder()
              .key("{{environment.attributes.current_time}}")
              .value("09:00:00+00:00")
              .operator("timeGreaterThanOrEquals")
              .build();
      V2PolicyAttribute endConditionAttribute = new V2PolicyAttribute.Builder()
              .key("{{environment.attributes.current_time}}")
              .value("17:00:00+00:00")
              .operator("timeLessThanOrEquals")
              .build();
      V2PolicyBaseRuleV2RuleWithConditions policyRule = new V2PolicyBaseRuleV2RuleWithConditions.Builder()
              .operator("and")
              .conditions(new ArrayList<V2PolicyAttribute>(Arrays.asList(weeklyConditionAttribute, startConditionAttribute, endConditionAttribute)))
              .build();
      V2CreatePolicyOptions options = new V2CreatePolicyOptions.Builder()
              .type("access")
              .subject(policySubject)
              .control(policyControl)
              .resource(policyResource)
              .rule(policyRule)
              .pattern("time-based-conditions:weekly")
              .build();
      Response<V2Policy> response = service.v2CreatePolicy(options).execute();
      V2Policy policy = response.getResult();
      System.out.println(policy);

const policySubject = {
      attributes: [
        {
          key: 'iam_id',
          operator: 'stringEquals',
          value: exampleUserId,
        },
      ],
    };
    const policyResourceAccountAttribute = {
      key: 'accountId',
      value: exampleAccountId,
      operator: 'stringEquals',
    };
    const policyResourceServiceAttribute = {
      key: 'serviceName',
      operator: 'stringEquals',
      value: 'iam-groups',
    };
    const policyResource = {
      attributes: [policyResourceAccountAttribute, policyResourceServiceAttribute]
    };
    const policyControl = {
      grant: {
        roles: [{
          role_id: 'crn:v1:bluemix:public:iam::::role:Editor',
        }],
      }
    };
    const policyRule = {
      operator: 'and',
      conditions: [
          {
              key: '{{environment.attributes.day_of_week}}',
              operator: 'dayOfWeekAnyOf',
              value: [1, 2, 3, 4, 5],
          },
          {
              key: '{{environment.attributes.current_time}}',
              operator: 'timeGreaterThanOrEquals',
              value: '09:00:00+00:00',
          },
          {
              key: '{{environment.attributes.current_time}}',
              operator: 'timeLessThanOrEquals',
              value: '17:00:00+00:00',
          },
      ],
    }
    const policyPattern = 'time-based-conditions:weekly'
    const params = {
      type: 'access',
      subject: policySubject,
      control: policyControl,
      resource: policyResource,
      rule: policyRule,
      pattern: policyPattern,
    };
    try {
      const res = await iamPolicyManagementService.v2CreatePolicy(params);
      examplePolicyId = res.result.id;
      console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
      console.warn(err)
    }

policy_subject = V2PolicyBaseSubject(
                attributes=[V2PolicyAttribute(key='iam_id', value=example_user_id, operator='stringEquals')]
            )
            policy_role = PolicyRole(role_id='crn:v1:bluemix:public:iam::::role:Editor')
            account_id_resource_attribute = V2PolicyAttribute(
                key='accountId', value=example_account_id, operator='stringEquals'
            )
            service_name_resource_attribute = V2PolicyAttribute(
                key='serviceName', value='iam-groups', operator='stringEquals'
            )
            policy_resource = PolicyResource(
                attributes=[account_id_resource_attribute, service_name_resource_attribute],
            )
            policy_control = V2PolicyBaseControl(grant=V2PolicyBaseControlGrant(roles=[policy_role]))
            policy_rule = V2PolicyBaseRuleV2RuleWithConditions(
                operator='and',
                conditions=[
                    V2PolicyAttribute(
                        key='{{environment.attributes.day_of_week}}', operator='dayOfWeekAnyOf', value=[1, 2, 3, 4, 5]
                    ),
                    V2PolicyAttribute(
                        key='{{environment.attributes.current_time}}',
                        operator='timeGreaterThanOrEquals',
                        value='09:00:00+00:00',
                    ),
                    V2PolicyAttribute(
                        key='{{environment.attributes.current_time}}',
                        operator='timeLessThanOrEquals',
                        value='17:00:00+00:00',
                    ),
                ],
            )
            policy_pattern = 'time-based-conditions:weekly'
            policy = iam_policy_management_service.v2_create_policy(
                type='access',
                subject=policy_subject,
                control=policy_control,
                resource=policy_resource,
                rule=policy_rule,
                pattern=policy_pattern,
            ).get_result()
            print(json.dumps(policy, indent=2))

Pour plus d'informations sur les conditions temporelles des politiques d'accès, voir Conditions dans les politiques d'accès.

Création d'une condition basée sur un attribut de ressource à l'aide de la console

Vous pouvez attribuer un accès en spécifiant un attribut de ressource qui détermine les ressources auxquelles la condition donne accès. Par exemple, vous pouvez avoir un utilisateur qui doit présenter une démonstration dans votre compte en utilisant des ressources spécifiques. Pour plus d'informations et d'exemples sur les opérateurs disponibles, voir Conditions basées sur les attributs des ressources.

Vous pouvez avoir jusqu'à 10 conditions et une imbrication jusqu'à 2 niveaux en utilisant OR.

Effectuez les étapes suivantes pour attribuer une politique d'accès avec une condition basée sur les ressources de l'attribut :

  1. Dans la console IBM Cloud, allez dans Gérer > Accès (IAM)

  2. Sélectionnez Utilisateurs, Profils de confiance, ID de service ou Groupes d'accès, en fonction de l'entité à laquelle vous souhaitez attribuer un accès.

  3. Cliquez sur le nom de l'entité dans la liste et accédez à Accès.

  4. Cliquez sur Affecter un accès.

  5. Sélectionnez un service et cliquez sur Suivant.

    Tous les services ne prennent pas en charge les conditions basées sur les attributs des ressources. Pour continuer, sélectionnez un service qui prend en charge les conditions basées sur les attributs des ressources. Par exemple, Cloud Object Storage.

  6. Sélectionnez la ressource à laquelle vous souhaitez attribuer l'accès à l'utilisateur ou sélectionnez Toutes les ressources. Cliquez sur Suivant.

  7. (Facultatif) Sélectionnez un rôle d'accès au groupe de ressources. Cliquez sur Suivant.

  8. Sélectionnez n'importe quelle combinaison de rôles d'accès aux services et d'accès à la plate-forme, puis cliquez sur Suivant.

  9. Cliquez sur Ajouter une condition et sélectionnez Constructeur de conditions avancé > Suivant.

  10. Ajoutez les conditions de ressources et cliquez sur Créer.

Par exemple, disons que vous créez une politique conditionnelle pour un développeur qui a besoin d'accéder à tout ce qui se trouve sous les dossiers dev/David/ et dev/Secret/ OU à tout chemin qui commence par devOps/ ou cicd/. Dans ce cas, sélectionnez Prefix, string matches any of, et ajoutez dev/David/* et dev/Secret/*. Ensuite, ajoutez une condition OR et sélectionnez Path, string matches any of, et ajoutez devOps/* et cicd/*.

  1. Cliquez sur Créer> Réviser > Ajouter pour ajouter votre configuration d'accès à votre résumé d'accès.
  2. Cliquez sur Affecter.

Documentation spécifique au service

Pour plus d'informations sur la façon dont Cloud Object Storage utilise les conditions basées sur les attributs de ressources, voir Contrôle de l'accès aux objets individuels d'un panier.

Avant de commencer

Veillez à appeler l'URI v2/policies, c'est-à-dire https://iam.coud.ibm.com/v2/policies, afin de pouvoir utiliser des conditions dans vos politiques d'accès. Pour plus d'informations, voir l'API de gestion des politiques IAM et le journal des modifications.

Création de conditions basées sur les attributs des ressources à l'aide de l'API

Vous pouvez attribuer un accès en spécifiant un attribut de ressource qui détermine les ressources auxquelles la condition donne accès. Par exemple, disons que vous créez une politique conditionnelle pour un développeur qui a besoin d'accéder à tout ce qui se trouve sous les dossiers dev/David/* et devA/* ou à tout chemin qui commence par dev/David/* ou devA/*. L'exemple suivant montre comment créer une condition basée sur un attribut de ressource qui donne à l'utilisateur l'accès à tout ce qui se trouve sous le dossier dev/David/ et à tout chemin d'accès commençant par le dossier devA ou spécifiquement devA/.

Vous pouvez avoir jusqu'à 10 conditions et une imbrication jusqu'à 2 niveaux en utilisant OR.

Pour plus d'informations et d'exemples sur les opérateurs disponibles, voir Conditions basées sur les attributs des ressources.

"pattern": "attribute-based-condition:resource:literal-and-wildcard",
"rule": {
    "operator": "or",
    "conditions": [
      {
        "key": "{{resource.attributes.prefix}}",
        "operator": "stringMatchAnyOf",
        "value": [
          "dev/David/*",
          "devA*"
        ]
      },
      {
        "key": "{{resource.attributes.path}}",
        "operator": "stringMatchAnyOf",
        "value": [
          "dev/David/*",
          "devA/*"
        ]
      },
      {
        "operator": "and",
        "conditions": [
          {
            "key": "{{resource.attributes.prefix}}",
            "operator": "stringMatchAnyOf",
            "value": [
              "dev/David/*",
              "devA/*"
            ]
          },
          {
            "key": "{{resource.attributes.delimiter}}",
            "operator": "stringEquals",
            "value": "/"
          }
        ]
      }
    ]
  }