Creación de zonas de red

Al crear zonas de red, se establece una lista de ubicaciones permitidas en las que se origina una solicitud de acceso. Puede especificar un juego de una o varias ubicaciones de red por dirección IP como direcciones individuales, rangos o subredes, e ID de VPC. Después de crear una zona de red, puede añadirla a una regla.

Para crear una zona de red, siga estos pasos.

1. En la consola de IBM Cloud, pulse Gestionar > Restricciones basadas en contexto y seleccione Zonas de red.

2. Pulse Crear.

   En lugar de crear una zona utilizando entradas de IU, puede utilizar el formato de código JSON para especificar directamente JSON para crear una zona pulsando Especificar como código JSON.

3. Especifique un nombre exclusivo y una descripción.

4. Especifique las direcciones IP permitidas donde se puede originar una solicitud de acceso. Incluya excepciones de dirección IP en la lista de denegación, si es necesario.

5. Especifique los VPC permitidos.

   Si desea permitir el acceso desde la VPC a puntos finales públicos en su regla, incluya cualquier dirección IP de puerta de enlace pública en la definición de zona junto con la VPC.

6. Haga referencia a un servicio. Seleccione el tipo de servicio y, a continuación, seleccione un servicio. Haga clic en Añadir para asociar las direcciones IP del servicio a su zona de red.

   Si no está seguro de cuál es el tipo de servicio, consulte la tabla Servicios integrados con restricciones basadas en el contexto.

7. Pulse Siguiente para revisar la zona de red.

8. Pulse Crear.

Puede continuar creando más zonas de red o creando reglas.

Creación de zonas de red mediante la CLI

Al crear zonas de red, se establece una lista de ubicaciones permitidas en las que se origina una solicitud de acceso. Puede especificar un juego de una o varias ubicaciones de red por dirección IP como direcciones individuales, rangos o subredes, e ID de VPC. Después de crear una zona de red, puede añadirla a una regla.

1. Instale el complemento CLI de restricciones basadas en contexto ejecutando el siguiente comando :

   ibmcloud plugin install cbr
   

2. Para crear una zona de red, utilice el comando cbr zone-create.

   El siguiente ejemplo crea una zona de red con una lista de ubicaciones de red permitidas.

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

   El siguiente ejemplo crea una zona de red con una referencia de servicio. Para más información, consulte Referencias de servicio.

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

   Para encontrar una lista de referencias de servicio disponibles, ejecute el comando ibmcloud cbr service-ref-targets.

Creación de zonas de red mediante la API

Al crear zonas de red, se establece una lista de ubicaciones permitidas en las que se origina una solicitud de acceso. Un conjunto de una o más ubicaciones de red puede especificarse mediante direcciones IP como direcciones individuales, rangos o subredes, ID de VPC y referencias de servicio. Después de crear una zona de red, puede añadirla a una regla.

Para crear una zona de red, llame a la API de restricciones basadas en contexto como se muestra en el siguiente ejemplo:

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

Para encontrar una lista de referencias de servicio disponibles, llame al método ListAvailableServicerefTargets método.

Creación de zonas de red mediante Terraform

Al crear zonas de red, se establece una lista de ubicaciones permitidas en las que se origina una solicitud de acceso. Un conjunto de una o más ubicaciones de red puede especificarse mediante direcciones IP como direcciones individuales, rangos o subredes, ID de VPC y referencias de servicio. Después de crear una zona de red, puede añadirla a una regla.

Para crear una zona de red, utilice el recurso de Terraform cbr_zone.

1. Para instalar la CLI de Terraform y configurar el plug-in de proveedor de IBM Cloud para Terraform, siga la guía de aprendizaje Cómo empezar con Terraform en IBM Cloud®. El plug-in abstrae las API de IBM Cloud que se utilizan para completar esta tarea.

2. Cree un archivo de configuración de Terraform denominado main.tf. En este archivo, se añade la configuración para crear una zona de red utilizando HashiCorp Configuration Language. Para más información, consulte la documentación de Terraform.

   El siguiente ejemplo crea una zona de red que permite una única dirección IP y excluye explícitamente una dirección IP signle.

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

Como alternativa, también puede utilizar Terraform IBM Modules(TIM)for CBR Zone para crear una zona para restricciones basadas en contexto o actualizar direcciones en una zona existente. Más información sobre los módulos de Terraform IBM.

El siguiente ejemplo muestra cómo definir una zona de red utilizando el módulo:

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

Para ver la lista completa de entradas y ejemplos de uso, consulte el módulo Restricciones basadas en el contexto en GitHub.

Creación de reglas

Defina restricciones para sus recursos de nube creando reglas.

Para crear una regla, siga estos pasos.

1. En la consola de IBM Cloud, pulse Gestionar > Restricciones basadas en contexto y seleccione Reglas.

2. Pulse Crear.

3. Seleccione el servicio de destino en la regla. A continuación, pulse Siguiente.

   Al crear una restricción basada en el contexto para el servicio Grupos de acceso de IAM, los usuarios que no cumplan la regla no podrán ver ningún grupo de la cuenta, incluido el grupo de acceso público.

4. (Opcional) Seleccione el ámbito de las API cuyas operaciones están restringidas por su regla. Para más información, consulte Definición del ámbito de aplicación de una regla.

   No todos los servicios admiten la posibilidad de delimitar una regla por API.

5. Alcance la restricción a Todos los recursos o a Recursos específicos en función de los atributos seleccionados.

6. Pulse Revisar > Continuar.

7. Añade uno o varios contextos. Seleccione los tipos de punto final y las zonas de red y, a continuación, pulse Añadir.

   • Por defecto, se permite el acceso desde todos los tipos de terminales compatibles con el servicio cuando el conmutador está en No. Seleccione Sí para permitir sólo determinados tipos de terminales.

   Si desea permitir el acceso desde una VPC a puntos finales públicos en su regla, incluya cualquier dirección IP de puerta de enlace pública en la definición de zona junto con la VPC.

   • Puede añadir zonas de red existentes a la regla o crear nuevas zonas para añadirlas a la regla. Para más información, consulte Creación de zonas de red.

8. Pulse Continuar.

9. Proporcione una descripción única.

10. Seleccione cómo desea aplicar la regla. Puede decidir cómo desea aplicar una regla en el momento de su creación y actualizar la aplicación de la regla en cualquier momento.

    • Activar: Aplicar la regla. Los intentos de acceso denegados se notifican en Activity Tracker Event Routing.
    • Desactivar: No aplicar la regla. Las restricciones no se aplican a los recursos de su cuenta. Seleccione esta opción si no está preparado para activar la regla.
    • Sólo informe: Supervisa cómo afecta la regla a los usuarios sin aplicarla. Todos los intentos de acceder a los recursos de la cuenta se registran en Activity Tracker Event Routing. Se recomienda la supervisión durante 30 días antes de aplicar la regla.

11. Pulse Crear.

Creación de reglas mediante la CLI

Para definir restricciones a sus recursos en la nube mediante la creación de reglas, utilice el comando ibmcloud cbr rule-create. En el siguiente ejemplo se crea una regla dirigida a Kubernetes Service que sólo permite el acceso al servicio a los terminales privados de la zona de red especificada.

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

Para la opción enforcement-mode, la CLI acepta los valores enabled, disabled, y report. Si no se especifica ninguna aplicación, la regla se activa por defecto. Para más información, véase Aplicación de las normas.

Creación de reglas utilizando la API

Para crear restricciones a sus recursos en la nube mediante la creación de reglas, llame a la API de restricciones basadas en el contexto. El siguiente ejemplo crea una regla habilitada que se dirige a Kubernetes Service y permite que sólo las solicitudes de la zona de red especificada accedan al servicio.

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

Creación de reglas mediante Terraform

Para definir restricciones a tus recursos en la nube mediante la creación de reglas, utiliza el recurso de Terraform cbr_rule.

1. Para instalar la CLI de Terraform y configurar el plug-in de proveedor de IBM Cloud para Terraform, siga la guía de aprendizaje Cómo empezar con Terraform en IBM Cloud®. El plug-in abstrae las API de IBM Cloud que se utilizan para completar esta tarea.

2. Cree un archivo de configuración de Terraform denominado main.tf. En este archivo, se añade la configuración para crear una regla de restricciones basada en el contexto utilizando HashiCorp Configuration Language. Para más información, consulte la documentación de Terraform.

   El siguiente ejemplo crea una regla dirigida a una API específica de Kubernetes Service y sólo permite que los endpoints privados de la zona de red especificada llamen a las operaciones asociadas con esa 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"
           }
     }
   }