Creazione di zone di rete

Creando le zone di rete, si stabilisce un elenco di posizioni consentite da cui proviene una richiesta di accesso. Un insieme di una o più posizioni di rete può essere specificato da indirizzi IP, come indirizzi individuali, intervalli o sottoreti e ID VPC. Dopo aver creato una zona di rete, è possibile aggiungerla a una regola.

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

1. Nella console IBM Cloud, fare clic su Gestione > Restrizioni contestuali e selezionare Zone di rete.

2. Fai clic su Crea.

   Invece di creare una zona utilizzando gli input dell'interfaccia utente, è possibile utilizzare il modulo del codice JSON per inserire direttamente JSON per creare una zona facendo clic su Inserisci come codice JSON.

3. Inserire un nome univoco e una descrizione.

4. Inserire gli indirizzi IP consentiti da cui può provenire una richiesta di accesso. Includere le eccezioni di indirizzo IP nell'elenco dei rifiuti, se necessario.

5. Immettere le VPC consentite.

   Se si desidera consentire l'accesso dalla VPC agli endpoint pubblici nella regola, includere gli indirizzi IP dei gateway pubblici nella definizione della zona insieme alla VPC.

6. Riferimento a un servizio. Selezionare il tipo di servizio e quindi selezionare un servizio. Fare clic su Aggiungi per associare gli indirizzi IP del servizio alla propria zona di rete.

   Se non si è sicuri del tipo di servizio, consultare la tabella Servizi integrati con restrizioni basate sul contesto.

7. Fare clic su Avanti per rivedere la zona di rete.

8. Fai clic su Crea.

È possibile continuare creando altre zone di rete o creando regole.

Creazione di zone di rete tramite la CLI

Creando le zone di rete, si stabilisce un elenco di posizioni consentite da cui proviene una richiesta di accesso. Un insieme di una o più posizioni di rete può essere specificato da indirizzi IP, come indirizzi individuali, intervalli o sottoreti e ID VPC. Dopo aver creato una zona di rete, è possibile aggiungerla a una regola.

1. Installare il plug-in CLI per le restrizioni contestuali eseguendo il seguente comando:

   ibmcloud plugin install cbr
   

2. Per creare una zona di rete, utilizzare il comando cbr zone-create.

   L'esempio seguente crea una zona di rete con un elenco di posizioni di rete consentite.

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

   L'esempio seguente crea una zona di rete con un riferimento di servizio. Per ulteriori informazioni, vedere Riferimenti del servizio.

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

   Per trovare un elenco dei riferimenti di servizio disponibili, eseguire il comando ibmcloud cbr service-ref-targets.

Creazione di zone di rete tramite API

Creando le zone di rete, si stabilisce un elenco di posizioni consentite da cui proviene una richiesta di accesso. Un insieme di una o più posizioni di rete può essere specificato da indirizzi IP come indirizzi individuali, intervalli o sottoreti, ID VPC e riferimenti di servizio. Dopo aver creato una zona di rete, è possibile aggiungerla a una regola.

Per creare una zona di rete, chiamare il sito API per le restrizioni basate sul contesto come mostrato nell'esempio seguente:

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

Per trovare un elenco di riferimenti ai servizi disponibili, richiamare il metodo ListAvailableServicerefTargets metodo.

Creare zone di rete con Terraform

Creando le zone di rete, si stabilisce un elenco di posizioni consentite da cui proviene una richiesta di accesso. Un insieme di una o più posizioni di rete può essere specificato da indirizzi IP come indirizzi individuali, intervalli o sottoreti, ID VPC e riferimenti di servizio. Dopo aver creato una zona di rete, è possibile aggiungerla a una regola.

Per creare una zona di rete, utilizzare la risorsa Terraform cbr_zone.

1. Per installare la CLI di Terraform e configurare il plug-in IBM Cloud Provider per Terraform, seguire l'esercitazione Per iniziare con Terraform su IBM Cloud®. Il plug-in astrae le API di IBM Cloud che vengono utilizzate per completare questo compito.

2. Creare un file di configurazione di Terraform chiamato main.tf. In questo file si aggiunge la configurazione per creare una zona di rete utilizzando HashiCorp Configuration Language. Per ulteriori informazioni, consultare il sito Documentazione di Terraform.

   L'esempio seguente crea una zona di rete che consente un singolo indirizzo IP ed esclude esplicitamente un indirizzo IP di segno contrario.

   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"
   }
   

In alternativa, è possibile utilizzare Terraform IBM Modules(TIM)for CBR Zone per creare una zona per le restrizioni basate sul contesto o aggiornare gli indirizzi in una zona esistente. Conoscere i moduli Terraform IBM.

L'esempio seguente mostra come definire una zona di rete utilizzando il modulo:

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
      ]
    }
  ]
}

Per l'elenco completo degli ingressi e gli esempi di utilizzo, vedere il modulo Restrizioni basate sul contesto su GitHub.

Creazione di regole

Definite le restrizioni alle vostre risorse cloud creando delle regole.

Per creare una regola, completare i seguenti passaggi.

1. Nella console IBM Cloud, fare clic su Gestione > Restrizioni contestuali e selezionare Regole.

2. Fai clic su Crea.

3. Selezionare il servizio che si desidera indirizzare nella regola. Poi, fai clic su Avanti.

   Quando si creano restrizioni basate sul contesto per il servizio Gruppi di accesso IAM, gli utenti che non soddisfano la regola non possono visualizzare alcun gruppo nell'account, compreso il gruppo di accesso pubblico.

4. (Facoltativo) Selezionare l'ambito delle API le cui operazioni sono limitate dalla regola. Per ulteriori informazioni, vedere Definizione dell'ambito di una regola.

   Non tutti i servizi supportano la possibilità di eseguire lo scope di una regola tramite API.

5. Estendere la restrizione a Tutte le risorse o a Risorse specifiche in base agli attributi selezionati.

6. Fare clic su Revisione > Continua.

7. Aggiungere uno o più contesti. Selezionare i tipi di endpoint e le zone di rete e fare clic su Aggiungi.

   • Per impostazione predefinita, l'accesso è consentito da tutti i tipi di endpoint supportati dal servizio quando la levetta è impostata su No. Impostare la levetta su Sì per consentire solo tipi di endpoint specifici.

   Se si desidera consentire l'accesso da una VPC agli endpoint pubblici nella regola, includere gli indirizzi IP dei gateway pubblici nella definizione della zona insieme alla VPC.

   • È possibile aggiungere alla regola zone di rete esistenti o creare nuove zone da aggiungere alla regola. Per ulteriori informazioni, vedere Creazione di zone di rete.

8. Fai clic su Continue.

9. Fornire una descrizione univoca.

10. Selezionare la modalità di applicazione della regola. È possibile decidere come applicare una regola al momento della creazione e aggiornare l'applicazione della regola in qualsiasi momento.

    • Abilita: Applicare la regola. I tentativi di accesso negati sono riportati in Activity Tracker Event Routing.
    • Disattivare: Non applicare la regola. Le restrizioni non si applicano alle risorse dell'account. Selezionare questa opzione se non si è pronti ad abilitare la regola.
    • Solo rapporti: Controlla l'impatto della regola sugli utenti senza applicarla. Tutti i tentativi di accesso alle risorse dell'account vengono registrati in Activity Tracker Event Routing. Si consiglia il monitoraggio per 30 giorni, prima di applicare la regola.

11. Fai clic su Crea.

Creazione di regole tramite la CLI

Per definire le restrizioni alle risorse cloud creando regole, utilizzare il comando ibmcloud cbr rule-create. L'esempio seguente crea una regola che ha come obiettivo il sito Kubernetes Service e consente l'accesso al servizio solo agli endpoint privati della zona di rete specificata.

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

Per l'opzione enforcement-mode, la CLI accetta i valori enabled, disabled, e report. Se non viene specificata alcuna applicazione, la regola è abilitata per impostazione predefinita. Per maggiori informazioni, vedere Applicazione delle regole.

Creare regole utilizzando l'API

Per creare restrizioni alle risorse cloud creando regole, chiamare l'API Restrizioni basate sul contesto. L'esempio seguente crea una regola abilitata che ha come target Kubernetes Service e consente l'accesso al servizio solo alle richieste provenienti dalla zona di rete specificata.

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

Creare regole con Terraform

Per definire le restrizioni alle risorse cloud creando regole, utilizzare la risorsa Terraform cbr_rule.

1. Per installare la CLI di Terraform e configurare il plug-in IBM Cloud Provider per Terraform, seguire l'esercitazione Per iniziare con Terraform su IBM Cloud®. Il plug-in astrae le API di IBM Cloud che vengono utilizzate per completare questo compito.

2. Creare un file di configurazione di Terraform chiamato main.tf. In questo file si aggiunge la configurazione per creare una regola di restrizione basata sul contesto utilizzando HashiCorp Configuration Language. Per ulteriori informazioni, consultare il sito Documentazione di Terraform.

   L'esempio seguente crea una regola che si rivolge a una specifica API di Kubernetes Service e consente solo agli endpoint privati della zona di rete specificata di chiamare le operazioni associate a tale API.

   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"
           }
     }
   }