Gerenciamento de restrições baseadas no contexto

Você pode gerenciar as regras de contexto a qualquer momento, atualizando a descrição, o que ajuda a identificar a finalidade da regra, ou selecionando uma nova lista de recursos e ambientes de rede. Também é possível remover restrições baseadas em contexto para excluir restrições definidas pelos contextos em uma regra.

As restrições baseadas em contexto podem definir e aplicar restrições de acesso para seus próprios recursos IBM Cloud®. Você pode definir essas restrições com base em contextos, como zonas de rede e tipos de endpoint. Para obter mais informações, consulte Quais são as restrições baseadas em contexto.

O serviço de restrição baseado em contexto gerencia regras e zonas de rede, portanto, é possível perder toda a capacidade de gerenciar esses recursos se você não puder satisfazer uma regra no serviço de restrição baseado em contexto. As tentativas de criar ou atualizar essa regra são permitidas somente se o contexto da solicitação satisfizer a regra nova ou modificada.

Se você não puder mais atender a uma regra que vise ao serviço de restrições baseadas em contexto, abra um caso de suporte e forneça um contexto que possa ser atendido para restaurar seu acesso.

Antes de Iniciar

Para gerenciar restrições baseadas em contexto, você deve receber a função de administrador no serviço de gerenciamento de contas.

Atualização de regras usando o console

Para editar as restrições baseadas em contexto em seus recursos de nuvem, conclua as etapas a seguir:

  1. No console do IBM Cloud, clique em Gerenciar > Restrições baseadas em contexto e selecione Regras.
  2. Selecione o ícone Ações ícone Ações na regra que deseja atualizar e selecione Editar.
  3. Para atualizar o escopo das APIs cujas operações são restritas por sua regra, selecione All APIs ou Specific APIs. Em seguida, clique em Aplicar ou Continuar.
  4. Para atualizar o escopo dos recursos para a restrição, você pode selecionar Todos os recursos ou Recursos específicos com base nos atributos disponíveis, como grupo de recursos ou local. Em seguida, clique em Aplicar ou Continuar.
  5. Clique no ícone Editar Ícone de edição no painel de resumo para atualizar um contexto existente.
    1. Atualize os tipos de endpoint permitidos.
      • Defina a alternância como No (Não) para permitir todos os tipos de endpoint compatíveis com o serviço.
      • Defina a alternância como Yes para permitir apenas tipos específicos de pontos de extremidade.
    2. Atualize as zonas de trabalho. Você pode selecionar novas zonas de rede ou desmarcar zonas de rede para removê-las.
  6. Em seguida, clique em Aplicar.
  7. Clique no ícone Remover ícone Remover no painel de resumo para remover um contexto.
  8. Configure um novo contexto, selecionando todos os terminais ou um terminal específico, e selecionando suas zonas de rede. Em seguida, clique em ** Incluir **.
  9. Clique em Aplicar ou Continuar.
  10. Forneça uma nova descrição para sua regra. Clique em Apply (Aplicar ) para atualizar a descrição ou clique em Continue (Continuar ).
  11. Para atualizar a aplicação de uma regra, clique no ícone Editar Ícone de edição. Você pode Ativar, Desativar ou definir a regra como Somente relatório.
  12. Clique em Aplicar para finalizar.

Atualização de regras usando a CLI

Para atualizar as restrições baseadas em contexto em seus recursos de nuvem, use o comando ibmcloud cbr rule-update. O exemplo a seguir atualiza a descrição, o tipo de endpoint permitido e a zona de rede de uma regra com a ID 30fd58c9b75f40e854b89c432318b4a2.

ibmcloud cbr rule-update 30fd58c9b75f40e854b89c432318b4a2 --description 'Example rule description' --service-name kms --context-attributes endpointType=private --zone-id 93de8d3f588ab2c457ff576c364d1145

Atualização de regras usando a API

Para atualizar as restrições aos seus recursos de nuvem criando regras, chame a API de restrições baseadas em contexto.

  1. Obtenha a regra que você deseja substituir. No corpo da resposta, copie o ID da regra e, nos cabeçalhos da resposta, copie o cabeçalho ETag.

    curl -X GET --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" "https://cbr.cloud.ibm.com/v1/rules/{rule_id}"

    GetRuleOptions getRuleOptions = new GetRuleOptions.Builder()
.ruleId(ruleID)
.build();
Response<Rule> response = contextBasedRestrictionsService.getRule(getRuleOptions).execute();
Rule rule = response.getResult();
System.out.println(rule);

    const params = {
  ruleId,
};
try {
  const res = await contextBasedRestrictionsService.getRule(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

    rule = context_based_restrictions_service.get_rule(
  rule_id=rule_id
)
rule = rule.get_result()
print(json.dumps(rule, indent=2))

    getRuleOptions := contextBasedRestrictionsService.NewGetRuleOptions(
  ruleID,
)
rule, response, err := contextBasedRestrictionsService.GetRule(getRuleOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(rule, "", "  ")
fmt.Println(string(b))

  2. O exemplo a seguir substitui uma regra por uma versão atualizada. O valor ETag é necessário no cabeçalho If-Match da solicitação de substituição.

    curl -X PUT --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" --header "If-Match: {if_match}" --header "Content-Type: application/json" --data '{ "description": "this is an example of rule", "resources": [ { "attributes": [ { "name": "accountId", "value": "12ab34cd56ef78ab90cd12ef34ab56cd" }, { "name": "serviceName", "value": "kms" } ] } ], "contexts": [ { "attributes": [ { "name": "networkZoneId", "value": "76921bd873115033bd2a0909fe081b45" } ] } ], "enforcement_mode": "disabled" }' "{base_url}/v1/rules/{rule_id}"

    RuleContextAttribute ruleContextAttributeModel = new RuleContextAttribute.Builder()
  .name("networkZoneId")
  .value("76921bd873115033bd2a0909fe081b45")
  .build();
RuleContext ruleContextModel = new RuleContext.Builder()
  .attributes(new java.util.ArrayList<RuleContextAttribute>(java.util.Arrays.asList(ruleContextAttributeModel)))
  .build();
ResourceAttribute resourceAttributeModel = new ResourceAttribute.Builder()
  .name("accountId")
  .value("12ab34cd56ef78ab90cd12ef34ab56cd")
  .build();
Resource resourceModel = new Resource.Builder()
  .attributes(new java.util.ArrayList<ResourceAttribute>(java.util.Arrays.asList(resourceAttributeModel)))
  .build();
ReplaceRuleOptions replaceRuleOptions = new ReplaceRuleOptions.Builder()
  .ruleId("testString")
  .ifMatch("testString")
  .description("this is an example of rule")
  .enforcementMode("disabled")
  .contexts(new java.util.ArrayList<RuleContext>(java.util.Arrays.asList(ruleContextModel)))
  .resources(new java.util.ArrayList<Resource>(java.util.Arrays.asList(resourceModel)))
  .build();
Response<OutRule> response = contextBasedRestrictionsService.replaceRule(replaceRuleOptions).execute();
OutRule outRule = response.getResult();
System.out.println(outRule);

    // Request models needed by this operation.
// RuleContextAttribute
const ruleContextAttributeModel = {
  name: 'networkZoneId',
  value: '76921bd873115033bd2a0909fe081b45',
};
// RuleContext
const ruleContextModel = {
  attributes: [ruleContextAttributeModel],
};
// ResourceAttribute
const resourceAttributeModel = {
  name: 'accountId',
  value: '12ab34cd56ef78ab90cd12ef34ab56cd',
};
// Resource
const resourceModel = {
  attributes: [resourceAttributeModel],
};
const params = {
  ruleId: 'testString',
  ifMatch: 'testString',
  contexts: [ruleContextModel],
  resources: [resourceModel],
  description: 'this is an example of rule',
  enforcementMode: 'disabled',
};
contextBasedRestrictionsService.replaceRule(params)
  .then(res => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

    rule_context_attribute_model = {
  'name': 'networkZoneId',
  'value': '76921bd873115033bd2a0909fe081b45',
}
rule_context_model = {
  'attributes': [rule_context_attribute_model],
}
resource_attribute_model = {
  'name': 'accountId',
  'value': '12ab34cd56ef78ab90cd12ef34ab56cd',
}
resource_model = {
  'attributes': [resource_attribute_model],
}
out_rule = context_based_restrictions_service.replace_rule(
  rule_id='testString',
  if_match='testString',
  contexts=[rule_context_model],
  resources=[resource_model],
  description='this is an example of rule',
  enforcement_mode='disabled'
).get_result()
print(json.dumps(out_rule, indent=2))

    ruleContextAttributeModel := &contextbasedrestrictionsv1.RuleContextAttribute{
  Name: core.StringPtr("networkZoneId"),
  Value: core.StringPtr("76921bd873115033bd2a0909fe081b45"),
}
ruleContextModel := &contextbasedrestrictionsv1.RuleContext{
  Attributes: []contextbasedrestrictionsv1.RuleContextAttribute{*ruleContextAttributeModel},
}
resourceAttributeModel := &contextbasedrestrictionsv1.ResourceAttribute{
  Name: core.StringPtr("accountId"),
  Value: core.StringPtr("12ab34cd56ef78ab90cd12ef34ab56cd"),
}
resourceModel := &contextbasedrestrictionsv1.Resource{
  Attributes: []contextbasedrestrictionsv1.ResourceAttribute{*resourceAttributeModel},
}
replaceRuleOptions := contextBasedRestrictionsService.NewReplaceRuleOptions(
  "testString",
  "testString",
)
replaceRuleOptions.SetDescription("this is an example of rule")
replaceRuleOptions.SetContexts([]contextbasedrestrictionsv1.RuleContext{*ruleContextModel})
replaceRuleOptions.SetResources([]contextbasedrestrictionsv1.Resource{*resourceModel})
replaceRuleOptions.SetEnforcementMode(contextbasedrestrictionsv1.ReplaceRuleOptionsEnforcementModeDisabledConst)
outRule, response, err := contextBasedRestrictionsService.ReplaceRule(replaceRuleOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(outRule, "", "  ")
fmt.Println(string(b))

Atualização de zonas de rede usando o console

É possível modificar a lista de locais permitidos onde uma solicitação de acesso pode ser originada. Um conjunto de um ou mais locais de rede pode ser especificado por endereços IP (endereços individuais, intervalos ou sub-redes), VPCs ou referências de serviço. É possível atualizar uma zona de rede que é usada em uma regra ou integrar as novas zonas de rede atualizadas em suas regras posteriormente.

  1. No console do IBM Cloud, clique em Gerenciar > Restrições baseadas em contexto e selecione Zonas de rede.
  2. Selecione o ícone Ações ícone Ações na zona de rede que você deseja atualizar e selecione Editar.
  3. Você pode atualizar o nome e a descrição de sua zona.
  4. É possível editar a lista de endereços IP permitidos onde uma solicitação de acesso pode ser originada. Inclua exceções na lista de negação, se necessário.
  5. É possível incluir ou remover VPCs permitidos.
  6. É possível incluir ou remover referências de serviço. Selecione um serviço para associar seus endereços IP à sua zona de rede.
  7. Clique em Avançar para revisar sua nova configuração.
  8. Para aplicar as mudanças, clique em Atualizar.

Atualização de zonas de rede usando a CLI

Para atualizar uma zona de rede, conclua as etapas a seguir.

  1. Recupere o ID da zona da rede que você deseja atualizar usando o comando ibmcloud cbr zones para listar todas as zonas da conta.
    ibmcloud cbr zones
  2. Atualize a zona de rede usando o comando ibmcloud cbr zone-update. O exemplo a seguir atualiza o nome da zona, os endereços permitidos e os endereços excluídos de uma zona de rede com o ID 65810ac762004f22ac19f8f8edf70a34.
    ibmcloud cbr zone-update 65810ac762004f22ac19f8f8edf70a34 --name 'Example Zone Name' --addresses 166.22.23.0-166.22.23.108 --excluded 166.22.23.100

Atualização de zonas de rede usando a API

Para atualizar uma zona de rede, conclua as etapas a seguir.

  1. Obtenha a zona que você deseja substituir. No corpo da resposta, copie o ID da zona e, nos cabeçalhos da resposta, copie o cabeçalho ETag.

    curl -X GET --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" "https://cbr.cloud.ibm.com/v1/zones/{zone_id}"

    GetZoneOptions getZoneOptions = new GetZoneOptions.Builder()
 .zoneId(zoneID)
 .build();
Response<Zone> response = contextBasedRestrictionsService.getZone(getZoneOptions).execute();
Zone zone = response.getResult();
System.out.println(zone);

    const params = {
 zoneId,
};
try {
 const res = await contextBasedRestrictionsService.getZone(params);
 console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
 console.warn(err);
}

    get_zone_response = context_based_restrictions_service.get_zone(
 zone_id=zone_id
)
zone = get_zone_response.get_result()
print(json.dumps(zone, indent=2))

    getZoneOptions := contextBasedRestrictionsService.NewGetZoneOptions(
  zoneID,
)
 zone, response, err := contextBasedRestrictionsService.GetZone(getZoneOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(zone, "", "  ")
fmt.Println(string(b))

  2. Atualize a zona de rede usando o método Substituir zona. O valor ETag é necessário no cabeçalho If-Match da solicitação de substituição.

    curl -X PUT --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" --header "If-Match: {if_match}" --header "Content-Type: application/json" --data '{ "name": "new zone name", "description": "new zone description", "account_id": "12ab34cd56ef78ab90cd12ef34ab56cd", "addresses": [ { "type": "ipAddress", "value": "169.23.56.234" }, { "type": "ipRange", "value": "169.23.22.0-169.23.22.255" }, { "type": "vpc", "value": "crn:v1:bluemix:public:is:us-south:a/12ab34cd56ef78ab90cd12ef34ab56cd::vpc:r134-d98a1702-b39a-449a-86d4-ef8dbacf281e" } ] }' "{base_url}/v1/zones/{zone_id}"

    AddressIPAddress addressModel = new AddressIPAddress.Builder()
  .type("ipAddress")
  .value("169.23.56.234")
  .build();
ReplaceZoneOptions replaceZoneOptions = new ReplaceZoneOptions.Builder()
  .zoneId("testString")
  .ifMatch("testString")
  .name("an example of zone")
  .accountId("12ab34cd56ef78ab90cd12ef34ab56cd")
  .description("this is an example of zone")
  .addresses(new java.util.ArrayList<Address>(java.util.Arrays.asList(addressModel)))
  .build();
Response<OutZone> response = contextBasedRestrictionsService.replaceZone(replaceZoneOptions).execute();
OutZone outZone = response.getResult();
System.out.println(outZone);

    // Request models needed by this operation.
// AddressIPAddress
const addressModel = {
  type: 'ipAddress',
  value: '169.23.56.234',
};
const params = {
  zoneId: 'testString',
  ifMatch: 'testString',
  name: 'an example of zone',
  accountId: '12ab34cd56ef78ab90cd12ef34ab56cd',
  addresses: [addressModel],
  description: 'this is an example of zone',
};
contextBasedRestrictionsService.replaceZone(params)
  .then(res => {
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

    address_model = {
  'type': 'ipAddress',
  'value': '169.23.56.234',
}
out_zone = context_based_restrictions_service.replace_zone(
  zone_id='testString',
  if_match='testString',
  name='an example of zone',
  account_id='12ab34cd56ef78ab90cd12ef34ab56cd',
  addresses=[address_model],
  description='this is an example of zone'
).get_result()
print(json.dumps(out_zone, indent=2))

    addressModel := &contextbasedrestrictionsv1.AddressIPAddress{
  Type: core.StringPtr("ipAddress"),
  Value: core.StringPtr("169.23.56.234"),
}
replaceZoneOptions := contextBasedRestrictionsService.NewReplaceZoneOptions(
  "testString",
  "testString",
)
replaceZoneOptions.SetName("an example of zone")
replaceZoneOptions.SetAccountID("12ab34cd56ef78ab90cd12ef34ab56cd")
replaceZoneOptions.SetDescription("this is an example of updated zone")
replaceZoneOptions.SetAddresses([]contextbasedrestrictionsv1.AddressIntf{addressModel})
outZone, response, err := contextBasedRestrictionsService.ReplaceZone(replaceZoneOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(outZone, "", "  ")
fmt.Println(string(b))

Remoção de uma regra usando o console

A exclusão de regras remove as restrições baseadas no contexto de um determinado recurso, e as solicitações de qualquer contexto são permitidas se o usuário tiver as permissões corretas. É possível remover uma regra em seus recursos de nuvem, concluindo as etapas a seguir:

  1. No console do IBM Cloud, acesse Gerenciar > Restrições baseadas em contexto e selecione Regras.
  2. Clique no ícone Ações Ícone de Ações na linha que contém a regra, e clique em Remover.

Remoção de uma regra usando a CLI

É possível remover uma regra em seus recursos de nuvem, concluindo as etapas a seguir:

  1. Recupere o ID da regra que você deseja excluir usando o comando de regras de restrições baseadas em contexto. Você pode restringir os resultados da lista especificando atributos como opções de comando.
    ibmcloud cbr rules --serviceName "iam-identity"
  2. Exclua a regra do ID de regra especificado usando o comando cbr rule-delete.
    ibmcloud cbr rule-delete 30fd58c9b75f40e854b89c432318b4a2

Remoção de uma regra usando a API

É possível remover uma regra em seus recursos de nuvem, concluindo as etapas a seguir:

  1. Recupere o ID da regra que você deseja excluir usando o método context-based-restrictions list rules.
    curl -X GET --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" "{base_url}/v1/rules?account_id={account_id}"

    ListRulesOptions listRulesOptions = new ListRulesOptions.Builder()
.accountId("testString")
.build();

Response<OutRulePage> response = contextBasedRestrictionsService.listRules(listRulesOptions).execute();
OutRulePage outRulePage = response.getResult();

System.out.println(outRulePage);

     const params = {
   accountId: 'testString',
 };

 contextBasedRestrictionsService.listRules(params)
   .then(res => {
     console.log(JSON.stringify(res.result, null, 2));
   })
   .catch(err => {
     console.warn(err)
   });

    out_rule_page = context_based_restrictions_service.list_rules(
   account_id='testString'
 ).get_result()

 print(json.dumps(out_rule_page, indent=2))

     listRulesOptions := contextBasedRestrictionsService.NewListRulesOptions(
   "testString",
 )

 ruleList, response, err := contextBasedRestrictionsService.ListRules(listRulesOptions)
 if err != nil {
   panic(err)
 }
 b, _ := json.MarshalIndent(ruleList, "", "  ")
 fmt.Println(string(b))
  2. Exclui a regra para o ID de regra especificado.
    curl -X DELETE --location --header "Authorization: Bearer {iam_token}" "{base_url}/v1/rules/{rule_id}"

    DeleteRuleOptions deleteRuleOptions = new DeleteRuleOptions.Builder()
  .ruleId("testString")
  .build();

Response<Void> response = contextBasedRestrictionsService.deleteRule(deleteRuleOptions).execute();

     const params = {
   ruleId: 'testString',
 };

 contextBasedRestrictionsService.deleteRule(params)
   .then(res => {
     done();
   })
   .catch(err => {
     console.warn(err)
   });

     response = context_based_restrictions_service.delete_rule(
   rule_id='testString'
 )

     deleteRuleOptions := contextBasedRestrictionsService.NewDeleteRuleOptions(
   "testString",
 )

 response, err := contextBasedRestrictionsService.DeleteRule(deleteRuleOptions)
 if err != nil {
   panic(err)
 }
 if response.StatusCode != 204 {
   fmt.Printf("\nUnexpected response status code received from DeleteRule(): %d\n", response.StatusCode)
 }

Remoção de uma zona de rede usando o console

A remoção de uma zona de rede remove o conjunto de locais de rede permitidos a partir dos quais uma solicitação de acesso é criada. Se uma zona de rede for incluída em uma regra, primeiro você deve remover a zona da regra. Conclua as etapas a seguir para remover uma zona de rede:

  1. No console IBM Cloud, acesse Gerenciar > Restrições baseadas no contexto e selecione Zonas de rede.
  2. Clique no ícone Ações Ícone de Ações na linha que contém a zona de rede, e clique em Remover.

Remoção de uma zona de rede usando a CLI

A remoção de uma zona de rede remove o conjunto de locais de rede permitidos a partir dos quais uma solicitação de acesso é criada. Se uma zona de rede for incluída em uma regra, primeiro você deve remover a zona da regra. Para obter mais informações sobre como remover uma zona de uma regra, consulte Atualização de restrições baseadas em contexto. Em seguida, conclua as etapas a seguir:

  1. Recupere a ID da zona da rede que você deseja excluir usando o comando contxt-based restrictions zones. Você pode restringir os resultados da lista especificando o nome da zona.
    ibmcloud cbr zones --name "Example zone"
  2. Exclua a zona de rede da ID de zona especificada usando o comando cbr zone-delete.
    ibmcloud cbr zone-delete 65810ac762004f22ac19f8f8edf70a34

Remoção de uma zona de rede usando a API

A remoção de uma zona de rede remove o conjunto de locais de rede permitidos a partir dos quais uma solicitação de acesso é criada. Se uma zona de rede for incluída em uma regra, primeiro você deve remover a zona da regra. Consulte Atualizando restrições baseadas em contexto para obter mais informações sobre como remover uma zona de uma regra. Em seguida, conclua as etapas a seguir:

  1. Recupere o ID da regra que você deseja excluir usando o método de zonas da lista de restrições baseadas em contexto.
    curl -X GET --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" "{base_url}/v1/zones?account_id={account_id}"

    ListZonesOptions listZonesOptions = new ListZonesOptions.Builder()
.accountId("testString")
.build();

Response<OutZonePage> response = contextBasedRestrictionsService.listZones(listZonesOptions).execute();
OutZonePage outZonePage = response.getResult();

System.out.println(outZonePage);

     const params = {
   accountId: 'testString',
 };

 contextBasedRestrictionsService.listZones(params)
   .then(res => {
     console.log(JSON.stringify(res.result, null, 2));
   })
   .catch(err => {
     console.warn(err)
   });

     out_zone_page = context_based_restrictions_service.list_zones(
   account_id='testString'
 ).get_result()

 print(json.dumps(out_zone_page, indent=2))

     listZonesOptions := contextBasedRestrictionsService.NewListZonesOptions(
   "testString",
 )

 outZonePage, response, err := contextBasedRestrictionsService.ListZones(listZonesOptions)
 if err != nil {
   panic(err)
 }
 b, _ := json.MarshalIndent(outZonePage, "", "  ")
 fmt.Println(string(b))
  2. Exclui a zona de rede para o ID de zona especificado.
    curl -X DELETE --location --header "Authorization: Bearer {iam_token}" "{base_url}/v1/zones/{zone_id}"

     DeleteZoneOptions deleteZoneOptions = new DeleteZoneOptions.Builder()
   .zoneId("testString")
   .build();

 Response<Void> response = contextBasedRestrictionsService.deleteZone(deleteZoneOptions).execute();

     const params = {
   zoneId: 'testString',
 };

 contextBasedRestrictionsService.deleteZone(params)
   .then(res => {
     done();
   })
   .catch(err => {
     console.warn(err)
   });

     response = context_based_restrictions_service.delete_zone(
   zone_id='testString'
 )

     deleteZoneOptions := contextBasedRestrictionsService.NewDeleteZoneOptions(
   "testString",
 )

 response, err := contextBasedRestrictionsService.DeleteZone(deleteZoneOptions)
 if err != nil {
   panic(err)
 }
 if response.StatusCode != 204 {
   fmt.Printf("\nUnexpected response status code received from DeleteZone(): %d\n", response.StatusCode)
 }

Restringir a capacidade de gerenciar regras e zonas de rede usando o console

Para configurar essa regra, direcione o serviço de restrições baseadas em contexto. Para obter mais informações sobre as etapas de configuração de uma regra, consulte Criação de regras. Uma regra com escopo para Todos os recursos é aplicável a todos os recursos atuais e futuros que são gerenciados pelo serviço. Se você quiser restringir as operações de um recurso específico, defina o escopo da regra para Recursos específicos > Tipo de recurso. Para concluir qualquer regra ou operação de gerenciamento de zona de rede, um usuário deve ser atribuído à função correta com uma política de acesso IAM e deve satisfazer a regra de restrições baseadas em contexto.

Restringir a capacidade de gerenciar regras e zonas de rede usando a API

O exemplo a seguir mostra uma regra no formato JSON que protege as operações de gerenciamento de regras e zonas de rede:

{
  "resources": [
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "my-AccountID"
        },
        {
          "name": "serviceName",
          "value": "context-based-restrictions"
        }
      ]
    }
  ],
  "description": "",
  "contexts": [
    {
      "attributes": [
        {
          "name": "networkZoneId",
          "value": "my-zoneID"
        }
      ]
    }
  ],
  "enforcement_mode": "report"
}

Uma regra que especifica apenas os atributos de recursos accountId e serviceName é aplicável a todos os recursos atuais e futuros que são gerenciados pelo serviço. Se você quiser restringir as operações de um recurso específico, inclua o atributo de recurso resourceType correspondente. Os valores válidos de resourceType para o serviço de restrições baseadas em contexto são rule e zone.

Para concluir qualquer regra ou operação de gerenciamento de zona de rede, um usuário deve ser atribuído à função correta com uma política de acesso IAM e deve satisfazer a regra de restrições baseadas em contexto.