Gestión de las restricciones contextuales

Puedes gestionar las reglas contextuales en cualquier momento actualizando la descripción, que ayuda a identificar el propósito de la regla, o seleccionando una nueva lista de recursos y entornos de red. También puede eliminar las restricciones basadas en contextos para suprimir las restricciones definidas por los contextos de una regla.

Las restricciones basadas en el contexto pueden definir y aplicar restricciones de acceso para sus propios recursos IBM Cloud®. Puede definir estas restricciones en función de contextos, como zonas de red y tipos de terminales. Para obtener más información, consulte Qué son las restricciones basadas en el contexto.

El servicio de restricción basado en el contexto gestiona reglas y zonas de red, por lo que es posible perder toda la capacidad de gestionar estos recursos si no se puede satisfacer una regla en el servicio de restricción basado en el contexto. Los intentos de crear o actualizar una regla de este tipo sólo se permiten si el contexto de la solicitud satisface la regla nueva o modificada.

Si ya no puede satisfacer una regla que tiene como objetivo el servicio de restricciones basadas en contexto, abra un caso de soporte y proporcione un contexto que pueda satisfacer para restaurar su acceso.

Antes de empezar

Para gestionar restricciones contextuales, debe tener asignada la función de administrador en el servicio de gestión de cuentas.

Actualización de reglas mediante la consola

Para editar las restricciones contextuales de tus recursos en la nube, sigue estos pasos:

  1. En la consola de IBM Cloud, pulse Gestionar > Restricciones basadas en contexto y seleccione Reglas.
  2. Seleccione el icono Acciones Icono Acciones en la regla que desea actualizar y seleccione Editar.
  3. Para actualizar el alcance de las API cuyas operaciones están restringidas por su regla, seleccione Todas las API o API específicas. A continuación, pulse Aplicar o Continuar.
  4. Para actualizar el alcance de los recursos para la restricción, puede seleccionar Todos los recursos o Recursos específicos en función de los atributos disponibles, como el grupo de recursos o la ubicación. A continuación, pulse Aplicar o Continuar.
  5. Haga clic en el icono Editar en el panel de resumen para actualizar un contexto existente.
    1. Actualizar los tipos de extremos permitidos.
      • Establezca el conmutador en No para permitir todos los tipos de extremos admitidos por el servicio.
      • Seleccione Sí para permitir sólo determinados tipos de terminales.
    2. Actualizar las zonas de nuevo trabajo. Puede seleccionar nuevas zonas de red o deseleccionar zonas de red para eliminarlas.
  6. A continuación, haga clic en Aplicar.
  7. Haga clic en el icono Eliminar Eliminar icono del panel de resumen para eliminar un contexto.
  8. Configure un contexto nuevo seleccionando todos los puntos finales o un punto final específico y seleccionando las zonas de red. A continuación, pulse Añadir.
  9. Haga clic en Aplicar o Continuar.
  10. Proporcione una nueva descripción para su regla. Haga clic en Aplicar para actualizar la descripción o en Continuar.
  11. Para actualizar la aplicación de una regla, haga clic en el icono Editar . Puede Activar, Desactivar o establecer la regla como Sólo informe.
  12. Pulse Aplicar para finalizar.

Actualización de reglas mediante la CLI

Para actualizar las restricciones basadas en el contexto de sus recursos en la nube, utilice el comando ibmcloud cbr rule-update. El siguiente ejemplo actualiza la descripción, el tipo de endpoint permitido y la zona de red de una regla con el ID 30fd58c9b75f40e854b89c432318b4a2.

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

Actualización de reglas mediante la API

Para actualizar las restricciones de sus recursos en la nube mediante la creación de reglas, llame a la API de restricciones basadas en el contexto.

  1. Coge la regla que quieras sustituir. En el cuerpo de la respuesta, copie el ID de la regla y en las cabeceras de la respuesta copie la cabecera ETag.

    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. El siguiente ejemplo sustituye una regla por una versión actualizada. El valor ETag es necesario en la cabecera If-Match de la solicitud de sustitución.

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

Actualización de zonas de red mediante la consola

Puede modificar la lista de ubicaciones permitidas donde puede originarse una solicitud de acceso. Puede especificarse un conjunto de una o varias ubicaciones de red por direcciones IP (direcciones individuales, rangos o subredes), VPC o referencias de servicio. Puede actualizar una zona de red que se utiliza en una regla o integrar las nuevas zonas de red actualizadas en sus reglas más adelante.

  1. En la consola de IBM Cloud, pulse Gestionar > Restricciones basadas en contexto y seleccione Zonas de red.
  2. Seleccione el icono Acciones Icono Acciones en la zona de red que desee actualizar y seleccione Editar.
  3. Puede actualizar el nombre y la descripción de su zona.
  4. Puede editar la lista de direcciones IP permitidas donde puede originarse una solicitud de acceso. Incluya excepciones en la lista de denegación, si es necesario.
  5. Puede añadir o eliminar VPC permitidos.
  6. Puede añadir o eliminar referencias de servicio. Seleccione un servicio para asociar sus direcciones IP con su zona de red.
  7. Pulse Siguiente para revisar la nueva configuración.
  8. Para aplicar cambios, pulse Actualizar.

Actualización de zonas de red mediante la CLI

Para actualizar una zona de red, siga estos pasos.

  1. Recupere el ID de zona de la zona de red que desea actualizar utilizando el comando ibmcloud cbr zones para obtener una lista de todas las zonas de la cuenta. 
    ibmcloud cbr zones
  2. Actualice la zona de red mediante el comando ibmcloud cbr zone-update. El siguiente ejemplo actualiza el nombre de zona, las direcciones permitidas y las direcciones excluidas para una zona de red con el 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

Actualización de zonas de red mediante la API

Para actualizar una zona de red, siga estos pasos.

  1. Coge la zona que quieras sustituir. En el cuerpo de la respuesta, copia el ID de la zona y en las cabeceras de la respuesta copia la cabecera ETag.

    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. Actualice la zona de red utilizando el método Reemplazar zona. El valor ETag es necesario en la cabecera If-Match de la solicitud de sustitución.

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

Eliminar una regla mediante la consola

La supresión de reglas elimina las restricciones basadas en el contexto del recurso dado, y las solicitudes de cualquier contexto se permiten si el usuario tiene los permisos correctos. Siga estos pasos para eliminar una regla de los recursos de nube:

  1. En la consola de IBM Cloud, vaya a Gestionar > Restricciones basadas en contexto y seleccione Reglas.
  2. Pulse el icono Acciones Icono Acciones de la fila que contiene la regla y pulse Eliminar.

Eliminación de una regla mediante la CLI

Siga estos pasos para eliminar una regla de los recursos de nube:

  1. Recupere el ID de la regla que desea eliminar mediante el comando reglas de restricciones basadas en contexto. Puede limitar los resultados de la lista especificando atributos como opciones de comando.
    ibmcloud cbr rules --serviceName "iam-identity"
  2. Elimine la regla para el ID de regla especificado mediante el comando cbr rule-delete.
    ibmcloud cbr rule-delete 30fd58c9b75f40e854b89c432318b4a2

Eliminación de una regla mediante la API

Siga estos pasos para eliminar una regla de los recursos de nube:

  1. Recupere el ID de la regla que desea eliminar mediante el método context-based-restrictions list rules.
    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. Elimina la regla para el ID de regla especificado.
    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)
 }

Eliminación de una zona de red mediante la consola

La eliminación de una zona de red elimina el conjunto de ubicaciones de red permitidas desde las que se crea una solicitud de acceso. Si se añade una zona de red a una regla, primero debe eliminar la zona de la regla. Realice los siguientes pasos para eliminar una zona de red:

  1. En la consola IBM Cloud, vaya a Manage > Context-based restrictions, y seleccione Network zones.
  2. Pulse el icono Acciones Icono Acciones de la fila que contiene la zona de red y pulse Eliminar.

Eliminación de una zona de red mediante la CLI

La eliminación de una zona de red elimina el conjunto de ubicaciones de red permitidas desde las que se crea una solicitud de acceso. Si se añade una zona de red a una regla, primero debe eliminar la zona de la regla. Para obtener más información sobre la eliminación de una zona de una regla, consulte Actualización de las restricciones basadas en el contexto. A continuación, realice los pasos siguientes:

  1. Obtenga el ID de zona de la zona de red que desea eliminar mediante el comando contxt-based restrictions zones. Puede limitar los resultados de la lista especificando el nombre de la zona.
    ibmcloud cbr zones --name "Example zone"
  2. Elimine la zona de red para el ID de zona especificado utilizando el comando cbr zone-delete.
    ibmcloud cbr zone-delete 65810ac762004f22ac19f8f8edf70a34

Eliminación de una zona de red mediante la API

La eliminación de una zona de red elimina el conjunto de ubicaciones de red permitidas desde las que se crea una solicitud de acceso. Si se añade una zona de red a una regla, primero debe eliminar la zona de la regla. Consulte Actualización de restricciones basadas en contexto para obtener más información sobre cómo eliminar una zona de una regla. A continuación, realice los pasos siguientes:

  1. Recupere el ID de la regla que desea eliminar mediante el método Zonas de la lista de restricciones basadas en el contexto.
    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. Elimina la zona de red para el ID de zona especificado.
    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)
 }

Restringir la capacidad de gestionar reglas y zonas de red mediante la consola

Para configurar esta regla, diríjase al servicio Restricciones basadas en el contexto. Para obtener más información sobre los pasos para configurar una regla, consulte Creación de reglas. Una regla de ámbito Todos los recursos se aplica a todos los recursos actuales y futuros gestionados por el servicio. Si desea restringir las operaciones para un recurso específico, amplíe la regla a Recursos específicos > Tipo de recurso. Para completar cualquier regla u operación de gestión de zonas de red, un usuario debe tener asignado el rol correcto con una política de acceso IAM y debe satisfacer la regla de restricciones basadas en el contexto.

Restricción de la capacidad de gestionar reglas y zonas de red mediante la API

El siguiente ejemplo muestra una regla en formato JSON que protege las operaciones de gestión de reglas y zonas de red:

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

Una regla que especifica únicamente los atributos de recurso accountId y serviceName es aplicable a todos los recursos actuales y futuros gestionados por el servicio. Si desea restringir las operaciones para un recurso específico, incluya el atributo de recurso resourceType correspondiente. Los valores válidos de resourceType para el servicio de restricciones basadas en el contexto son rule y zone.

Para completar cualquier regla u operación de gestión de zonas de red, un usuario debe tener asignado el rol correcto con una política de acceso IAM y debe satisfacer la regla de restricciones basadas en el contexto.