Netzzonen erstellen

Durch die Einrichtung von Netzwerkzonen erstellen Sie eine Liste der zulässigen Standorte, von denen eine Zugriffsanfrage ausgeht. Eine Gruppe mit einer oder mehreren Netzadressen kann durch IP-Adressen wie einzelne Adressen, Bereiche oder Teilnetze und VPC-IDs angegeben werden. Nachdem Sie eine Netzzone erstellt haben, können Sie sie zu einer Regel hinzufügen.

Führen Sie zum Erstellen einer Netzzone die folgenden Schritte aus.

1. Klicken Sie in der IBM Cloud-Konsole auf Verwalten > Kontextbasierte Einschränkungen und wählen Sie Netzzonen aus.

2. Klicken Sie auf Erstellen.

   Statt eine Zone durch Eingaben in der Benutzerschnittstellen zu erstellen, können Sie das JSON-Codeformular verwenden, um direkt JSON-Code zum Erstellen einer Zone einzugeben. Klicken Sie hierzu auf Als JSON-Code eingeben.

3. Geben Sie einen eindeutigen Namen und eine Beschreibung ein.

4. Geben Sie die zulässigen IP-Adressen ein, von denen eine Zugriffsanforderung stammen kann. Nehmen Sie Ausnahmen für die IP-Adressen bei Bedarf in die Liste mit nicht zulässigen Adressen auf.

5. Geben Sie die zulässigen VPCs ein.

   Wenn Sie den Zugriff vom VPC auf öffentliche Endpunkte in Ihrer Regel zulassen möchten, fügen Sie alle öffentlichen Gateway-IP-Adressen in die Zonendefinition zusammen mit dem VPC ein.

6. Referenzieren Sie einen Service. Wählen Sie den Diensttyp und dann einen Dienst aus. Klicken Sie auf Hinzufügen, um die IP-Adressen des Dienstes mit Ihrer Netzwerkzone zu verknüpfen.

   Wenn Sie sich nicht sicher sind, um welchen Diensttyp es sich handelt, sehen Sie sich die Tabelle Integrierte Dienste mit kontextbezogenen Einschränkungen an.

7. Klicken Sie auf Weiter, um Ihre Netzzone zu überprüfen.

8. Klicken Sie auf Erstellen.

Anschließend können Sie weitere Netzzonen erstellen oder Regeln erstellen.

Erstellen von Netzwerkzonen mit Hilfe der CLI

Durch die Einrichtung von Netzwerkzonen erstellen Sie eine Liste der zulässigen Standorte, von denen eine Zugriffsanfrage ausgeht. Eine Gruppe mit einer oder mehreren Netzadressen kann durch IP-Adressen wie einzelne Adressen, Bereiche oder Teilnetze und VPC-IDs angegeben werden. Nachdem Sie eine Netzzone erstellt haben, können Sie sie zu einer Regel hinzufügen.

1. Installieren Sie das Plug-in für kontextbasierte Einschränkungen CLI, indem Sie den folgenden Befehl ausführen:

   ibmcloud plugin install cbr
   

2. Um eine Netzwerkzone zu erstellen, verwenden Sie den Befehl cbr zone-create.

   Im folgenden Beispiel wird eine Netzwerkzone mit einer Liste der zulässigen Netzwerkstandorte erstellt.

   ibmcloud cbr zone-create --name example-zone --description "Example zone description" --addresses 192.0.2.1,192.2.3.5-192.2.3.10
   

   Im folgenden Beispiel wird eine Netzwerkzone mit einer Dienstreferenz erstellt. Weitere Informationen finden Sie unter Service-Referenzen.

   ibmcloud cbr zone-create --name example-zone-1 --description "Kube zone" --service-ref service_name=containers-kubernetes
   

   Um eine Liste der verfügbaren Dienstreferenzen zu finden, führen Sie den Befehl ibmcloud cbr service-ref-targets aus.

Erstellen von Netzwerkzonen mit Hilfe der API

Durch die Einrichtung von Netzwerkzonen erstellen Sie eine Liste der zulässigen Standorte, von denen eine Zugriffsanfrage ausgeht. Ein Satz von einem oder mehreren Netzwerkstandorten kann durch IP-Adressen wie einzelne Adressen, Bereiche oder Subnetze, VPC-IDs und Dienstreferenzen angegeben werden. Nachdem Sie eine Netzzone erstellt haben, können Sie sie zu einer Regel hinzufügen.

Um eine Netzwerkzone zu erstellen, rufen Sie die kontextbasierte Beschränkungs-API wie im folgenden Beispiel gezeigt auf:

curl -X POST --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" --header "Content-Type: application/json" --data '{ "name": "an example of zone", "description": "this is an example of zone", "account_id": "12ab34cd56ef78ab90cd12ef34ab56cd", "addresses": [ { "type": "ipAddress", "value": "169.23.56.234" }, { "type": "ipRange", "value": "169.23.22.0-169.23.22.255" }, { "type": "subnet", "value": "192.0.2.0/24" }, { "type": "vpc", "value": "crn:v1:bluemix:public:is:us-south:a/12ab34cd56ef78ab90cd12ef34ab56cd::vpc:r134-d98a1702-b39a-449a-86d4-ef8dbacf281e" }, { "type": "serviceRef", "ref": { "account_id": "12ab34cd56ef78ab90cd12ef34ab56cd", "service_name": "cloud-object-storage" } } ], "excluded": [ { "type": "ipAddress", "value": "169.23.22.127" } ] }' "{base_url}/v1/zones"

AddressIPAddress ipAddressModel = new AddressIPAddress.Builder()
  .type("ipAddress")
  .value("169.23.56.234")
  .build();
AddressIPAddressRange ipRangeAddressModel = new AddressIPAddressRange.Builder()
  .type("ipRange")
  .value("169.23.22.0-169.23.22.255")
  .build();
AddressSubnet subnetAddressModel = new AddressSubnet.Builder()
  .type("subnet")
  .value("192.0.2.0/24")
  .build();
AddressVPC vpcAddressModel = new AddressVPC.Builder()
  .type("vpc")
  .value(vpcCRN)
  .build();
ServiceRefValue serviceRefValueModel = new ServiceRefValue.Builder()
  .accountId(accountID)
  .serviceName("cloud-object-storage")
  .build();
AddressServiceRef serviceRefAddressModel = new AddressServiceRef.Builder()
  .type("serviceRef")
  .ref(serviceRefValueModel)
  .build();
AddressIPAddress excludedIPAddressModel = new AddressIPAddress.Builder()
  .type("ipAddress")
  .value("169.23.22.127")
  .build();
CreateZoneOptions createZoneOptions = new CreateZoneOptions.Builder()
  .name("an example of zone")
  .accountId(accountID)
  .description("this is an example of zone")
  .addresses(java.util.Arrays.asList(ipAddressModel, ipRangeAddressModel, subnetAddressModel, vpcAddressModel, serviceRefAddressModel))
  .excluded(java.util.Arrays.asList(excludedIPAddressModel))
  .build();

Response<Zone> response = contextBasedRestrictionsService.createZone(createZoneOptions).execute();
Zone zone = response.getResult();

System.out.println(zone);

// Request models needed by this operation.

// AddressIPAddress
const ipAddressModel = {
  type: 'ipAddress',
  value: '169.23.56.234',
};
// AddressIPAddressRange
const ipRangeAddressModel = {
  type: 'ipRange',
  value: '169.23.22.0-169.23.22.255',
};
// AddressSubnet
const subnetAddressModel = {
  type: 'subnet',
  value: '192.0.2.0/24',
};
// AddressVPC
const vpcAddressModel = {
  type: 'vpc',
  value: vpcCRN,
};
// AddressServiceRef
const serviceRefAddressModel = {
  type: 'serviceRef',
  ref: {
    account_id: accountId,
    service_name: 'cloud-object-storage',
  },
};
// AddressIPAddress
const excludedIPAddressModel = {
  type: 'ipAddress',
  value: '169.23.22.127',
};

const params = {
  name: 'an example of zone',
  accountId,
  addresses: [ipAddressModel, ipRangeAddressModel, subnetAddressModel, vpcAddressModel, serviceRefAddressModel],
  excluded: [excludedIPAddressModel],
  description: 'this is an example of zone',
};

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

ip_address_model = {
  'type': 'ipAddress',
  'value': '169.23.56.234',
}
ip_range_address_model = {
  'type': 'ipRange',
  'value': '169.23.22.0-169.23.22.255',
}
subnet_address_model = {
  'type': 'subnet',
  'value': '192.0.2.0/24',
}
vpc_address_model = {
  'type': 'vpc',
  'value': vpc_crn,
}
service_ref_address_model = {
  'type': 'serviceRef',
  'ref': {
    'account_id': account_id,
    'service_name': 'cloud-object-storage',
  }
}
excluded_ip_address_model = {
  'type': 'ipAddress',
  'value': '169.23.22.127',
}

zone = context_based_restrictions_service.create_zone(
  name='an example of zone',
  account_id=account_id,
  addresses=[ip_address_model, ip_range_address_model, subnet_address_model, vpc_address_model, service_ref_address_model],
  excluded=[excluded_ip_address_model],
  description='this is an example of zone',
).get_result()

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

ipAddressModel := &contextbasedrestrictionsv1.AddressIPAddress{
  Type:  core.StringPtr("ipAddress"),
  Value: core.StringPtr("169.23.56.234"),
}
ipRangeAddressModel := &contextbasedrestrictionsv1.AddressIPAddressRange{
  Type:  core.StringPtr("ipRange"),
  Value: core.StringPtr("169.23.22.0-169.23.22.255"),
}
subnetAddressModel := &contextbasedrestrictionsv1.AddressSubnet{
  Type:  core.StringPtr("subnet"),
  Value: core.StringPtr("192.0.2.0/24"),
}
vpcAddressModel := &contextbasedrestrictionsv1.AddressVPC{
  Type:  core.StringPtr("vpc"),
  Value: core.StringPtr(vpcCRN),
}
serviceRefAddressModel := &contextbasedrestrictionsv1.AddressServiceRef{
  Type: core.StringPtr("serviceRef"),
  Ref: &contextbasedrestrictionsv1.ServiceRefValue{
    AccountID:   core.StringPtr(accountID),
    ServiceName: core.StringPtr("cloud-object-storage"),
  },
}
excludedIPAddressModel := &contextbasedrestrictionsv1.AddressIPAddress{
  Type:  core.StringPtr("ipAddress"),
  Value: core.StringPtr("169.23.22.127"),
}

createZoneOptions := contextBasedRestrictionsService.NewCreateZoneOptions()
createZoneOptions.SetName("an example of zone")
createZoneOptions.SetAccountID(accountID)
createZoneOptions.SetDescription("this is an example of zone")
createZoneOptions.SetAddresses([]contextbasedrestrictionsv1.AddressIntf{ipAddressModel, ipRangeAddressModel, subnetAddressModel, vpcAddressModel, serviceRefAddressModel})
createZoneOptions.SetExcluded([]contextbasedrestrictionsv1.AddressIntf{excludedIPAddressModel})

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

Um eine Liste der verfügbaren Dienstreferenzen zu finden, rufen Sie die ListAvailableServicerefTargets methode auf.

Erstellen von Netzwerkzonen mit Terraform

Durch die Einrichtung von Netzwerkzonen erstellen Sie eine Liste der zulässigen Standorte, von denen eine Zugriffsanfrage ausgeht. Ein Satz von einem oder mehreren Netzwerkstandorten kann durch IP-Adressen wie einzelne Adressen, Bereiche oder Subnetze, VPC-IDs und Dienstreferenzen angegeben werden. Nachdem Sie eine Netzzone erstellt haben, können Sie sie zu einer Regel hinzufügen.

Um eine Netzwerkzone zu erstellen, verwenden Sie die Terraform-Ressource cbr_zone.

1. Um die Terraform-CLI zu installieren und das IBM Cloud Provider-Plug-in für Terraform zu konfigurieren, führen Sie das Lernprogramm für Erste Schritte mit auf IBM Cloud®aus. Das Plug-in abstrahiert die IBM Cloud APIs, die zur Erfüllung dieses Tasks verwendet werden.

2. Erstellen Sie eine Terraform-Konfigurationsdatei mit dem Namen main.tf. In dieser Datei fügen Sie die Konfiguration zur Erstellung einer Netzwerkzone mit Hilfe der HashiCorp Configuration Language hinzu. Weitere Informationen finden Sie in der Terraform-Dokumentation.

   Das folgende Beispiel erstellt eine Netzwerkzone, die eine einzelne IP-Adresse zulässt und eine andere IP-Adresse ausdrücklich ausschließt.

   resource "ibm_cbr_zone" "cbr_zone" {
     account_id = "12ab34cd56ef78ab90cd12ef34ab56cd"
     addresses {
           type = "ipAddress"
           value = "169.23.56.234"
     }
     description = "this is an example of zone"
     excluded {
           type = "ipAddress"
           value = "202.38.89.897"
     }
     name = "an example of zone"
   }
   

Alternativ können Sie auch Terraform IBM Module(TIM)für CBR Zone verwenden, um eine Zone für kontextbasierte Einschränkungen zu erstellen oder Adressen in einer bestehenden Zone zu aktualisieren. Erfahren Sie mehr über Terraform IBM Module.

Das folgende Beispiel zeigt, wie eine Netzwerkzone mithilfe des Moduls definiert wird:

module "cbr" {
  source  = "terraform-ibm-modules/cbr/ibm"
  version = "X.X.X" # Replace with the latest version

  cbr_zones = [
    {
      name             = "my-network-zone"
      zone_description = "Zone for approved IP ranges and VPCs"
      addresses = [
        { type = "ipRange", value = "10.0.0.0/8" }, # use your valid/supported CIDR range.
        { type = "vpc",     value = "abcxxxx..." } # provide vpc crn
      ]
    }
  ]
}

Eine vollständige Liste der Eingaben und Verwendungsbeispiele finden Sie im Modul "Kontextbasierte Einschränkungen" auf GitHub.

Regeln erstellen

Durch die Erstellung von Regeln können Sie Einschränkungen für Ihre Cloudressourcen definieren.

Führen Sie zum Erstellen einer Regel die folgenden Schritte aus.

1. Klicken Sie in der IBM Cloud-Konsole auf Verwalten > Kontextbasierte Einschränkungen und wählen Sie Regeln aus.

2. Klicken Sie auf Erstellen.

3. Wählen Sie den Service aus, den Sie in Ihrer Regel als Ziel festlegen wollen. Klicken Sie anschließend auf Weiter.

   Wenn Sie eine kontextbasierte Einschränkung für den IAM-Zugriffsgruppendienst erstellen, können Benutzer, die die Regel nicht erfüllen, keine Gruppen im Konto anzeigen, auch nicht die öffentliche Zugriffsgruppe.

4. (Optional) Wählen Sie den Bereich der APIs aus, deren Operationen durch Ihre Regel eingeschränkt werden. Weitere Informationen finden Sie unter Definieren des Geltungsbereichs einer Regel.

   Nicht alle Dienste unterstützen die Möglichkeit, eine Regel über die API zu erfassen.

5. Beschränkung auf alle Ressourcen oder bestimmte Ressourcen auf der Grundlage der ausgewählten Attribute.

6. Klicken Sie auf Überprüfen > Weiter.

7. Fügen Sie einen oder mehrere Kontexte hinzu. Wählen Sie die Endpunkttypen und Netzzonen aus und klicken Sie auf Hinzufügen.

   • Standardmäßig ist der Zugriff von allen vom Dienst unterstützten Endpunkttypen aus erlaubt, wenn der Schalter auf Nein gesetzt ist. Setzen Sie die Umschaltfunktion auf Ja, um nur bestimmte Endpunkttypen zuzulassen.

   Wenn Sie in Ihrer Regel den Zugriff von einem VPC auf öffentliche Endpunkte zulassen möchten, fügen Sie alle öffentlichen Gateway-IP-Adressen in die Zonendefinition zusammen mit dem VPC ein.

   • Sie können vorhandene Netzzonen zu Ihrer Regel hinzufügen oder neue Zonen erstellen, die zu Ihrer Regel hinzugefügt werden sollen. Weitere Informationen finden Sie unter Erstellen von Netzwerkzonen.

8. Klicken Sie auf Weiter.

9. Geben Sie eine eindeutige Beschreibung.

10. Wählen Sie aus, wie Sie die Regel durchsetzen wollen. Sie können entscheiden, wie Sie eine Regel bei der Erstellung durchsetzen wollen und die Durchsetzung der Regel jederzeit aktualisieren.

    • Aktivieren: Erzwingen Sie die Regel. Verweigerte Zugriffsversuche werden in Activity Tracker Event Routing gemeldet.
    • Deaktivieren: Die Regel wird nicht durchgesetzt. Einschränkungen gelten nicht für Ihre Kontoressourcen. Wählen Sie diese Option, wenn Sie die Regel noch nicht aktivieren wollen.
    • Nur Bericht: Überwachen Sie, wie sich die Regel auf die Benutzer auswirkt, ohne sie durchzusetzen. Alle Versuche, auf die Ressourcen des Kontos zuzugreifen, werden in Activity Tracker Event Routing protokolliert. Es wird empfohlen, die Überwachung 30 Tage lang durchzuführen, bevor Sie die Regel durchsetzen.

11. Klicken Sie auf Erstellen.

Erstellen von Regeln mit Hilfe der CLI

Um Einschränkungen für Ihre Cloud-Ressourcen zu definieren, indem Sie Regeln erstellen, verwenden Sie den Befehl ibmcloud cbr rule-create. Im folgenden Beispiel wird eine Regel erstellt, die auf Kubernetes Service abzielt und nur privaten Endpunkten aus der angegebenen Netzwerkzone den Zugriff auf den Dienst erlaubt.

ibmcloud cbr rule-create --description 'Example Rule Description' --service-name kms --context-attributes endpointType=private --zone-id 93de8d3f588ab2c457ff576c364d1145 --enforcement-mode report

Für die Option enforcement-mode akzeptiert die CLI die Werte enabled, disabled und report. Wenn keine Durchsetzung angegeben wird, ist die Regel standardmäßig aktiviert. Weitere Informationen finden Sie unter Regeldurchsetzung.

Regeln mithilfe der API erstellen

Um Einschränkungen für Ihre Cloud-Ressourcen durch die Erstellung von Regeln zu erstellen, rufen Sie die API für kontextbasierte Einschränkungen auf. Im folgenden Beispiel wird eine aktivierte Regel erstellt, die auf Kubernetes Service abzielt und den Zugriff auf den Dienst nur für Anfragen aus der angegebenen Netzwerkzone zulässt.

curl -X POST --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" --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": "65810ac762004f22ac19f8f8edf70a34" } ] } ], "enforcement_mode": "enabled" }' "{base_url}/v1/rules"

RuleContextAttribute ruleContextAttributeModel = new RuleContextAttribute.Builder()
  .name("networkZoneId")
  .value(zoneID)
  .build();
RuleContext ruleContextModel = new RuleContext.Builder()
  .attributes(java.util.Arrays.asList(ruleContextAttributeModel))
  .build();
ResourceAttribute resourceAttributeModelAccountID = new ResourceAttribute.Builder()
  .name("accountId")
  .value(accountID)
  .build();
ResourceAttribute resourceAttributeModelServiceName = new ResourceAttribute.Builder()
  .name("serviceName")
  .value(serviceName)
  .build();
ResourceTagAttribute resourceTagAttributeModel = new ResourceTagAttribute.Builder()
  .name("tagName")
  .value("tagValue")
  .build();
Resource resourceModel = new Resource.Builder()
  .addAttributes(resourceAttributeModelAccountID)
  .addAttributes(resourceAttributeModelServiceName)
  .tags(java.util.Arrays.asList(resourceTagAttributeModel))
  .build();
CreateRuleOptions createRuleOptions = new CreateRuleOptions.Builder()
  .description("this is an example of rule")
  .addContexts(ruleContextModel)
  .addResources(resourceModel)
  .enforcementMode("enabled")
  .build();

Response<Rule> response = contextBasedRestrictionsService.createRule(createRuleOptions).execute();
Rule rule = response.getResult();

System.out.println(rule);
ruleID = rule.getId();
ruleRev = response.getHeaders().values("Etag").get(0);

// Request models needed by this operation.

// RuleContextAttribute
const ruleContextAttributeModel = {
  name: 'networkZoneId',
  value: zoneId,
};

// RuleContext
const ruleContextModel = {
  attributes: [ruleContextAttributeModel],
};

// ResourceAttribute
const resourceAttributeAccountIdModel = {
  name: 'accountId',
  value: accountId,
};

// Resource Attribute
const resourceAttributeServiceNameModel = {
  name: 'serviceName',
  value: serviceName,
  operator: 'stringEquals',
};

// Resource
const resourceModel = {
  attributes: [resourceAttributeAccountIdModel, resourceAttributeServiceNameModel],
};

const params = {
  contexts: [ruleContextModel],
  resources: [resourceModel],
  description: 'this is an example of rule',
  enforcementMode: 'enabled',
};

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

rule_context_attribute_model = {
  'name': 'networkZoneId',
  'value': zone_id,
}

rule_context_model = {
  'attributes': [rule_context_attribute_model],
}

resource_attribute_account_id_model = {
  'name': 'accountId',
  'value': account_id,
}

resource_attribute_service_name_model = {
  'name': 'serviceName',
  'value': service_name,
}

resource_model = {
  'attributes': [resource_attribute_account_id_model, resource_attribute_service_name_model],
}

rule = context_based_restrictions_service.create_rule(
  contexts=[rule_context_model],
  resources=[resource_model],
  description='this is an example of rule',
  enforcement_mode='enabled'
).get_result()

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

ruleContextAttributeModel := &contextbasedrestrictionsv1.RuleContextAttribute{
  Name:  core.StringPtr("networkZoneId"),
  Value: core.StringPtr(zoneID),
}

ruleContextModel := &contextbasedrestrictionsv1.RuleContext{
  Attributes: []contextbasedrestrictionsv1.RuleContextAttribute{*ruleContextAttributeModel},
}

resourceModel := &contextbasedrestrictionsv1.Resource{
  Attributes: []contextbasedrestrictionsv1.ResourceAttribute{
    {
      Name:  core.StringPtr("accountId"),
      Value: core.StringPtr(accountID),
    },
    {
      Name:  core.StringPtr("serviceName"),
      Value: core.StringPtr(serviceName),
    },
  },
  Tags: []contextbasedrestrictionsv1.ResourceTagAttribute{
    {
      Name:  core.StringPtr("tagName"),
      Value: core.StringPtr("tagValue"),
    },
  },
}

createRuleOptions := contextBasedRestrictionsService.NewCreateRuleOptions()
createRuleOptions.SetDescription("this is an example of rule")
createRuleOptions.SetContexts([]contextbasedrestrictionsv1.RuleContext{*ruleContextModel})
createRuleOptions.SetResources([]contextbasedrestrictionsv1.Resource{*resourceModel})
createRuleOptions.SetEnforcementMode(contextbasedrestrictionsv1.CreateRuleOptionsEnforcementModeEnabledConst)
rule, response, err := contextBasedRestrictionsService.CreateRule(createRuleOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(rule, "", "  ")
fmt.Println(string(b))

Erstellen von Regeln mit Terraform

Um Einschränkungen für Ihre Cloud-Ressourcen zu definieren, indem Sie Regeln erstellen, verwenden Sie die Terraform-Ressource cbr_rule.

1. Um die Terraform-CLI zu installieren und das IBM Cloud Provider-Plug-in für Terraform zu konfigurieren, führen Sie das Lernprogramm für Erste Schritte mit auf IBM Cloud®aus. Das Plug-in abstrahiert die IBM Cloud APIs, die zur Erfüllung dieses Tasks verwendet werden.

2. Erstellen Sie eine Terraform-Konfigurationsdatei mit dem Namen main.tf. In dieser Datei fügen Sie die Konfiguration zur Erstellung einer kontextbasierten Beschränkungsregel mit Hilfe der HashiCorp Configuration Language hinzu. Weitere Informationen finden Sie in der Terraform-Dokumentation.

   Im folgenden Beispiel wird eine Regel erstellt, die auf eine bestimmte Kubernetes Service API abzielt und nur privaten Endpunkten aus der angegebenen Netzwerkzone erlaubt, die mit dieser API verbundenen Vorgänge aufzurufen.

   resource "ibm_cbr_rule" "cbr_rule" {
     contexts {
           attributes {
               name = "endpointType"
               value = "private"
           }
     }
     description = "this is an example of rule"
     enforcement_mode = "enabled"
     operations {
           api_types {
               api_type_id = "api_type_id"
           }
     }
     resources {
           attributes {
               name = "serviceName"
               value = "containers-kubernetes"
               operator = "equals"
           }
     }
   }