Verwaltung kontextbezogener Einschränkungen

Sie können Kontextregeln jederzeit verwalten, indem Sie die Beschreibung aktualisieren, die den Zweck der Regel verdeutlicht, oder 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 ihre eigenen IBM Cloud® Ressourcen definieren und durchsetzen. Sie können diese Einschränkungen auf der Grundlage von Kontexten, wie Netzwerkzonen und Endpunkttypen, definieren. Weitere Informationen finden Sie unter Was sind kontextbasierte Einschränkungen?

Der kontextbasierte Beschränkungsdienst verwaltet Regeln und Netzwerkzonen, so dass es möglich ist, dass Sie alle Möglichkeiten zur Verwaltung dieser Ressourcen verlieren, wenn Sie eine Regel des kontextbasierten Beschränkungsdienstes 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 nicht mehr erfüllen können, die auf den kontextbasierten Beschränkungsdienst abzielt, öffnen Sie einen Support-Fall und geben Sie einen Kontext an, den Sie erfüllen können, um Ihren Zugang wiederherzustellen.

Vorbereitende Schritte

Um kontextbezogene Einschränkungen zu verwalten, muss Ihnen die Rolle eines Administrators im Kontoverwaltungsdienst zugewiesen werden.

Aktualisierung der Regeln über die Konsole

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

  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 Aktionen Aktionen auf der Regel, die Sie aktualisieren möchten, und wählen Sie Bearbeiten.
  3. Um den Bereich der APIs zu aktualisieren, deren Operationen durch Ihre Regel eingeschränkt sind, wählen Sie Alle APIs oder Bestimmte APIs. 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 auf der Grundlage der verfügbaren Attribute, wie Ressourcengruppe oder Standort, Alle Ressourcen oder Bestimmte Ressourcen auswählen. Klicken Sie anschließend auf Anwenden oder auf Weiter.
  5. Klicken Sie im Übersichtsbereich auf das Symbol Bearbeiten , um einen bestehenden Kontext zu aktualisieren.
    1. Aktualisieren Sie die zulässigen Endpunkttypen.
      • Setzen Sie den Schalter auf Nein, um alle vom Dienst unterstützten Endpunkttypen zuzulassen.
      • Setzen Sie die Umschaltfunktion auf Ja, um nur bestimmte Endpunkttypen zuzulassen.
    2. Aktualisieren Sie die neuen Arbeitsbereiche. Sie können neue Netzzonen auswählen oder die Auswahl von Netzzonen aufheben, um sie zu entfernen.
  6. Klicken Sie dann auf Übernehmen.
  7. Klicken Sie auf das Symbol Entfernen im Übersichtsfenster, 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 Bearbeiten-Symbol Bearbeiten-Symbol. Sie können Aktivieren Sie, Deaktivieren Sie, oder die Regel auf Nur Bericht setzen.
  12. Klicken Sie zum Schluss auf Anwenden.

Aktualisierung der Regeln mit Hilfe 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 mit Hilfe der API

Um Einschränkungen für Ihre Cloud-Ressourcen zu aktualisieren, indem Sie Regeln erstellen, rufen Sie die API für kontextbasierte Einschränkungen auf.

  1. Holen Sie sich die Regel, die Sie ersetzen wollen. Kopieren Sie in den Antwortkörper die Regel-ID und in die Antwort-Header 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 über die 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 Aktionen Aktionen auf der Netzwerkzone, die Sie aktualisieren möchten, und wählen Sie Bearbeiten.
  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.

Aktualisierung von Netzwerkzonen mit Hilfe der CLI

Um eine Netzwerkzone zu aktualisieren, führen Sie die folgenden Schritte aus.

  1. Rufen Sie die Zonen-ID für die Netzwerkzone ab, die Sie aktualisieren möchten, indem Sie den Befehl ibmcloud cbr zones verwenden, um alle Zonen im Konto aufzulisten. 
    ibmcloud cbr zones
  2. Aktualisieren Sie die Netzwerkzone mit dem Befehl ibmcloud cbr zone-update. Das folgende Beispiel aktualisiert den Zonennamen, die zulässigen Adressen und die ausgeschlossenen Adressen für eine Netzwerkzone mit der 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

Aktualisierung von Netzwerkzonen mit Hilfe der API

Um eine Netzwerkzone zu aktualisieren, führen Sie die folgenden Schritte aus.

  1. Holen Sie sich die Zone, die Sie ersetzen wollen. Kopieren Sie im Antwortkörper 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 mit 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 über die 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 mit Hilfe 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, die Sie löschen möchten, mit dem Befehl Kontextbasierte Beschränkungsregeln ab. Sie können die Ergebnisse der Liste einschränken, indem Sie Attribute als Befehlsoptionen angeben.
    ibmcloud cbr rules --serviceName "iam-identity"
  2. Löschen Sie die Regel für die angegebene Regel-ID, indem Sie den Befehl cbr rule-delete verwenden.
    ibmcloud cbr rule-delete 30fd58c9b75f40e854b89c432318b4a2

Entfernen einer Regel mit Hilfe 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 zu löschende Regel mit der Methode context-based-restrictions list rules ab.
    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öscht 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 über die 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 auf Verwalten > Kontextbasierte Einschränkungen und wählen Sie Netzwerkzonen.
  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 mit Hilfe 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 von kontextbasierten 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 einschränken, 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 mit Hilfe 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 zu löschende Regel mit der Methode der kontextbasierten Beschränkungslistenzonen ab.
    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öscht 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, zielen Sie auf den Dienst für kontextbezogene Einschränkungen. Weitere Informationen über die Schritte zum Einrichten einer Regel finden Sie unter Erstellen von Regeln. Eine Regel, die sich auf Alle Ressourcen bezieht, 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, erweitern Sie die Regel auf bestimmte Ressourcen > Ressourcentyp. Um eine Regel oder einen Netzwerkzonen-Verwaltungsvorgang abzuschließen, muss einem Benutzer die richtige Rolle mit einer IAM-Zugriffsrichtlinie zugewiesen werden und er muss die kontextbasierte Beschränkungsregel erfüllen.

Einschränkung der Möglichkeit, Regeln und Netzwerkzonen mit Hilfe 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 wollen, fügen Sie das entsprechende resourceType Ressourcenattribut ein. Gültige resourceType Werte für den Dienst für kontextbezogene Einschränkungen sind rule und zone.

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