시간 및 리소스 속성 기반 조건으로 액세스 제한하기

시간 기반 조건을 설정하여 계정의 리소스에 대한 임시 액세스를 지정하거나 특정 시간 동안 리소스에 대한 액세스를 허용할 수 있으며, 리소스 속성 기반 조건을 설정하여 액세스 요구 사항을 충족하기 위해 여러 액세스 정책을 만들지 않도록 할 수 있습니다.

특정 시간 및 날짜 범위에 대해 일회성 임시 액세스 권한을 부여하는 시간 기반 조건을 만들거나 매주 반복되는 액세스 권한을 설정할 수 있습니다. 예를 들어 반복 액세스를 지정하여 사용자에게 근무 시간에만 계정 리소스에 대한 액세스 권한을 부여하거나, 서비스의 기능을 데모해야 하는 계약자나 사용자에게 일시적인 액세스 권한만 부여하고 싶을 수 있습니다.

시간 기반 조건은 서머타임을 준수하는 시간대에 대한 서머타임(DST) 변경 사항을 고려하지 않습니다. 관리자는 시간 기반 조건을 정확하게 적용하려면 DST 변경에 따라 정책을 업데이트해야 합니다. 예를 들어, 동부 표준시 시간대는 서머타임이 적용될 때 UTC-4 시간이 아니라 표준시인 -5 시간입니다. 표준 시간은 11월에 시작하여 서머타임이 시작되는 3월에 끝납니다.

Kubernetes Service 은 시간 기반 조건을 준수하지 않습니다. 예를 들어, 모든 ID 및 액세스 사용 서비스에 대한 액세스 권한을 부여하는 시간 기반 조건이 있는 정책에는 Kubernetes Service 리소스에 대한 액세스 권한이 포함됩니다. 정책의 주체는 지정된 시간 기반 조건 외의 일부 Kubernetes Service 리소스에 액세스할 수 있습니다.

액세스 정책에 대한 시간 기반 조건은 액세스 권한 할당에 최소 권한 원칙을 적용하고 보안 침해가 발생할 경우 공격 표면을 줄이는 데 도움이 됩니다.

리소스 속성 기반 조건으로 정책을 만들면 액세스 요구 사항을 충족하기 위해 여러 액세스 정책을 만들지 않아도 됩니다. 대신 리소스 속성에 리터럴 또는 와일드카드 값으로 적용되는 OR/AND 연산자의 조합을 사용하여 단일 정책을 만들 수 있습니다. 여러 기준을 동시에 충족하는 리소스에 대한 액세스 권한을 부여하거나(AND), 여러 조건 중 하나라도 충족하는 경우에만 액세스 권한을 부여할 수 있습니다(OR). 예를 들어 리소스 속성 기반 조건을 사용하면 Service instance: abc, 또는 attribute-1: xyz, 또는 (attribute-2: def AND attribute-3: hij) 을 기준으로 액세스를 허용하는 단일 정책을 만들 수 있습니다.

OR/AND 및 리소스 속성 기반 조건을 사용하는 조건이 최소 2개 이상 있어야 합니다. 단일 조건을 추가해야 하는 경우 콘솔에서 리소스에 액세스 권한 할당을 참조하고 특정 리소스를 선택한 후 조건을 추가하세요.

사용자의 액세스 권한을 검토하려면 콘솔에서 할당된 액세스 권한 검토하기를 참조하세요.

조건 패턴

시간 기반 조건 패턴

다음 패턴은 허용되는 조건 순열을 나타냅니다:

시간 기반 조건에 허용되는 조건 패턴입니다.
패턴	예
시간 기반 조건: 한 번	오전 9시부터 오후 5시까지 특정 날짜에 임시 액세스 UTC-5.
시간 기반 조건:주간:종일	월~금요일 UTC-5 하루 종일 반복 액세스.
시간 기반 조건:주간:사용자 지정 시간	월~금 오전 9시~오후 5시 반복 액세스 UTC-5.

IAM은 동일한 정책 정의에서 일회성 임시 조건과 주간 반복 조건을 결합하는 것을 방지합니다.

리소스 속성 기반 조건 패턴

다음 패턴은 허용되는 조건 순열을 나타냅니다:

리소스 속성 기반 조건에 허용되는 조건 패턴입니다.
패턴	예
`attribute-based-condition:resource:literal-and-wildcard`	리터럴 또는 와일드카드 값이 있는 리소스 속성을 기반으로 하는 조건(사용된 연산자 기준)

콘솔을 사용하여 임시 시간 기반 조건 만들기

조건에 따라 액세스 권한을 부여하고 종료하는 시기를 결정하는 날짜 및 시간 범위를 지정하여 한정된 기간 동안 액세스 권한을 할당할 수 있습니다. 예를 들어 계정에서 몇 시간 동안 데모를 보여줘야 하는 사용자나 며칠 동안 서비스에 임시로 액세스해야 하는 계약자가 있을 수 있습니다. 임시 시간 기반 조건으로 액세스 정책을 할당하려면 다음 단계를 완료하세요:

IBM Cloud 콘솔에서 관리 > 액세스(IAM) 로 이동합니다
액세스 권한을 할당하려는 엔터티에 따라 사용자, 신뢰할 수 있는 프로필, 서비스 ID 또는 액세스 그룹을 선택합니다.
목록에서 엔티티의 이름을 클릭하고 액세스로 이동합니다.
액세스 권한 지정 을 클릭하십시오.
서비스를 선택하고 다음을 클릭합니다.
- 사용자가 모든 서비스를 작성할 수 있도록 하려면 모든 ID 및 액세스 사용 서비스를 선택하십시오.
- 사용자에게 특정 서비스에 대한 액세스 권한을 지정하려면 목록에서 해당 서비스를 선택하십시오.
사용자에게 액세스 권한을 할당할 리소스를 선택하거나 모든 리소스를 선택합니다. 다음 을 클릭하십시오.
(선택 사항) 리소스 그룹 액세스 역할을 선택합니다. 다음 을 클릭하십시오.
서비스 액세스 및 플랫폼 액세스 역할의 조합을 선택하고 다음을 클릭합니다.
조건 추가를 클릭하고 일회성을 선택합니다.
시간대를 선택하십시오.

예를 들어 더블린에 있는 개발자를 위한 조건부 정책을 만든다고 가정해 보겠습니다. 이 경우 UTC+1 을 선택하여 다음 단계에서 선택한 날짜 및 시간 범위가 해당 위치의 정확한 시간에 액세스를 적용하도록 합니다.
조건에 따라 액세스 권한 부여 및 종료 시기를 결정하는 날짜 및 시간 범위에 대한 필드를 작성합니다.
작성을 클릭하십시오.
검토를 클릭하십시오.
추가를 클릭하여 정책 요약에 정책 구성을 추가하십시오.
지정을 클릭하십시오.

임시 정책은 자동으로 제거되지 않습니다. 계정의 정책 한도에 도달하지 않도록 하려면 관리자는 정책이 만료된 후 수동으로 정책을 삭제할 수 있습니다.

액세스 정책의 시간 기반 조건에 대한 자세한 내용은 액세스 정책의 조건을 참조하세요.

시작하기 전에

액세스 정책에서 조건을 사용할 수 있도록 최신 버전의 IBM Cloud CLI가 있는지 확인하세요.

IBM Cloud CLI 버전을 판별하려면 다음 명령을 실행하십시오.

ibmcloud -v

최신 버전의 CLI를 사용해야 합니다. 최신 버전을 사용하지 않는 경우 다음 명령을 실행하여 CLI를 업데이트하십시오.

ibmcloud update

현재 릴리스를 실행 중이면 다음 출력이 표시됩니다.

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

자세한 내용은 독립 실행형 IBM Cloud CLI 설치하기를 참조하세요.

CLI를 사용하여 임시 시간 기반 조건 만들기

조건에 따라 액세스 권한을 부여하고 종료하는 시기를 결정하는 날짜 및 시간 범위를 지정하여 한정된 기간 동안 액세스 권한을 할당할 수 있습니다. 예를 들어 계정에서 몇 시간 동안 데모를 보여줘야 하는 사용자나 며칠 동안 서비스에 임시로 액세스해야 하는 계약자가 있을 수 있습니다. 다음 예에서는 사용자에게 모든 계정 관리 서비스에 대한 운영자로 임시 액세스 권한을 부여하여 계정에 대해 일회성 시간 기반 조건을 만드는 방법을 보여 줍니다.

IBM Cloud® CLI에 로그인하십시오. 여러 계정이 있는 경우 사용할 계정을 선택하라는 프롬프트가 표시됩니다. -r 플래그로 지역을 지정하지 않은 경우, 지역도 선택해야 합니다.
```
ibmcloud login
```
인증 정보가 거부되는 경우 연합 ID를 사용 중일 수 있습니다. 연합 ID로 로그인하려면 --sso 플래그를 사용하십시오. 자세한 정보는 연합 ID로 로그인을 참조하십시오.

IBM Cloud CLI를 처음 사용하는 경우 시작하기 튜토리얼을 확인하세요.
액세스 정책을 만들고 다음 명령을 사용하여 사용자 또는 서비스 ID에 할당합니다 ibmcloud iam user-policy-create.

Operator 역할로 모든 계정 관리 서비스에 대한 액세스 권한을 할당합니다:

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

다음 임시 시간 기반 정책 JSON 스키마의 예시를 사용하여 자신만의 조건을 만들 수 있습니다:

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

time-based-conditions:once 패턴을 사용하는 임시 정책은 자동으로 제거되지 않습니다. 계정의 정책 한도에 도달하지 않도록 하려면 관리자는 정책이 만료된 후 수동으로 정책을 삭제할 수 있습니다.

액세스 정책의 시간 기반 조건에 대한 자세한 내용은 액세스 정책의 조건을 참조하세요.

시작하기 전에

액세스 정책에서 조건을 사용할 수 있도록 v2/policies URI( https://iam.coud.ibm.com/v2/policies)를 호출해야 합니다. 자세한 내용은 IAM 정책 관리 API 및 변경 로그를 참조하세요.

API를 사용하여 임시 시간 기반 조건 만들기

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

액세스 정책의 시간 기반 조건에 대한 자세한 내용은 액세스 정책의 조건을 참조하세요.

콘솔을 사용하여 반복 시간 기반 조건 만들기

주 단위로 반복 액세스를 할당할 수 있습니다. 사용자에게 근무 시간에만 계정 리소스에 대한 액세스 권한을 부여하고 싶을 수도 있습니다. 반복 시간 기반 조건이 있는 액세스 정책을 할당하려면 다음 단계를 완료하세요:

IBM Cloud 콘솔에서 관리 > 액세스(IAM) 로 이동합니다
액세스 권한을 할당하려는 엔터티에 따라 사용자, 신뢰할 수 있는 프로필, 서비스 ID 또는 액세스 그룹을 선택합니다.
목록에서 ID의 이름을 클릭하고 접근으로 이동합니다.
액세스 권한 지정 을 클릭하십시오.
서비스를 선택하고 다음을 클릭합니다.
- 사용자가 모든 서비스를 작성할 수 있도록 하려면 모든 ID 및 액세스 사용 서비스를 선택하십시오.
- 사용자에게 특정 서비스에 대한 액세스 권한을 지정하려면 목록에서 해당 서비스를 선택하십시오.
사용자에게 액세스 권한을 할당할 리소스를 선택하거나 모든 리소스를 선택합니다. 다음 을 클릭하십시오.
(선택 사항) 리소스 그룹 액세스 역할을 선택합니다. 다음 을 클릭하십시오.
서비스 액세스 및 플랫폼 액세스 역할의 조합을 선택하고 다음을 클릭합니다.
조건 추가를 클릭하고 주간을 선택합니다.
조건부 정책의 표준 시간대를 선택합니다.

예를 들어 더블린에 있는 개발자를 위한 조건부 정책을 만든다고 가정해 보겠습니다. 이 경우 UTC+1 을 선택하여 다음에 선택하는 날짜 및 시간 범위가 해당 위치의 정확한 시간에 적용되도록 합니다.
조건에 따라 액세스 권한을 부여할 요일을 선택합니다.
- (선택 사항) 하루 종일 토글을 아니요로 설정하여 선택한 날짜의 기간을 지정할 수 있습니다.
작성을 클릭하십시오.
검토를 클릭하십시오.
추가를 클릭하여 정책 요약에 정책 구성을 추가하십시오.
지정을 클릭하십시오.

액세스 정책의 시간 기반 조건에 대한 자세한 내용은 액세스 정책의 조건을 참조하세요.

CLI를 사용하여 반복 시간 기반 조건 만들기

주 단위로 반복 액세스를 할당할 수 있습니다. 사용자에게 근무 시간에만 계정 리소스에 대한 액세스 권한을 부여하고 싶을 수도 있습니다. 다음 예에서는 사용자에 대한 반복 시간 기반 조건을 만드는 방법을 보여 줍니다. 이 정책은 월요일부터 금요일까지 근무 시간 동안 모든 계정 관리 서비스에 대한 편집자로 액세스 권한을 할당합니다.

IBM Cloud® CLI에 로그인하십시오. 여러 계정이 있는 경우 사용할 계정을 선택하라는 프롬프트가 표시됩니다. -r 플래그로 지역을 지정하지 않은 경우, 지역도 선택해야 합니다.
```
ibmcloud login
```
인증 정보가 거부되는 경우 연합 ID를 사용 중일 수 있습니다. 연합 ID로 로그인하려면 --sso 플래그를 사용하십시오. 자세한 정보는 연합 ID로 로그인을 참조하십시오.

처음으로 IBM Cloud CLI를 사용하는 경우 시작하기 튜토리얼을 확인하십시오.
액세스 정책을 만들고 다음 명령을 사용하여 사용자 또는 서비스 ID에 할당합니다 ibmcloud iam user-policy-create.

Editor 역할로 모든 계정 관리 서비스에 대한 액세스 권한을 할당합니다:

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

다음 반복 시간 기반 정책 JSON 스키마의 예시를 사용하여 자신만의 조건을 만들 수 있습니다:

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

액세스 정책의 시간 기반 조건에 대한 자세한 내용은 액세스 정책의 조건을 참조하세요.

API를 사용하여 반복되는 시간 기반 조건 만들기

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

액세스 정책의 시간 기반 조건에 대한 자세한 내용은 액세스 정책의 조건을 참조하세요.

콘솔을 사용하여 리소스 속성 기반 조건 만들기

조건에 따라 액세스 권한을 부여하는 리소스를 결정하는 리소스 속성을 지정하여 액세스 권한을 할당할 수 있습니다. 예를 들어 계정에서 특정 리소스를 사용하여 데모를 제공해야 하는 사용자가 있을 수 있습니다. 사용 가능한 연산자에 대한 자세한 내용과 예제는 리소스 속성 기반 조건을 참조하세요.

OR 을 사용하여 최대 10개의 조건과 최대 2단계까지 중첩할 수 있습니다.

속성 리소스 기반 조건으로 액세스 정책을 할당하려면 다음 단계를 완료하세요:

IBM Cloud 콘솔에서 관리 > 액세스(IAM) 로 이동합니다
액세스 권한을 할당하려는 엔터티에 따라 사용자, 신뢰할 수 있는 프로필, 서비스 ID 또는 액세스 그룹을 선택합니다.
목록에서 엔티티의 이름을 클릭하고 액세스로 이동합니다.
액세스 권한 지정 을 클릭하십시오.
서비스를 선택하고 다음을 클릭합니다.

모든 서비스가 리소스 속성 기반 조건을 지원하는 것은 아닙니다. 계속하려면 리소스 속성 기반 조건을 지원하는 서비스를 선택합니다. 예를 들어, Cloud Object Storage를 선택하십시오.
사용자에게 액세스 권한을 할당할 리소스를 선택하거나 모든 리소스를 선택합니다. 다음을 클릭하십시오.
(선택 사항) 리소스 그룹 액세스 역할을 선택합니다. 다음 을 클릭하십시오.
서비스 액세스 및 플랫폼 액세스 역할의 조합을 선택하고 다음을 클릭합니다.
조건 추가를 클릭하고 고급 조건 작성기 > 다음을 선택합니다.
리소스 조건을 추가하고 생성을 클릭합니다.

예를 들어 dev/David/ 및 dev/Secret/ 폴더 또는 devOps/ 또는 cicd/ 로 시작하는 경로 아래의 모든 항목에 액세스해야 하는 개발자를 위한 조건부 정책을 만든다고 가정해 보겠습니다. 이 경우 접두사, 문자열 중 일치하는 것을 선택하고 dev/David/* 및 dev/Secret/* 을 추가합니다. 그런 다음 OR 조건을 추가하고 경로, 문자열 일치 중 하나를 선택한 다음 devOps/* 및 cicd/* 을 추가합니다.

만들기 > 검토 > 추가를 클릭하여 액세스 요약에 액세스 구성을 추가합니다.
지정을 클릭하십시오.

서비스별 문서

Cloud Object Storage 에서 리소스 속성 기반 조건을 사용하는 방법에 대한 자세한 내용은 버킷의 개별 개체에 대한 액세스 제어하기를 참조하세요.

시작하기 전에

API를 사용하여 리소스 속성 기반 조건 만들기

조건에 따라 액세스 권한을 부여하는 리소스를 결정하는 리소스 속성을 지정하여 액세스 권한을 할당할 수 있습니다. 예를 들어 dev/David/* 및 devA/* 폴더 또는 dev/David/* 또는 devA/* 로 시작하는 경로 아래의 모든 항목에 액세스해야 하는 개발자를 위한 조건부 정책을 만든다고 가정해 보겠습니다. 다음 예는 사용자에게 dev/David/ 폴더 아래의 모든 항목과 devA 또는 특히 devA/ 폴더로 시작하는 모든 경로에 대한 액세스 권한을 부여하는 리소스 속성 기반 조건을 만드는 방법을 보여 줍니다.

OR 을 사용하여 최대 10개의 조건과 최대 2단계까지 중첩할 수 있습니다.

사용 가능한 연산자에 대한 자세한 내용과 예제는 리소스 속성 기반 조건을 참조하세요.

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