Limitar o acesso com condições baseadas em atributos de tempo e recursos

Você pode configurar condições baseadas em tempo para designar acesso temporário a recursos em sua conta ou permitir o acesso a recursos durante janelas de tempo específicas, e condições baseadas em atributos de recursos para evitar a criação de várias políticas de acesso para atender às suas necessidades de acesso.

Você pode criar condições baseadas no tempo que concedem acesso temporário único para um intervalo de data e hora específico ou pode configurar um acesso semanal recorrente. Por exemplo, talvez você queira dar a um usuário acesso aos recursos da conta somente durante o horário de trabalho, especificando o acesso recorrente, ou talvez você tenha um contratado ou um usuário que precise fazer uma demonstração dos recursos de um serviço e precise apenas de acesso temporário.

As condições baseadas no horário não levam em conta as alterações do horário de verão para os fusos horários que observam o horário de verão. Os administradores devem atualizar as políticas de acordo com as alterações do horário de verão para aplicar com precisão as condições baseadas em tempo. Por exemplo, o fuso horário do leste é UTC-4 horas durante o horário de verão, em vez de -5 horas como no horário padrão. O horário padrão começa em novembro e termina em março, quando começa o horário de verão.

O site Kubernetes Service não adere a condições baseadas em tempo. Por exemplo, uma política com uma condição baseada em tempo que concede acesso a todos os serviços habilitados para Identidade e Acesso inclui o acesso aos recursos do site Kubernetes Service. O sujeito da política tem acesso a alguns recursos do Kubernetes Service fora da condição baseada em tempo especificada.

As condições baseadas em tempo para políticas de acesso ajudam você a aplicar o princípio do menor privilégio para atribuir acesso e reduzir a superfície de ataque caso ocorra uma violação de segurança.

Quando você cria uma política com condições baseadas em atributos de recursos, é possível evitar a criação de várias políticas de acesso para atender às suas necessidades de acesso. Em vez disso, você pode criar uma única política usando uma combinação de operadores OR/AND que são aplicados em atributos de recursos com valores literais ou curingas. Você pode conceder acesso a um recurso que atenda a vários critérios simultaneamente (AND) ou conceder acesso se qualquer uma das várias condições for atendida (OR). Por exemplo, com condições baseadas em atributos de recursos, você pode criar uma única política que permita o acesso com base em Service instance: abc, OU attribute-1: xyz, OU (attribute-2: def E attribute-3: hij).

Você deve ter no mínimo duas condições que usem OR/AND e condições baseadas em atributos de recursos. Se precisar adicionar uma única condição, consulte Atribuição de acesso a recursos no console e adicione a condição após selecionar Recursos específicos.

Para revisar o acesso de um usuário, consulte Revisão do acesso atribuído no console.

Padrões de condição

Padrões de condição baseados no tempo

Os padrões a seguir representam as permutações de condições permitidas:

Padrões de condição permitidos para condições baseadas em tempo.
Padrão	Exemplo
time-based-conditions:once	Acesso temporário em um dia específico, das 9h às 17h UTC-5.
time-based-conditions:weekly:all-day	Acesso recorrente de segunda a sexta UTC-5 o dia todo.
time-based-conditions:weekly:custom-hours	Acesso recorrente de segunda a sexta, das 9h às 17h UTC-5.

O IAM impede a combinação de condições temporárias únicas com condições recorrentes semanais na mesma definição de política.

Padrões de condição baseados em atributos de recursos

Os padrões a seguir representam as permutações de condições permitidas:

Padrões de condição permitidos para condições baseadas em atributos de recursos.
Padrão	Exemplo
`attribute-based-condition:resource:literal-and-wildcard`	Condições baseadas em atributos de recursos com valores literais ou curingas (com base no operador usado)

Criação de uma condição temporária baseada no tempo usando o console

Você pode atribuir acesso por uma duração finita, especificando um intervalo de data e hora que determina quando a condição concede e encerra o acesso. Por exemplo, você pode ter um usuário que precise apresentar uma demonstração em sua conta por algumas horas ou um contratado que precise de acesso temporário a um serviço por alguns dias. Conclua as etapas a seguir para atribuir uma política de acesso com uma condição temporária baseada em tempo:

No console IBM Cloud, vá para Gerenciar > Acesso (IAM)
Selecione Usuários, Perfis confiáveis, IDs de serviço ou Grupos de acesso, dependendo da entidade à qual você deseja atribuir acesso.
Clique no nome da entidade na lista e vá para Access (Acesso ).
Clique em Designar acesso.
Selecione um serviço e clique em Next.
- Se você deseja que o usuário possa criar qualquer serviço, selecione Todos os serviços ativados do Identity and Access.
- Se você desejar designar o acesso do usuário a um serviço específico, selecione-o na lista.
Selecione o recurso ao qual deseja atribuir o acesso do usuário ou selecione Todos os recursos. Clique em Avançar.
(Opcional) Selecione uma função de acesso ao grupo de recursos. Clique em Avançar.
Selecione qualquer combinação de funções de acesso ao serviço e de acesso à plataforma e clique em Next.
Clique em Add condition e selecione One-time.
Selecione o fuso horário.

Por exemplo, digamos que você esteja criando uma política condicional para um desenvolvedor que mora em Dublin. Nesse caso, selecione UTC+1 para que o intervalo de data e hora que você selecionar na próxima etapa imponha o acesso no horário correto para esse local.
Preencha os campos para o intervalo de data e hora que determina quando a condição concede e encerra o acesso.
Clique em Criar.
Clique em Revisar.
Clique em Incluir para incluir sua configuração de política em seu resumo de política.
Clique em Designar.

As políticas temporárias não são removidas automaticamente. Para evitar atingir o limite da política na conta, os administradores podem remover a política manualmente depois que ela expirar.

Para obter mais informações sobre condições baseadas em tempo para políticas de acesso, consulte Condições em políticas de acesso.

Antes de Iniciar

Verifique se você tem a versão mais recente da CLI do IBM Cloud para poder usar condições em suas políticas de acesso.

Para determinar a versão da CLI do IBM Cloud, execute o comando a seguir:

ibmcloud -v

Deve-se usar a versão mais recente da CLI. Se você não estiver usando a versão mais recente, execute o comando a seguir para atualizar sua CLI:

ibmcloud update

Se você estiver executando a liberação atual, a saída a seguir será exibida:

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

Para obter mais informações, consulte Instalação da CLI autônoma do IBM Cloud.

Criação de uma condição temporária baseada em tempo usando a CLI

Você pode atribuir acesso por uma duração finita, especificando um intervalo de data e hora que determina quando a condição concede e encerra o acesso. Por exemplo, você pode ter um usuário que precise apresentar uma demonstração em sua conta por algumas horas ou um contratado que precise de acesso temporário a um serviço por alguns dias. O exemplo a seguir mostra como criar uma condição única baseada em tempo para sua conta, concedendo ao usuário acesso temporário como Operador para todos os serviços de gerenciamento de contas.

Efetue login na CLI da IBM Cloud®. Se você tiver múltiplas contas, deverá selecionar qual conta usar. Se você não especificar uma região com o sinalizador -r, deverá também selecionar uma região.
```
ibmcloud login
```
Se as suas credenciais forem rejeitadas, talvez você esteja usando um ID federado. Para efetuar login com um ID federado, use a sinalização --sso. Consulte Efetuando login com um ID federado para obter mais detalhes.

Se é a primeira vez que você está usando a CLI do IBM Cloud, consulte o tutorial de introdução.
Crie uma política de acesso e atribua-a a um usuário ou a um ID de serviço usando o comando ibmcloud iam user-policy-create.

Atribua acesso aos serviços All Account Management com a função Operator:

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

Use o exemplo a seguir de um esquema JSON de política temporária baseada em tempo para criar suas próprias condições:

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

As políticas temporárias, que usam o padrão time-based-conditions:once, não são removidas automaticamente. Para evitar atingir o limite da política na conta, os administradores podem remover a política manualmente depois que ela expirar.

Para obter mais informações sobre condições baseadas em tempo para políticas de acesso, consulte Condições em políticas de acesso.

Antes de Iniciar

Certifique-se de chamar o URI v2/policies, que é https://iam.coud.ibm.com/v2/policies, para que você possa usar condições em suas políticas de acesso. Para obter mais informações, consulte a API de gerenciamento de políticas do IAM e o registro de alterações.

Criação de uma condição temporária baseada no tempo usando a API

Você pode atribuir acesso por uma duração finita, especificando um intervalo de data e hora que determina quando a condição concede e encerra o acesso. Por exemplo, você pode ter um usuário que precise apresentar uma demonstração em sua conta por algumas horas ou um contratado que precise de acesso temporário a um serviço por alguns dias. Os exemplos a seguir mostram como criar uma condição única baseada no tempo para sua conta, concedendo ao usuário acesso temporário como Operador para todos os Serviços de Gerenciamento de Contas.

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

Para obter mais informações sobre condições baseadas em tempo para políticas de acesso, consulte Condições em políticas de acesso.

Criação de uma condição recorrente baseada no tempo usando o console

Você pode atribuir acesso recorrente em uma cadência semanal. Talvez você queira dar aos usuários acesso aos recursos da conta somente durante o horário de trabalho. Conclua as etapas a seguir para atribuir uma política de acesso com uma condição recorrente baseada em tempo:

No console IBM Cloud, vá para Gerenciar > Acesso (IAM)
Selecione Usuários, Perfis confiáveis, IDs de serviço ou Grupos de acesso, dependendo da entidade à qual você deseja atribuir acesso.
Clique no nome da identidade na lista e vá para Access (Acesso ).
Clique em Designar acesso.
Selecione um serviço e clique em Next.
- Se você deseja que o usuário possa criar qualquer serviço, selecione Todos os serviços ativados do Identity and Access.
- Se você desejar designar o acesso do usuário a um serviço específico, selecione-o na lista.
Selecione o recurso ao qual deseja atribuir o acesso do usuário ou selecione Todos os recursos. Clique em Avançar.
(Opcional) Selecione uma função de acesso ao grupo de recursos. Clique em Avançar.
Selecione qualquer combinação de funções de acesso ao serviço e de acesso à plataforma e clique em Next.
Clique em Adicionar condição e selecione Semanal.
Selecione o fuso horário para a política condicional.

Por exemplo, digamos que você esteja criando uma política condicional para um desenvolvedor que mora em Dublin. Nesse caso, selecione UTC+1 para que o intervalo de data e hora que você selecionar em seguida seja aplicado no horário correto para esse local.
Selecione os dias da semana em que você deseja que a condição conceda acesso.
- (Opcional) Defina a opção All day (Todos os dias ) como No (Não) para especificar um período de tempo para os dias que você selecionar.
Clique em Criar.
Clique em Revisar.
Clique em Incluir para incluir sua configuração de política em seu resumo de política.
Clique em Designar.

Para obter mais informações sobre condições baseadas em tempo para políticas de acesso, consulte Condições em políticas de acesso.

Criação de uma condição recorrente baseada em tempo usando a CLI

Você pode atribuir acesso recorrente em uma cadência semanal. Talvez você queira dar aos usuários acesso aos recursos da conta somente durante o horário de trabalho. O exemplo a seguir mostra como criar uma condição recorrente baseada em tempo para um usuário. A política atribui acesso durante o horário de trabalho, de segunda a sexta-feira, como editor de todos os serviços de gerenciamento de contas.

Efetue login na CLI da IBM Cloud®. Se você tiver múltiplas contas, deverá selecionar qual conta usar. Se você não especificar uma região com o sinalizador -r, deverá também selecionar uma região.
```
ibmcloud login
```
Se as suas credenciais forem rejeitadas, talvez você esteja usando um ID federado. Para efetuar login com um ID federado, use a sinalização --sso. Consulte Efetuando login com um ID federado para obter mais detalhes.

Se esta for a sua primeira vez usando a CLI da IBM Cloud, confira o tutorial de introdução.
Crie uma política de acesso e atribua-a a um usuário ou a um ID de serviço usando o comando ibmcloud iam user-policy-create.

Atribua acesso aos serviços All Account Management com a função Editor:

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

Use o exemplo a seguir de um esquema JSON de política recorrente baseada em tempo para criar suas próprias condições:

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

Para obter mais informações sobre condições baseadas em tempo para políticas de acesso, consulte Condições em políticas de acesso.

Criação de uma condição recorrente baseada no tempo usando a API

Você pode atribuir acesso recorrente em uma cadência semanal. Talvez você queira dar aos usuários acesso aos recursos da conta somente durante o horário de trabalho. Os exemplos a seguir mostram como criar uma condição recorrente baseada em tempo para um usuário. A política atribui acesso durante o horário de trabalho, de segunda a sexta-feira, como editor de todos os serviços de gerenciamento de contas.

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

Para obter mais informações sobre condições baseadas em tempo para políticas de acesso, consulte Condições em políticas de acesso.

Criação de uma condição baseada em atributos de recursos usando o console

Você pode atribuir acesso especificando um atributo de recurso que determina a quais recursos a condição concede acesso. Por exemplo, talvez você tenha um usuário que precise apresentar uma demonstração em sua conta usando recursos específicos. Para obter mais informações e exemplos sobre os operadores disponíveis, consulte Condições baseadas em atributos de recursos.

Você pode ter até 10 condições e aninhamento de até 2 níveis usando OR.

Conclua as etapas a seguir para atribuir uma política de acesso com uma condição baseada em recursos de atributo:

No console IBM Cloud, vá para Gerenciar > Acesso (IAM)
Selecione Usuários, Perfis confiáveis, IDs de serviço ou Grupos de acesso, dependendo da entidade à qual você deseja atribuir acesso.
Clique no nome da entidade na lista e vá para Access (Acesso ).
Clique em Designar acesso.
Selecione um serviço e clique em Next.

Nem todos os serviços suportam condições baseadas em atributos de recursos. Para continuar, selecione um serviço que ofereça suporte a condições baseadas em atributos de recursos. Por exemplo, Cloud Object Storage.
Selecione o recurso ao qual deseja atribuir o acesso do usuário ou selecione Todos os recursos. Clique em Avançar.
(Opcional) Selecione uma função de acesso ao grupo de recursos. Clique em Avançar.
Selecione qualquer combinação de funções de acesso ao serviço e de acesso à plataforma e clique em Next.
Clique em Adicionar condição e selecione Construtor de condição avançado > Avançar.
Adicione as condições do recurso e clique em Create (Criar ).

Como exemplo, digamos que você esteja criando uma política condicional para um desenvolvedor que precisa acessar tudo o que está nas pastas dev/David/ e dev/Secret/ OU qualquer caminho que comece com devOps/ ou cicd/. Nesse caso, selecione Prefixo, a cadeia de caracteres corresponde a qualquer um de, e adicione dev/David/* e dev/Secret/*. Em seguida, adicione uma condição OR e selecione Path, string matches any of, e adicione devOps/* e cicd/*.

Clique em Criar > Revisar > Adicionar para adicionar sua configuração de acesso ao resumo de acesso.
Clique em Designar.

Documentação específica do serviço

Para obter mais informações sobre como o site Cloud Object Storage usa condições baseadas em atributos de recursos, consulte Controle de acesso a objetos individuais em um bucket.

Antes de Iniciar

Criação de condições baseadas em atributos de recursos usando a API

Você pode atribuir acesso especificando um atributo de recurso que determina a quais recursos a condição concede acesso. Como exemplo, digamos que você esteja criando uma política condicional para um desenvolvedor que precisa acessar tudo o que está nas pastas dev/David/* e devA/* ou qualquer caminho que comece com dev/David/* ou devA/*. O exemplo a seguir mostra como criar uma condição baseada em atributos de recursos que dá ao usuário acesso a tudo o que estiver na pasta dev/David/ e a qualquer caminho que comece com a pasta devA ou, especificamente, devA/.

Você pode ter até 10 condições e aninhamento de até 2 níveis usando OR.

Para obter mais informações e exemplos sobre os operadores disponíveis, consulte Condições baseadas em atributos de recursos.

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