IBM Cloud Docs
Umgang mit kontextbasierten Einschränkungen

Umgang mit kontextbasierten Einschränkungen

Sie können Kontextregeln jederzeit verwalten, indem Sie die Beschreibung aktualisieren, um den Zweck der Regel zu ermitteln, oder indem Sie eine neue Liste von Ressourcen und Netzwerkumgebungen auswählen. Sie können auch kontextbasierte Einschränkungen entfernen, um Einschränkungen zu löschen, die durch die Kontexte in einer Regel definiert sind.

Kontextbasierte Einschränkungen können Zugriffsbeschränkungen für die eigenen IBM Cloud®-Ressourcen definieren und durchsetzen. Sie können diese Einschränkungen basierend auf Kontexten wie Netzwerkzonen und Endpunkttypen definieren. Weitere Informationen finden Sie unter Was sind kontextbasierte Einschränkungen?

Der kontextbasierte Einschränkungsdienst verwaltet Regeln und Netzwerkzonen, sodass es möglich ist, die Fähigkeit zur Verwaltung dieser Ressourcen zu verlieren, wenn Sie eine Regel im kontextbasierten Einschränkungsdienst nicht erfüllen können. Versuche, eine solche Regel zu erstellen oder zu aktualisieren, sind nur zulässig, wenn der Kontext der Anfrage der neuen oder geänderten Regel entspricht.

Wenn Sie eine Regel, die auf den kontextbasierten Einschränkungsdienst abzielt, nicht mehr erfüllen können, öffnen Sie einen Support-Fall und geben Sie einen Kontext an, den Sie erfüllen können, um Ihren Zugang wiederherzustellen.

Vorbereitende Schritte

Um kontextbasierte Einschränkungen verwalten zu können, müssen Sie die Administratorrolle für den Kontoverwaltungsdienst zugewiesen bekommen haben.

Aktualisierung von Regeln über die Konsole

Führen Sie die folgenden Schritte aus, um die kontextbasierten Einschränkungen für Ihre Cloud-Ressourcen zu bearbeiten:

  1. Klicken Sie in der IBM Cloud-Konsole auf Verwalten > Kontextbasierte Einschränkungen und wählen Sie Regeln aus.
  2. Wählen Sie das Symbol Aktionen Aktions-Symbol für die Regel aus, die Sie aktualisieren möchten, und wählen Sie Bearbeiten aus.
  3. Um den Umfang der APIs zu aktualisieren, deren Betrieb durch Ihre Regel eingeschränkt ist, wählen Sie "Alle APIs" oder "Bestimmte APIs" aus. Klicken Sie anschließend auf Anwenden oder auf Weiter.
  4. Um den Umfang der Ressourcen für die Einschränkung zu aktualisieren, können Sie "Alle Ressourcen" oder "Bestimmte Ressourcen" basierend auf den verfügbaren Attributen, wie Ressourcengruppe oder Standort, auswählen. Klicken Sie anschließend auf Anwenden oder auf Weiter.
  5. Klicken Sie auf das Symbol „Bearbeiten“ Symbol „Bearbeiten“ im Übersichtsbereich, um einen vorhandenen Kontext zu aktualisieren.
    1. Aktualisieren Sie die zulässigen Endpunkttypen.
      • Stellen Sie den Schalter auf "Nein", um alle vom Dienst unterstützten Endpunkttypen zuzulassen.
      • Stellen Sie den Schalter auf "Ja", um nur bestimmte Endpunkttypen zuzulassen.
    2. Aktualisieren Sie die Netzwerkzonen. Sie können neue Netzwerkzonen auswählen oder die Auswahl von Netzwerkzonen aufheben, um sie zu entfernen.
  6. Klicken Sie dann auf "Übernehmen ".
  7. Klicken Sie auf das Symbol Entfernen Symbol entfernen im Zusammenfassungsfeld, um einen Kontext zu entfernen.
  8. Konfigurieren Sie einen neuen Kontext, indem Sie alle Endpunkte oder einen bestimmten Endpunkt auswählen und die Netzzonen auswählen. Klicken Sie dann auf Hinzufügen.
  9. Klicken Sie auf "Übernehmen" oder "Weiter ".
  10. Geben Sie eine neue Beschreibung für Ihre Regel an. Klicken Sie auf "Übernehmen ", um die Beschreibung zu aktualisieren, oder klicken Sie auf "Weiter ".
  11. Um die Durchsetzung einer Regel zu aktualisieren, klicken Sie auf das Symbol "Bearbeiten" Sie können die Regel aktivieren, deaktivieren oder auf "Nur melden" einstellen.
  12. Klicken Sie zum Schluss auf Anwenden.

Aktualisieren von Regeln mithilfe der CLI

Um die kontextbasierten Einschränkungen für Ihre Cloud-Ressourcen zu aktualisieren, verwenden Sie den Befehl ibmcloud cbr rule-update. Im folgenden Beispiel werden Beschreibung, zulässiger Endpunkttyp und Netzwerkzone für eine Regel mit der ID 30fd58c9b75f40e854b89c432318b4a2 aktualisiert.

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

Aktualisierung von Regeln mithilfe der API

Um Einschränkungen für Ihre Cloud-Ressourcen durch das Erstellen von Regeln zu aktualisieren, rufen Sie die API für kontextbasierte Einschränkungen auf.

  1. Suchen Sie die Regel, die Sie ersetzen möchten. Kopieren Sie in der Antwort die Regel-ID und in den Antwort-Headern den ETag-Header.

    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. Im folgenden Beispiel wird eine Regel durch eine aktualisierte Version ersetzt. Der ETag-Wert ist im If-Match-Header der Ersetzungsanfrage erforderlich.

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

Aktualisierung von Netzwerkzonen mithilfe der Konsole

Sie können die Liste der zulässigen Standorte ändern, von denen eine Zugriffsanforderung stammen kann. Eine Gruppe von einer oder mehreren Netzadressen kann durch IP-Adressen (einzelne Adressen, Bereiche oder Teilnetze), VPCs oder Servicereferenzen angegeben werden. Sie können eine Netzzone aktualisieren, die in einer Regel verwendet wird, oder die neuen aktualisierten Netzzonen später in Ihre Regeln integrieren.

  1. Klicken Sie in der IBM Cloud-Konsole auf Verwalten > Kontextbasierte Einschränkungen und wählen Sie Netzzonen aus.
  2. Wählen Sie das Symbol Aktionen Symbol Aktionen für die Netzwerkzone, die Sie aktualisieren möchten, und wählen Sie Bearbeiten aus.
  3. Sie können den Namen und die Beschreibung Ihrer Zone aktualisieren.
  4. Sie können die Liste der zulässigen IP-Adressen bearbeiten, von denen eine Zugriffsanforderung stammen kann. Nehmen Sie Ausnahmen bei Bedarf in die Liste mit nicht zulässigen Adressen auf.
  5. Sie können zulässige VPCs hinzufügen oder entfernen.
  6. Sie können Servicereferenzen hinzufügen oder entfernen. Wählen Sie einen Service aus, um seine IP-Adressen Ihrer Netzzone zuzuordnen.
  7. Klicken Sie auf Weiter, um Ihre neue Konfiguration zu überprüfen.
  8. Klicken Sie zum Anwenden Ihrer Änderungen auf Aktualisieren.

Aktualisieren von Netzwerkzonen mithilfe der CLI

Führen Sie die folgenden Schritte aus, um eine Netzwerkzone zu aktualisieren.

  1. Rufen Sie die Zonen-ID für die Netzwerkzone ab, die Sie aktualisieren möchten, indem Sie mit dem Befehl "ibmcloud cbr zones" alle Zonen im Konto auflisten.
    ibmcloud cbr zones
  2. Aktualisieren Sie die Netzwerkzone mit dem Befehl "ibmcloud cbr zone-update ". Im folgenden Beispiel werden der Zonenname, die zulässigen Adressen und die ausgeschlossenen Adressen für eine Netzwerkzone mit der ID 65810ac762004f22ac19f8f8edf70a34 aktualisiert.
    ibmcloud cbr zone-update 65810ac762004f22ac19f8f8edf70a34 --name 'Example Zone Name' --addresses 166.22.23.0-166.22.23.108 --excluded 166.22.23.100

Aktualisierung von Netzwerkzonen mithilfe der API

Führen Sie die folgenden Schritte aus, um eine Netzwerkzone zu aktualisieren.

  1. Holen Sie sich die Zone, die Sie ersetzen möchten. Kopieren Sie im Antworttext die Zonen-ID und in den Antwort-Headern den ETag-Header.

    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. Aktualisieren Sie die Netzwerkzone mithilfe der Methode "Zone ersetzen ". Der ETag-Wert ist im If-Match-Header der Ersetzungsanfrage erforderlich.

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

Entfernen einer Regel mithilfe der Konsole

Beim Löschen von Regeln werden kontextbasierte Einschränkungen aus der angegebenen Ressource entfernt. Dann sind aus jedem Kontext Anforderungen zulässig, wenn der Benutzer über die korrekten Berechtigungen verfügt. Mit den folgenden Schritten können Sie eine Regel für Ihre Cloudressourcen entfernen:

  1. Navigieren Sie in der IBM Cloud-Konsole zu Verwalten > Kontextbasierte Einschränkungen und wählen Sie Regeln aus.
  2. Klicken Sie auf das Aktionen-Symbol Aktionen-Symbol in der Zeile, die die Regel enthält, und klicken Sie auf Entfernen.

Entfernen einer Regel mithilfe der CLI

Mit den folgenden Schritten können Sie eine Regel für Ihre Cloudressourcen entfernen:

  1. Rufen Sie die Regel-ID für die Regel ab, die Sie löschen möchten, indem Sie den Befehl "context-based restrictions rules" verwenden. Sie können die Ergebnisse der Liste eingrenzen, indem Sie Attribute als Befehlsoptionen angeben.
    ibmcloud cbr rules --serviceName "iam-identity"
  2. Löschen Sie die Regel für die angegebene Regel-ID mit dem Befehl cbr rule-delete.
    ibmcloud cbr rule-delete 30fd58c9b75f40e854b89c432318b4a2

Entfernen einer Regel mithilfe der API

Mit den folgenden Schritten können Sie eine Regel für Ihre Cloudressourcen entfernen:

  1. Rufen Sie die Regel-ID für die Regel ab, die Sie löschen möchten, indem Sie die Methode "Regeln der Liste der kontextbasierten Einschränkungen" verwenden.
    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. Löschen Sie die Regel für die angegebene Regel-ID.
    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)
 }

Entfernen einer Netzwerkzone mithilfe der Konsole

Durch das Entfernen einer Netzzone wird die Gruppe der zulässigen Netzadressen entfernt, von denen aus eine Zugriffsanforderung erstellt werden kann. Wenn eine Netzzone zu einer Regel hinzugefügt wurde, müssen Sie zuerst die Zone aus der Regel entfernen. Führen Sie die folgenden Schritte aus, um eine Netzwerkzone zu entfernen:

  1. Gehen Sie in der Konsole IBM Cloud zu Verwalten > Kontextbasierte Einschränkungen und wählen Sie Netzwerkzonen aus.
  2. Klicken Sie auf das Symbol Aktionen Aktionen-Symbol in der Zeile, die die Netzzone enthält, und klicken Sie auf Entfernen.

Entfernen einer Netzwerkzone mithilfe der CLI

Durch das Entfernen einer Netzzone wird die Gruppe der zulässigen Netzadressen entfernt, von denen aus eine Zugriffsanforderung erstellt werden kann. Wenn eine Netzzone zu einer Regel hinzugefügt wurde, müssen Sie zuerst die Zone aus der Regel entfernen. Weitere Informationen zum Entfernen einer Zone aus einer Regel finden Sie unter Aktualisieren kontextbasierter Einschränkungen. Gehen Sie anschließend wie folgt vor:

  1. Rufen Sie die Zonen-ID für die Netzwerkzone ab, die Sie löschen möchten, indem Sie den Befehl "contxt-based restrictions zones" verwenden. Sie können die Ergebnisse der Liste eingrenzen, indem Sie den Namen der Zone angeben.
    ibmcloud cbr zones --name "Example zone"
  2. Löschen Sie die Netzwerkzone für die angegebene Zonen-ID mit dem Befehl cbr zone-delete.
    ibmcloud cbr zone-delete 65810ac762004f22ac19f8f8edf70a34

Entfernen einer Netzwerkzone mithilfe der API

Durch das Entfernen einer Netzzone wird die Gruppe der zulässigen Netzadressen entfernt, von denen aus eine Zugriffsanforderung erstellt werden kann. Wenn eine Netzzone zu einer Regel hinzugefügt wurde, müssen Sie zuerst die Zone aus der Regel entfernen. Weitere Informationen zum Entfernen einer Zone aus einer Regel finden Sie im Abschnitt Kontextbasierte Einschränkungen aktualisieren. Gehen Sie anschließend wie folgt vor:

  1. Rufen Sie die Regel-ID für die Regel ab, die Sie löschen möchten, indem Sie die Methode "Zonenliste für kontextbasierte Einschränkungen" verwenden.
    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. Löschen Sie die Netzwerkzone für die angegebene Zonen-ID.
    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)
 }

Einschränkung der Möglichkeit, Regeln und Netzwerkzonen über die Konsole zu verwalten

Um diese Regel zu konfigurieren, richten Sie sich an den Dienst für kontextbasierte Einschränkungen. Weitere Informationen über die Schritte zum Einrichten einer Regel finden Sie unter "Regeln erstellen ". Eine Regel, die auf alle Ressourcen angewendet wird, gilt für alle aktuellen und zukünftigen Ressourcen, die von dem Dienst verwaltet werden. Wenn Sie Vorgänge für eine bestimmte Ressource einschränken möchten, wählen Sie "Bestimmte Ressourcen > Ressourcentyp" als Regelbereich aus. Um eine Regel- oder Netzwerkzonenverwaltung abzuschließen, muss einem Benutzer die richtige Rolle mit einer IAM-Zugriffsrichtlinie zugewiesen werden und er muss die kontextbasierte Einschränkungsregel erfüllen.

Einschränkung der Möglichkeit, Regeln und Netzwerkzonen mithilfe der API zu verwalten

Das folgende Beispiel zeigt eine Regel im JSON-Format, die Regel- und Netzwerkzonenverwaltungsvorgänge schützt:

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

Eine Regel, die nur die Ressourcenattribute accountId und serviceName angibt, gilt für alle aktuellen und zukünftigen Ressourcen, die von dem Dienst verwaltet werden. Wenn Sie Vorgänge für eine bestimmte Ressource einschränken möchten, fügen Sie das entsprechende Ressourcenattribut resourceType hinzu. Gültige resourceType-Werte für den kontextbasierten Einschränkungsdienst sind rule und zone.

Um eine Regel- oder Netzwerkzonenverwaltung abzuschließen, muss einem Benutzer die richtige Rolle mit einer IAM-Zugriffsrichtlinie zugewiesen werden und er muss die kontextbasierte Einschränkungsregel erfüllen.