Gestione delle restrizioni basate sul contesto

È possibile gestire le regole di contesto in qualsiasi momento aggiornando la descrizione, che aiuta a identificare lo scopo della regola, o selezionando un nuovo elenco di risorse e ambienti di rete. È anche possibile rimuovere le restrizioni basate sul contesto per eliminare le restrizioni definite dai contesti in una regola.

Le restrizioni basate sul contesto possono definire e applicare restrizioni di accesso per le proprie risorse IBM Cloud®. È possibile definire queste restrizioni in base ai contesti, come le zone di rete e i tipi di endpoint. Per ulteriori informazioni, vedere Cosa sono le restrizioni basate sul contesto.

Il servizio di restrizione basato sul contesto gestisce le regole e le zone di rete, pertanto è possibile perdere la capacità di gestire queste risorse se non si riesce a soddisfare una regola sul servizio di restrizione basato sul contesto. I tentativi di creare o aggiornare una regola di questo tipo sono consentiti solo se il contesto della richiesta soddisfa la regola nuova o modificata.

Se non è più possibile soddisfare una regola che ha come obiettivo il servizio Restrizioni basate sul contesto, aprire un caso di assistenza e fornire un contesto da soddisfare per ripristinare l'accesso.

Prima di iniziare

Per gestire una restrizione basata sul contesto, è necessario essere assegnati al ruolo di amministratore sul servizio di gestione degli account.

Aggiornamento delle regole tramite la console

Per modificare le restrizioni basate sul contesto delle risorse cloud, eseguire i seguenti passaggi:

  1. Nella console IBM Cloud, fare clic su Gestione > Restrizioni contestuali e selezionare Regole.
  2. Selezionare l'icona Azioni Icona Azioni Azioni sulla regola che si desidera aggiornare e selezionare Modifica.
  3. Per aggiornare l'ambito delle API le cui operazioni sono limitate dalla regola, selezionare Tutte le API o API specifiche. Quindi, fare clic su Applica o Continua.
  4. Per aggiornare l'ambito delle risorse per la restrizione, è possibile selezionare Tutte le risorse o Risorse specifiche in base agli attributi disponibili, come il gruppo di risorse o la posizione. Quindi, fare clic su Applica o Continua.
  5. Fare clic sull'icona Modifica Icona Modifica nel pannello di riepilogo per aggiornare un contesto esistente.
    1. Aggiornare i tipi di endpoint consentiti.
      • Impostare la levetta su No per consentire tutti i tipi di endpoint supportati dal servizio.
      • Impostare la levetta su Sì per consentire solo tipi di endpoint specifici.
    2. Aggiornare le zone di lavoro. È possibile selezionare nuove zone di rete o deselezionare zone di rete per rimuoverle.
  6. Quindi, fare clic su Applica.
  7. Fare clic sull'icona Rimuovere Rimuovere l'icona nel pannello di riepilogo per rimuovere un contesto.
  8. Configurare un nuovo contesto selezionando tutti gli endpoint o un endpoint specifico e selezionando le zone di rete. Quindi, fai clic su Add.
  9. Fare clic su Applica o Continua.
  10. Fornire una nuova descrizione per la regola. Fare clic su Applica per aggiornare la descrizione, oppure fare clic su Continua.
  11. Per aggiornare l'applicazione di una regola, fare clic sull'icona Modifica Modifica. È possibile Abilitare, Disabilitare o impostare la regola su Solo rapporti.
  12. Fare clic su Applica per terminare.

Aggiornamento delle regole tramite CLI

Per aggiornare le restrizioni basate sul contesto delle risorse cloud, utilizzare il comando ibmcloud cbr rule-update. L'esempio seguente aggiorna la descrizione, il tipo di endpoint consentito e la zona di rete per una regola con l'ID 30fd58c9b75f40e854b89c432318b4a2.

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

Aggiornamento delle regole tramite API

Per aggiornare le restrizioni alle risorse cloud creando regole, chiamare l'API Restrizioni basate sul contesto.

  1. Prendete la regola che volete sostituire. Nel corpo della risposta, copiare l'ID della regola e nelle intestazioni della risposta copiare l'intestazione 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. L'esempio seguente sostituisce una regola con una versione aggiornata. Il valore ETag è richiesto nell'intestazione If-Match della richiesta di sostituzione.

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

Aggiornamento delle zone di rete tramite la console

È possibile modificare l'elenco delle località consentite da cui può provenire una richiesta di accesso. Un insieme di una o più posizioni di rete può essere specificato da indirizzi IP (indirizzi individuali, intervalli o sottoreti), VPC o riferimenti di servizio. È possibile aggiornare una zona di rete utilizzata in una regola o integrare le nuove zone di rete aggiornate nelle regole in un secondo momento.

  1. Nella console IBM Cloud, fare clic su Gestione > Restrizioni contestuali e selezionare Zone di rete.
  2. Selezionare l'icona Azioni Icona Azioni Azioni sulla zona di rete che si desidera aggiornare e selezionare Modifica.
  3. È possibile aggiornare il nome e la descrizione della zona.
  4. È possibile modificare l'elenco degli indirizzi IP consentiti da cui può provenire una richiesta di accesso. Includere le eccezioni nell'elenco dei rifiuti, se necessario.
  5. È possibile aggiungere o rimuovere le VPC consentite.
  6. È possibile aggiungere o rimuovere i riferimenti al servizio. Selezionare un servizio per associare i relativi indirizzi IP alla tua zona di rete.
  7. Fare clic su Avanti per rivedere la nuova configurazione.
  8. Per applicare le modifiche, fare clic su Aggiorna.

Aggiornamento delle zone di rete tramite la CLI

Per aggiornare una zona di rete, completare i seguenti passaggi.

  1. Recuperare l'ID della zona di rete che si desidera aggiornare utilizzando il comando ibmcloud cbr zones per elencare tutte le zone dell'account.
    ibmcloud cbr zones
  2. Aggiornare la zona di rete utilizzando il comando ibmcloud cbr zone-update. L'esempio seguente aggiorna il nome della zona, gli indirizzi consentiti e quelli esclusi per una zona di rete con l'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

Aggiornamento delle zone di rete tramite API

Per aggiornare una zona di rete, completare i seguenti passaggi.

  1. Prendete la zona che volete sostituire. Nel corpo della risposta, copiare l'ID della zona e nelle intestazioni della risposta copiare l'intestazione 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. Aggiornare la zona di rete utilizzando il metodo Sostituisci zona. Il valore ETag è richiesto nell'intestazione If-Match della richiesta di sostituzione.

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

Rimozione di una regola tramite la console

L'eliminazione delle regole rimuove le restrizioni basate sul contesto dalla risorsa in questione e le richieste provenienti da qualsiasi contesto sono consentite se l'utente dispone delle autorizzazioni corrette. È possibile rimuovere una regola sulle risorse cloud completando i seguenti passaggi:

  1. Nella console IBM Cloud, andare su Gestione > Restrizioni contestuali e selezionare Regole.
  2. Fare clic sull'icona Azioni Icona Azioni Azioni nella riga che contiene la regola e fare clic su Rimuovi.

Rimozione di una regola tramite la CLI

È possibile rimuovere una regola sulle risorse cloud completando i seguenti passaggi:

  1. Recuperare l'ID della regola che si desidera eliminare utilizzando il comando regole di restrizione basate sul contesto. È possibile restringere i risultati dell'elenco specificando gli attributi come opzioni di comando.
    ibmcloud cbr rules --serviceName "iam-identity"
  2. Eliminare la regola per l'ID regola specificato utilizzando il comando cbr rule-delete.
    ibmcloud cbr rule-delete 30fd58c9b75f40e854b89c432318b4a2

Rimozione di una regola tramite l'API

È possibile rimuovere una regola sulle risorse cloud completando i seguenti passaggi:

  1. Recuperare l'ID della regola che si desidera eliminare utilizzando il metodo 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. Elimina la regola per l'ID regola specificato.
    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)
 }

Rimozione di una zona di rete tramite la console

La rimozione di una zona di rete rimuove l'insieme delle posizioni di rete consentite da cui viene creata una richiesta di accesso. Se una zona di rete viene aggiunta a una regola, è necessario prima rimuovere la zona dalla regola. Per rimuovere una zona di rete, procedere come segue:

  1. Nella console IBM Cloud, andare su Gestione > Restrizioni contestuali e selezionare Zone di rete.
  2. Fare clic sull'icona Azioni Icona Azioni Azioni nella riga che contiene la zona di rete e fare clic su Rimuovi.

Rimozione di una zona di rete tramite la CLI

La rimozione di una zona di rete rimuove l'insieme delle posizioni di rete consentite da cui viene creata una richiesta di accesso. Se una zona di rete viene aggiunta a una regola, è necessario prima rimuovere la zona dalla regola. Per ulteriori informazioni sulla rimozione di una zona da una regola, vedere Aggiornamento delle restrizioni basate sul contesto. Successivamente, completa la seguente procedura:

  1. Recuperare l'ID della zona di rete che si desidera eliminare utilizzando il comando zone di restrizione basato su contxt. È possibile restringere i risultati dell'elenco specificando il nome della zona.
    ibmcloud cbr zones --name "Example zone"
  2. Eliminare la zona di rete per l'ID zona specificato utilizzando il comando cbr zone-delete.
    ibmcloud cbr zone-delete 65810ac762004f22ac19f8f8edf70a34

Rimozione di una zona di rete tramite l'API

La rimozione di una zona di rete rimuove l'insieme delle posizioni di rete consentite da cui viene creata una richiesta di accesso. Se una zona di rete viene aggiunta a una regola, è necessario prima rimuovere la zona dalla regola. Per ulteriori informazioni sulla rimozione di una zona da una regola, vedere Aggiornamento delle restrizioni basate sul contesto. Successivamente, completa la seguente procedura:

  1. Recuperare l'ID della regola che si desidera eliminare utilizzando il metodo delle zone dell'elenco delle restrizioni basate sul contesto.
    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. Elimina la zona di rete per l'ID zona specificato.
    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)
 }

Limitazione della possibilità di gestire regole e zone di rete tramite la console

Per configurare questa regola, puntare al servizio Restrizioni basate sul contesto. Per ulteriori informazioni sulla procedura di impostazione di una regola, vedere Creazione di regole. Una regola con ambito Tutte le risorse è applicabile a tutte le risorse attuali e future gestite dal servizio. Se si desidera limitare le operazioni per una risorsa specifica, impostare la regola su Risorse specifiche > Tipo di risorsa. Per completare qualsiasi regola o operazione di gestione della zona di rete, a un utente deve essere assegnato il ruolo corretto con un criterio di accesso IAM e deve soddisfare la regola di restrizione basata sul contesto.

Limitazione della possibilità di gestire le regole e le zone di rete tramite l'API

L'esempio seguente mostra una regola in formato JSON che protegge le operazioni di gestione delle regole e delle zone di rete:

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

Una regola che specifica solo gli attributi delle risorse accountId e serviceName è applicabile a tutte le risorse attuali e future gestite dal servizio. Se si desidera limitare le operazioni per una risorsa specifica, includere l'attributo corrispondente alla risorsa resourceType. I valori validi di resourceType per il servizio di restrizioni basate sul contesto sono rule e zone.

Per completare qualsiasi regola o operazione di gestione della zona di rete, a un utente deve essere assegnato il ruolo corretto con un criterio di accesso IAM e deve soddisfare la regola di restrizione basata sul contesto.