Limitare l'accesso con condizioni basate su attributi di tempo e risorse

È possibile impostare condizioni basate sul tempo per designare l'accesso temporaneo alle risorse dell'account o consentire l'accesso alle risorse durante finestre temporali specifiche, e condizioni basate sugli attributi delle risorse per evitare di creare più criteri di accesso per soddisfare le esigenze di accesso.

È possibile creare condizioni basate sul tempo che garantiscono l'accesso temporaneo una tantum per un intervallo di tempo e una data specifici, oppure impostare un accesso settimanale ricorrente. Ad esempio, potreste voler dare a un utente l'accesso alle risorse dell'account solo durante il suo orario di lavoro, specificando un accesso ricorrente, oppure potreste avere un appaltatore o un utente che ha bisogno di dimostrare le funzionalità di un servizio e ha bisogno solo di un accesso temporaneo.

Le condizioni basate sull'ora non tengono conto delle variazioni dell'ora legale (DST) per i fusi orari che osservano la DST. Gli amministratori devono aggiornare i criteri in base alle modifiche del DST per applicare con precisione le condizioni basate sul tempo. Ad esempio, il fuso orario orientale è UTC-4 ore durante l'ora legale anziché -5 ore come durante l'ora solare. L'ora solare inizia a novembre e termina a marzo, quando inizia la DST.

Il sito Kubernetes Service non rispetta le condizioni temporali. Ad esempio, un criterio con una condizione basata sul tempo che concede l'accesso a Tutti i servizi abilitati all'identità e all'accesso include l'accesso alle risorse di Kubernetes Service. L'oggetto del criterio ha accesso ad alcune risorse di Kubernetes Service al di fuori della condizione temporale specificata.

Le condizioni temporali per i criteri di accesso consentono di applicare il principio del minimo privilegio per l'assegnazione dell'accesso e di ridurre la superficie di attacco in caso di violazione della sicurezza.

Quando si crea un criterio con condizioni basate sugli attributi delle risorse, si può evitare di creare più criteri di accesso per soddisfare le esigenze di accesso. È invece possibile creare un singolo criterio utilizzando una combinazione di operatori OR/AND che vengono applicati agli attributi delle risorse con valori letterali o jolly. È possibile concedere l'accesso a una risorsa che soddisfa più criteri contemporaneamente (AND), oppure concedere l'accesso se una qualsiasi delle condizioni è soddisfatta (OR). Ad esempio, con le condizioni basate sugli attributi delle risorse, è possibile creare un singolo criterio che consenta l'accesso in base a Service instance: abc, O attribute-1: xyz, O (attribute-2: def E attribute-3: hij).

È necessario disporre di almeno 2 condizioni che utilizzino OR/AND e condizioni basate sugli attributi delle risorse. Se è necessario aggiungere una singola condizione, vedere Assegnazione dell'accesso alle risorse nella console e aggiungere la condizione dopo aver selezionato Risorse specifiche.

Per rivedere l'accesso di un utente, vedere Revisione dell'accesso assegnato nella console.

Modelli di condizione

Modelli di condizione basati sul tempo

I modelli seguenti rappresentano le permutazioni di condizioni consentite:

Modelli di condizione consentiti per le condizioni basate sul tempo.
Modello Esempio
condizioni basate sul tempo: una volta Accesso temporaneo in un giorno specifico dalle 9 alle 17 UTC-5.
condizioni basate sul tempo:settimanale:tutto il giorno Accesso ricorrente dal lunedì al venerdì UTC-5 tutto il giorno.
condizioni basate sul tempo:settimanale:ore personalizzate Accesso ricorrente dal lunedì al venerdì dalle 9.00 alle 17.00 UTC-5.

IAM impedisce di combinare condizioni temporanee una tantum con condizioni ricorrenti settimanali nella stessa definizione di criterio.

Modelli di condizione basati sugli attributi delle risorse

I modelli seguenti rappresentano le permutazioni di condizioni consentite:

Modelli di condizione consentiti per le condizioni basate sugli attributi delle risorse.
Modello Esempio
attribute-based-condition:resource:literal-and-wildcard Condizioni basate su attributi di risorse con valori letterali o jolly (in base all'operatore utilizzato)

Creare una condizione temporanea basata sul tempo utilizzando la console

È possibile assegnare l'accesso per una durata limitata, specificando una data e un intervallo di tempo che determinano quando la condizione concede e termina l'accesso. Ad esempio, potreste avere un utente che ha bisogno di presentare una dimostrazione sul vostro account per alcune ore o un appaltatore che ha bisogno di un accesso temporaneo a un servizio per un paio di giorni. Completare i passaggi seguenti per assegnare un criterio di accesso con una condizione temporanea basata sul tempo:

  1. Nella console IBM Cloud, accedere a Gestione > Accesso (IAM)

  2. Selezionare Utenti, Profili di fiducia, ID servizio o Gruppi di accesso, a seconda dell'entità a cui si desidera assegnare l'accesso.

  3. Fare clic sul nome dell'entità dall'elenco e andare su Accesso.

  4. Fai clic su Assegna accesso.

  5. Selezionare un servizio e fare clic su Avanti.

    • Se si desidera che l'utente possa creare qualsiasi servizio, selezionare Tutti i servizi abilitati all'identità e all'accesso.
    • Se si desidera assegnare all'utente l'accesso a un servizio specifico, selezionarlo dall'elenco.

  6. Selezionate la risorsa a cui volete assegnare l'accesso all'utente, oppure selezionate Tutte le risorse. Fai clic su Next.

  7. (Facoltativo) Selezionare un ruolo di accesso al gruppo di risorse. Fai clic su Next.

  8. Selezionare una qualsiasi combinazione di ruoli di accesso ai servizi e alla piattaforma e fare clic su Avanti.

  9. Fare clic su Aggiungi condizione e selezionare Una volta.

  10. Selezionare il fuso orario.

    Ad esempio, supponiamo che stiate creando una politica condizionale per uno sviluppatore con sede a Dublino. In questo caso, selezionare UTC+1 in modo che l'intervallo di date e orari selezionato nel passaggio successivo imponga l'accesso all'ora corretta per quella località.

  11. Completare i campi per la data e l'intervallo di tempo che determinano quando la condizione concede e termina l'accesso.

  12. Fai clic su Crea.

  13. Cliccare sulla recensione.

  14. Fare clic su Aggiungi per aggiungere la configurazione del criterio al riepilogo dei criteri.

  15. Fai clic su Assegna.

I criteri temporanei non vengono rimossi automaticamente. Per evitare di raggiungere il limite di policy nell'account, gli amministratori possono rimuovere manualmente la policy dopo la sua scadenza.

Per ulteriori informazioni sulle condizioni temporali per i criteri di accesso, vedere Condizioni nei criteri di accesso.

Prima di iniziare

Assicurarsi di disporre dell'ultima versione della CLI di IBM Cloud per poter utilizzare le condizioni nei criteri di accesso.

Per determinare la tua versione della CLI IBM Cloud, immetti il seguente comando:

ibmcloud -v

Devi utilizzare l'ultima versione della CLI. Se non utilizzi l'ultima versione, immetti il seguente comando per aggiornare la tua CLI:

ibmcloud update

Se stai eseguendo la release corrente, viene visualizzato il seguente output:

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

Per ulteriori informazioni, vedere Installazione della CLI stand-alone IBM Cloud.

Creazione di una condizione temporanea basata sul tempo mediante l'uso della CLI

È possibile assegnare l'accesso per una durata limitata, specificando una data e un intervallo di tempo che determinano quando la condizione concede e termina l'accesso. Ad esempio, potreste avere un utente che ha bisogno di presentare una dimostrazione sul vostro account per alcune ore o un appaltatore che ha bisogno di un accesso temporaneo a un servizio per un paio di giorni. L'esempio seguente mostra come creare una condizione temporale unica per l'account, concedendo all'utente l'accesso temporaneo come Operatore per tutti i servizi di Gestione account.

  1. Accedere a IBM Cloud® CLI. Se hai più account, ti viene richiesto di selezionare quale account utilizzare. Se non specifichi una regione con l'indicatore -r, devi selezionare anche una regione.

    ibmcloud login

    Se le tue credenziali vengono rifiutate, è possibile che tu stia utilizzando un ID federato. Per eseguire l'accesso con un ID federato, utilizza l'indicatore --sso. Per ulteriori dettagli, vedi Accesso con un ID federato.

    Se è la prima volta che si utilizza la CLI di IBM Cloud, consultare l'esercitazione per iniziare.

  2. Creare un criterio di accesso e assegnarlo a un utente o a un ID servizio utilizzando il comando ibmcloud iam user-policy-create.

  3. Assegnare l'accesso a tutti i servizi di Gestione account con il ruolo Operator:

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

  4. Utilizzare il seguente esempio di schema JSON di un criterio temporaneo basato sul tempo per creare le proprie condizioni:

    {
  "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"
      }
    ]
  }
}

I criteri temporanei, che utilizzano il modello time-based-conditions:once, non vengono rimossi automaticamente. Per evitare di raggiungere il limite di policy nell'account, gli amministratori possono rimuovere manualmente la policy dopo la sua scadenza.

Per ulteriori informazioni sulle condizioni temporali per i criteri di accesso, vedere Condizioni nei criteri di accesso.

Prima di iniziare

Assicurarsi di chiamare l'URI v2/policies, che è https://iam.coud.ibm.com/v2/policies, in modo da poter utilizzare le condizioni nei criteri di accesso. Per ulteriori informazioni, consultare l'API di gestione dei criteri IAM e il registro delle modifiche.

Creare una condizione temporanea basata sul tempo utilizzando l'API

È possibile assegnare l'accesso per una durata limitata, specificando una data e un intervallo di tempo che determinano quando la condizione concede e termina l'accesso. Ad esempio, potreste avere un utente che ha bisogno di presentare una dimostrazione sul vostro account per alcune ore o un appaltatore che ha bisogno di un accesso temporaneo a un servizio per un paio di giorni. Gli esempi seguenti mostrano come creare una condizione temporale unica per l'account, concedendo all'utente l'accesso temporaneo come Operatore per tutti i servizi di Gestione account.

	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))

I criteri temporanei, che utilizzano il modello time-based-conditions:once, non vengono rimossi automaticamente. Per evitare di raggiungere il limite di policy nell'account, gli amministratori possono rimuovere manualmente la policy dopo la sua scadenza.

Per ulteriori informazioni sulle condizioni temporali per i criteri di accesso, vedere Condizioni nei criteri di accesso.

Creare una condizione ricorrente basata sul tempo utilizzando la console

È possibile assegnare accessi ricorrenti con cadenza settimanale. Potreste voler dare agli utenti l'accesso alle risorse dell'account solo durante il loro orario di lavoro. Completate i seguenti passaggi per assegnare un criterio di accesso con una condizione ricorrente basata sul tempo:

  1. Nella console IBM Cloud, accedere a Gestione > Accesso (IAM)

  2. Selezionare Utenti, Profili di fiducia, ID servizio o Gruppi di accesso, a seconda dell'entità a cui si desidera assegnare l'accesso.

  3. Fare clic sul nome dell'identità dall'elenco e andare su Accesso.

  4. Fai clic su Assegna accesso.

  5. Selezionare un servizio e fare clic su Avanti.

    • Se si desidera che l'utente possa creare qualsiasi servizio, selezionare Tutti i servizi abilitati all'identità e all'accesso.
    • Se si desidera assegnare all'utente l'accesso a un servizio specifico, selezionarlo dall'elenco.

  6. Selezionate la risorsa a cui volete assegnare l'accesso all'utente, oppure selezionate Tutte le risorse. Fai clic su Next.

  7. (Facoltativo) Selezionare un ruolo di accesso al gruppo di risorse. Fai clic su Next.

  8. Selezionare una qualsiasi combinazione di ruoli di accesso ai servizi e alla piattaforma e fare clic su Avanti.

  9. Fare clic su Aggiungi condizione e selezionare Settimanale.

  10. Selezionare il fuso orario per il criterio condizionale.

    Ad esempio, supponiamo che stiate creando una politica condizionale per uno sviluppatore con sede a Dublino. In questo caso, selezionare UTC+1 in modo che l'intervallo di date e orari selezionato successivamente venga applicato all'ora corretta per quella località.

  11. Selezionare i giorni della settimana in cui si desidera che la condizione garantisca l'accesso.

    • (Facoltativo) Impostare l'opzione Tutti i giorni su No per specificare un intervallo di tempo per i giorni selezionati.

  12. Fai clic su Crea.

  13. Cliccare sulla recensione.

  14. Fare clic su Aggiungi per aggiungere la configurazione del criterio al riepilogo dei criteri.

  15. Fai clic su Assegna.

Per ulteriori informazioni sulle condizioni temporali per i criteri di accesso, vedere Condizioni nei criteri di accesso.

Creazione di una condizione ricorrente basata sul tempo tramite la CLI

È possibile assegnare accessi ricorrenti con cadenza settimanale. Potreste voler dare agli utenti l'accesso alle risorse dell'account solo durante il loro orario di lavoro. L'esempio seguente mostra come creare una condizione ricorrente basata sul tempo per un utente. La politica assegna l'accesso durante l'orario di lavoro dal lunedì al venerdì come redattore per tutti i servizi di gestione degli account.

  1. Accedere a IBM Cloud® CLI. Se hai più account, ti viene richiesto di selezionare quale account utilizzare. Se non specifichi una regione con l'indicatore -r, devi selezionare anche una regione.

    ibmcloud login

    Se le tue credenziali vengono rifiutate, è possibile che tu stia utilizzando un ID federato. Per eseguire l'accesso con un ID federato, utilizza l'indicatore --sso. Per ulteriori dettagli, vedi Accesso con un ID federato.

    Se è la prima volta che si utilizza la CLI di IBM Cloud, consultare l'esercitazione per iniziare.

  2. Creare un criterio di accesso e assegnarlo a un utente o a un ID servizio utilizzando il comando ibmcloud iam user-policy-create.

  3. Assegnare l'accesso a tutti i servizi di Gestione account con il ruolo Editor:

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

  4. Utilizzare il seguente esempio di schema JSON di un criterio ricorrente basato sul tempo per creare le proprie condizioni:

    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"
      }
    ]
  }
}

Per ulteriori informazioni sulle condizioni temporali per i criteri di accesso, vedere Condizioni nei criteri di accesso.

Creazione di una condizione ricorrente basata sul tempo utilizzando l'API

È possibile assegnare accessi ricorrenti con cadenza settimanale. Potreste voler dare agli utenti l'accesso alle risorse dell'account solo durante il loro orario di lavoro. Gli esempi seguenti mostrano come creare una condizione ricorrente basata sul tempo per un utente. La politica assegna l'accesso durante l'orario di lavoro dal lunedì al venerdì come redattore per tutti i servizi di gestione degli account.

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))

Per ulteriori informazioni sulle condizioni temporali per i criteri di accesso, vedere Condizioni nei criteri di accesso.

Creare una condizione basata sugli attributi delle risorse utilizzando la console

È possibile assegnare l'accesso specificando un attributo di risorsa che determina le risorse a cui la condizione concede l'accesso. Ad esempio, si potrebbe avere un utente che ha bisogno di presentare una dimostrazione nel proprio account utilizzando risorse specifiche. Per ulteriori informazioni ed esempi sugli operatori disponibili, vedere Condizioni basate sugli attributi delle risorse.

È possibile avere fino a 10 condizioni e annidare fino a 2 livelli utilizzando OR.

Completare i passaggi seguenti per assegnare un criterio di accesso con una condizione basata sulle risorse dell'attributo:

  1. Nella console IBM Cloud, accedere a Gestione > Accesso (IAM)

  2. Selezionare Utenti, Profili di fiducia, ID servizio o Gruppi di accesso, a seconda dell'entità a cui si desidera assegnare l'accesso.

  3. Fare clic sul nome dell'entità dall'elenco e andare su Accesso.

  4. Fai clic su Assegna accesso.

  5. Selezionare un servizio e fare clic su Avanti.

    Non tutti i servizi supportano condizioni basate sugli attributi delle risorse. Per continuare, selezionare un servizio che supporti le condizioni basate sugli attributi delle risorse. Ad esempio, Cloud Object Storage.

  6. Selezionate la risorsa a cui volete assegnare l'accesso all'utente, oppure selezionate Tutte le risorse. Fai clic su Next.

  7. (Facoltativo) Selezionare un ruolo di accesso al gruppo di risorse. Fai clic su Next.

  8. Selezionare una qualsiasi combinazione di ruoli di accesso ai servizi e alla piattaforma e fare clic su Avanti.

  9. Fare clic su Aggiungi condizione e selezionare Costruttore di condizioni avanzato > Avanti.

  10. Aggiungete le condizioni della risorsa e fate clic su Crea.

Ad esempio, supponiamo di creare un criterio condizionale per uno sviluppatore che ha bisogno di accedere a tutto ciò che si trova nelle cartelle dev/David/ e dev/Secret/ OPPURE a qualsiasi percorso che inizi con devOps/ o cicd/. In questo caso, selezionare Prefisso, stringa corrisponde a qualsiasi di e aggiungere dev/David/* e dev/Secret/*. Quindi, aggiungere una condizione OR e selezionare Path, stringa corrisponde a qualsiasi di, e aggiungere devOps/* e cicd/*.

  1. Fare clic su Crea > Rivedi > Aggiungi per aggiungere la configurazione di accesso al riepilogo degli accessi.
  2. Fai clic su Assegna.

Documentazione specifica del servizio

Per ulteriori informazioni su come Cloud Object Storage utilizza le condizioni basate sugli attributi delle risorse, vedere Controllo dell'accesso ai singoli oggetti in un bucket.

Prima di iniziare

Assicurarsi di chiamare l'URI v2/policies, che è https://iam.coud.ibm.com/v2/policies, in modo da poter utilizzare le condizioni nei criteri di accesso. Per ulteriori informazioni, consultare l'API di gestione dei criteri IAM e il registro delle modifiche.

Creare condizioni basate sugli attributi delle risorse utilizzando l'API

È possibile assegnare l'accesso specificando un attributo di risorsa che determina le risorse a cui la condizione concede l'accesso. Ad esempio, supponiamo di creare un criterio condizionale per uno sviluppatore che ha bisogno di accedere a tutto ciò che si trova nelle cartelle dev/David/* e devA/* o a qualsiasi percorso che inizi con dev/David/* o devA/*. L'esempio seguente mostra come creare una condizione basata sugli attributi delle risorse che dia all'utente l'accesso a tutto ciò che si trova nella cartella dev/David/ e a qualsiasi percorso che inizi con la cartella devA o specificamente devA/.

È possibile avere fino a 10 condizioni e annidare fino a 2 livelli utilizzando OR.

Per ulteriori informazioni ed esempi sugli operatori disponibili, vedere Condizioni basate sugli attributi delle risorse.

"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": "/"
          }
        ]
      }
    ]
  }