Limitar el acceso con condiciones basadas en atributos de tiempo y recursos

Puede configurar condiciones basadas en el tiempo para designar el acceso temporal a los recursos de su cuenta o permitir el acceso a los recursos durante ventanas de tiempo específicas, y condiciones basadas en atributos de recursos para evitar la creación de múltiples políticas de acceso para satisfacer sus necesidades de acceso.

Puede crear condiciones basadas en el tiempo que concedan un acceso temporal único para un intervalo específico de tiempo y fecha, o puede configurar un acceso semanal recurrente. Por ejemplo, puede que desee dar a un usuario acceso a los recursos de la cuenta sólo durante sus horas de trabajo especificando un acceso recurrente, o puede que tenga un contratista o un usuario que necesite hacer una demostración de las características de un servicio y sólo necesite un acceso temporal.

Las condiciones basadas en la hora no tienen en cuenta los cambios del horario de verano (DST) para las zonas horarias que observan el DST. Los administradores deben actualizar las políticas según los cambios de DST para aplicar con precisión las condiciones basadas en la hora. Por ejemplo, la zona horaria del Este es UTC-4 horas durante el horario de verano en lugar de -5 horas como lo es durante el horario estándar. La hora estándar comienza en noviembre y termina en marzo, cuando empieza el horario de verano.

El sitio Kubernetes Service no se atiene a condiciones temporales. Por ejemplo, una política con una condición basada en el tiempo que concede acceso a todos los servicios habilitados de Identidad y Acceso incluye el acceso a los recursos de Kubernetes Service. El sujeto de la política tiene acceso a algunos recursos de Kubernetes Service fuera de la condición temporal especificada.

Las condiciones basadas en el tiempo para las políticas de acceso le ayudan a aplicar el principio del menor privilegio para asignar el acceso y reducir la superficie de ataque si se produce una violación de la seguridad.

Al crear una política con condiciones basadas en atributos de recursos, puede evitar la creación de múltiples políticas de acceso para satisfacer sus necesidades de acceso. En su lugar, puede crear una única política utilizando una combinación de operadores OR/AND que se aplican sobre atributos de recursos con valores literales o comodines. Puede conceder acceso a un recurso que cumpla varios criterios simultáneamente (AND), o conceder acceso si se cumple alguna de varias condiciones (OR). Por ejemplo, con las condiciones basadas en atributos de recursos, puede crear una única política que permita el acceso en función de Service instance: abc, O attribute-1: xyz, O (attribute-2: def Y attribute-3: hij).

Debe tener un mínimo de 2 condiciones que utilicen OR/AND y condiciones basadas en atributos de recursos. Si necesita añadir una única condición, consulte Asignación de acceso a recursos en la consola y añada la condición después de seleccionar Recursos específicos.

Para revisar el acceso de un usuario, consulte Revisión del acceso asignado en la consola.

Patrones de condición

Patrones de condiciones temporales

Los siguientes patrones representan las permutaciones de condiciones permitidas:

Patrones de condiciones permitidos para condiciones basadas en el tiempo.
Patrón	Ejemplo
condiciones temporales:una vez	Acceso temporal un día concreto de 9 a 17 horas UTC-5.
condiciones temporales:semanal:todo el día	Acceso recurrente de lunes a viernes UTC-5 todo el día.
condiciones basadas en el tiempo:semanales:horas personalizadas	Acceso recurrente de lunes a viernes de 9 a 17 horas UTC-5.

IAM impide combinar condiciones temporales únicas con condiciones recurrentes semanales en la misma definición de política.

Patrones de condiciones basados en atributos de recursos

Los siguientes patrones representan las permutaciones de condiciones permitidas:

Patrones de condiciones permitidos para las condiciones basadas en atributos de recursos.
Patrón	Ejemplo
`attribute-based-condition:resource:literal-and-wildcard`	Condiciones basadas en atributos de recursos con valores literales o comodines (en función del operador utilizado)

Creación de una condición temporal basada en el tiempo mediante la consola

Puede asignar acceso para una duración finita especificando un intervalo de fecha y hora que determine cuándo la condición concede y termina el acceso. Por ejemplo, puede tener un usuario que necesite presentar una demostración en su cuenta durante unas horas o un contratista que necesite acceso temporal a un servicio durante un par de días. Complete los siguientes pasos para asignar una política de acceso con una condición temporal basada en el tiempo:

En la consola IBM Cloud, vaya a Gestionar > Acceso (IAM)
Seleccione Usuarios, Perfiles de confianza, ID de servicio o Grupos de acceso, en función de la entidad a la que desee asignar el acceso.
Haga clic en el nombre de la entidad de la lista y vaya a Acceso.
Pulse Asignar acceso.
Seleccione un servicio y haga clic en Siguiente.
- Si desea que el usuario pueda crear cualquier servicio, seleccione Todos los servicios habilitados para identidad y acceso.
- Si desea asignar acceso al usuario a un servicio específico, selecciónelo de la lista.
Seleccione el recurso al que desea asignar acceso al usuario, o seleccione Todos los recursos. Pulse Siguiente.
(Opcional) Seleccione una función de acceso al grupo de recursos. Pulse Siguiente.
Seleccione cualquier combinación de funciones de acceso a servicios y acceso a plataformas y haga clic en Siguiente.
Haga clic en Añadir condición y seleccione Una sola vez.
Seleccione el huso horario.

Por ejemplo, supongamos que está creando una política condicional para un desarrollador con sede en Dublín. En este caso, seleccione UTC+1 para que el intervalo de fechas y horas que seleccione en el siguiente paso imponga el acceso a la hora correcta para esa ubicación.
Rellene los campos para el intervalo de fechas y horas que determina cuándo la condición concede y finaliza el acceso.
Pulse Crear.
Pulse Revisar.
Pulse Añadir para añadir la configuración de política a su resumen de políticas.
Pulse Asignar.

Las políticas temporales no se eliminan automáticamente. Para evitar alcanzar el límite de políticas en la cuenta, los administradores pueden eliminar la política manualmente después de que expire.

Para obtener más información sobre las condiciones basadas en el tiempo para las políticas de acceso, consulte Condiciones de las políticas de acceso.

Antes de empezar

Asegúrese de que dispone de la última versión de la CLI IBM Cloud para poder utilizar condiciones en sus políticas de acceso.

Para determinar la versión de la CLI de IBM Cloud, ejecute el siguiente mandato:

ibmcloud -v

Debe utilizar la versión más reciente de la CLI. Si no está utilizando la versión más reciente, ejecute el mandato siguiente para actualizar la CLI:

ibmcloud update

Si está ejecutando el release actual, se visualiza la salida siguiente:

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

Para obtener más información, consulte Instalación de la CLI independiente IBM Cloud.

Creación de una condición temporal basada en el tiempo mediante la CLI

Puede asignar acceso para una duración finita especificando un intervalo de fecha y hora que determine cuándo la condición concede y termina el acceso. Por ejemplo, puede tener un usuario que necesite presentar una demostración en su cuenta durante unas horas o un contratista que necesite acceso temporal a un servicio durante un par de días. El siguiente ejemplo muestra cómo crear una condición temporal única para su cuenta concediendo al usuario acceso temporal como Operador para todos los Servicios de Gestión de Cuentas.

Inicie sesión en la CLI de IBM Cloud®. Si tiene varias cuentas, se le solicitará que seleccione qué cuenta desea utilizar. Si no especifica una región con el distintivo -r, también deberá seleccionar una región.
```
ibmcloud login
```
Si se rechazan sus credenciales, puede que esté utilizando un ID federado. Para iniciar sesión con un ID federado, utilice el distintivo --sso. Consulte Inicio de sesión con un ID federado para obtener más detalles.

Si es la primera vez que utiliza la CLI de IBM Cloud, consulte el tutorial de introducción.
Cree una política de acceso y asígnela a un usuario o a un ID de servicio mediante el comando ibmcloud iam user-policy-create.

Asigne acceso a los servicios de gestión de todas las cuentas con la función Operator:

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

Utilice el siguiente ejemplo de esquema JSON de una política temporal basada en el tiempo para crear sus propias condiciones:

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

Las políticas temporales, que utilizan el patrón time-based-conditions:once, no se eliminan automáticamente. Para evitar alcanzar el límite de políticas en la cuenta, los administradores pueden eliminar la política manualmente después de que expire.

Para obtener más información sobre las condiciones basadas en el tiempo para las políticas de acceso, consulte Condiciones de las políticas de acceso.

Antes de empezar

Asegúrese de llamar al URI v2/policies, que es https://iam.coud.ibm.com/v2/policies, para poder utilizar condiciones en sus políticas de acceso. Para obtener más información, consulte la API de gestión de políticas de IAM y el registro de cambios.

Creación de una condición temporal basada en el tiempo mediante la API

Puede asignar acceso para una duración finita especificando un intervalo de fecha y hora que determine cuándo la condición concede y termina el acceso. Por ejemplo, puede tener un usuario que necesite presentar una demostración en su cuenta durante unas horas o un contratista que necesite acceso temporal a un servicio durante un par de días. En los siguientes ejemplos se muestra cómo crear una condición puntual para su cuenta concediendo al usuario acceso temporal como Operador para todos los Servicios de Gestión de Cuentas.

	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 obtener más información sobre las condiciones basadas en el tiempo para las políticas de acceso, consulte Condiciones de las políticas de acceso.

Creación de una condición recurrente basada en el tiempo mediante la consola

Puede asignar accesos recurrentes con una cadencia semanal. Es posible que desee dar a los usuarios acceso a los recursos de la cuenta sólo durante sus horas de trabajo. Complete los siguientes pasos para asignar una política de acceso con una condición recurrente basada en el tiempo:

En la consola IBM Cloud, vaya a Gestionar > Acceso (IAM)
Seleccione Usuarios, Perfiles de confianza, ID de servicio o Grupos de acceso, en función de la entidad a la que desee asignar el acceso.
Haga clic en el nombre de la identidad de la lista y vaya a Acceso.
Pulse Asignar acceso.
Seleccione un servicio y haga clic en Siguiente.
- Si desea que el usuario pueda crear cualquier servicio, seleccione Todos los servicios habilitados para identidad y acceso.
- Si desea asignar acceso al usuario a un servicio específico, selecciónelo de la lista.
Seleccione el recurso al que desea asignar acceso al usuario, o seleccione Todos los recursos. Pulse Siguiente.
(Opcional) Seleccione una función de acceso al grupo de recursos. Pulse Siguiente.
Seleccione cualquier combinación de funciones de acceso a servicios y acceso a plataformas y haga clic en Siguiente.
Haga clic en Añadir condición y seleccione Semanal.
Seleccione la zona horaria para la política condicional.

Por ejemplo, supongamos que está creando una política condicional para un desarrollador con sede en Dublín. En este caso, seleccione UTC+1 para que el intervalo de fechas y horas que seleccione a continuación se aplique a la hora correcta para esa ubicación.
Seleccione los días de la semana a los que desea que la condición conceda acceso.
- (Opcional) Establezca el conmutador Todo el día en No para especificar un marco temporal para los días que seleccione.
Pulse Crear.
Pulse Revisar.
Pulse Añadir para añadir la configuración de política a su resumen de políticas.
Pulse Asignar.

Para obtener más información sobre las condiciones basadas en el tiempo para las políticas de acceso, consulte Condiciones de las políticas de acceso.

Creación de una condición recurrente basada en el tiempo mediante la CLI

Puede asignar accesos recurrentes con una cadencia semanal. Es posible que desee dar a los usuarios acceso a los recursos de la cuenta sólo durante sus horas de trabajo. El siguiente ejemplo muestra cómo crear una condición recurrente basada en el tiempo para un usuario. La política asigna el acceso durante las horas de trabajo de lunes a viernes como Editor para todos los Servicios de Gestión de Cuentas.

Inicie sesión en la CLI de IBM Cloud®. Si tiene varias cuentas, se le solicitará que seleccione qué cuenta desea utilizar. Si no especifica una región con el distintivo -r, también deberá seleccionar una región.
```
ibmcloud login
```
Si se rechazan sus credenciales, puede que esté utilizando un ID federado. Para iniciar sesión con un ID federado, utilice el distintivo --sso. Consulte Inicio de sesión con un ID federado para obtener más detalles.

Si es la primera vez que utiliza la CLI de IBM Cloud, consulte la Guía de aprendizaje de iniciación.
Cree una política de acceso y asígnela a un usuario o a un ID de servicio mediante el comando ibmcloud iam user-policy-create.

Asigne acceso a los servicios de gestión de todas las cuentas con la función Editor:

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

Utilice el siguiente ejemplo de esquema JSON de política recurrente basada en tiempo para crear sus propias condiciones:

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 obtener más información sobre las condiciones basadas en el tiempo para las políticas de acceso, consulte Condiciones de las políticas de acceso.

Creación de una condición recurrente basada en el tiempo mediante la API

Puede asignar accesos recurrentes con una cadencia semanal. Es posible que desee dar a los usuarios acceso a los recursos de la cuenta sólo durante sus horas de trabajo. Los siguientes ejemplos muestran cómo crear una condición recurrente basada en el tiempo para un usuario. La política asigna el acceso durante las horas de trabajo de lunes a viernes como Editor para todos los Servicios de Gestión de Cuentas.

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 obtener más información sobre las condiciones basadas en el tiempo para las políticas de acceso, consulte Condiciones de las políticas de acceso.

Creación de una condición basada en atributos de recursos mediante la consola

Puede asignar acceso especificando un atributo de recurso que determine a qué recursos concede acceso la condición. Por ejemplo, puede tener un usuario que necesite presentar una demostración en su cuenta utilizando recursos específicos. Para obtener más información y ejemplos sobre los operadores disponibles, consulte Condiciones basadas en atributos de recursos.

Puede tener hasta 10 condiciones y anidar hasta 2 niveles utilizando OR.

Complete los siguientes pasos para asignar una política de acceso con una condición basada en recursos de atributo:

En la consola IBM Cloud, vaya a Gestionar > Acceso (IAM)
Seleccione Usuarios, Perfiles de confianza, ID de servicio o Grupos de acceso, en función de la entidad a la que desee asignar el acceso.
Haga clic en el nombre de la entidad de la lista y vaya a Acceso.
Pulse Asignar acceso.
Seleccione un servicio y haga clic en Siguiente.

No todos los servicios admiten condiciones basadas en atributos de recursos. Para continuar, seleccione un servicio que admita condiciones basadas en atributos de recursos. Por ejemplo, Cloud Object Storage.
Seleccione el recurso al que desea asignar acceso al usuario, o seleccione Todos los recursos. Pulse Siguiente.
(Opcional) Seleccione una función de acceso al grupo de recursos. Pulse Siguiente.
Seleccione cualquier combinación de funciones de acceso a servicios y acceso a plataformas y haga clic en Siguiente.
Haga clic en Añadir condición y seleccione Creador de condiciones avanzado > Siguiente.
Añada las condiciones del recurso y haga clic en Crear.

Como ejemplo, digamos que está creando una política condicional para un desarrollador que necesita acceso a todo lo que esté bajo las carpetas dev/David/ y dev/Secret/ O cualquier ruta que comience con devOps/ o cicd/. En este caso, seleccione Prefijo, cadena coincide con cualquiera de, y añadir dev/David/* y dev/Secret/*. A continuación, añada una condición OR y seleccione Path, string matches any of, y añada devOps/* y cicd/*.

Haga clic en Crear> Revisar > Añadir para añadir su configuración de acceso a su resumen de acceso.
Pulse Asignar.

Documentación específica del servicio

Para obtener más información sobre cómo Cloud Object Storage utiliza las condiciones basadas en atributos de recursos, consulte Control de acceso a objetos individuales en un bucket.

Antes de empezar

Creación de condiciones basadas en atributos de recursos mediante la API

Puede asignar acceso especificando un atributo de recurso que determine a qué recursos concede acceso la condición. Como ejemplo, digamos que está creando una política condicional para un desarrollador que necesita acceso a todo lo que se encuentra bajo las carpetas dev/David/* y devA/* o cualquier ruta que comience con dev/David/* o devA/*. El siguiente ejemplo muestra cómo crear una condición basada en atributos de recursos que dé acceso al usuario a todo lo que se encuentre bajo la carpeta dev/David/ y a cualquier ruta que comience por la carpeta devA o específicamente devA/.

Puede tener hasta 10 condiciones y anidar hasta 2 niveles utilizando OR.

Para obtener más información y ejemplos sobre los operadores disponibles, consulte Condiciones basadas en 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": "/"
          }
        ]
      }
    ]
  }