Gestion des restrictions contextuelles

Vous pouvez gérer les règles contextuelles à tout moment en mettant à jour la description, qui permet d'identifier l'objectif de la règle, ou en sélectionnant une nouvelle liste de ressources et d'environnements réseau. Vous pouvez également supprimer les restrictions basées sur le contexte pour supprimer les restrictions définies par les contextes d'une règle.

Les restrictions basées sur le contexte peuvent définir et appliquer des restrictions d'accès à ses propres ressources IBM Cloud®. Vous pouvez définir ces restrictions en fonction des contextes, tels que les zones de réseau et les types de terminaux. Pour plus d'informations, voir Que sont les restrictions basées sur le contexte ?.

Le service de restriction contextuelle gère les règles et les zones du réseau. Il est donc possible de perdre toute capacité à gérer ces ressources si vous ne pouvez pas satisfaire une règle du service de restriction contextuelle. Les tentatives de création ou de mise à jour d'une telle règle ne sont autorisées que si le contexte de la demande satisfait à la règle nouvelle ou modifiée.

Si vous ne pouvez plus satisfaire à une règle ciblant le service de restrictions basées sur le contexte, ouvrez un dossier d'assistance et fournissez un contexte que vous pouvez satisfaire pour rétablir votre accès.

Avant de commencer

Pour gérer les restrictions contextuelles, vous devez avoir le rôle d'administrateur dans le service de gestion des comptes.

Mise à jour des règles à l'aide de la console

Pour modifier les restrictions contextuelles de vos ressources en nuage, procédez comme suit :

  1. Dans la console IBM Cloud, cliquez sur Gérer > Restrictions basées sur le contexte, puis sélectionnez Règles.
  2. Sélectionnez l'icône Actions Actions sur la règle que vous souhaitez mettre à jour, puis sélectionnez Modifier.
  3. Pour mettre à jour l'étendue des API dont les opérations sont restreintes par votre règle, sélectionnez All APIs ou Specific APIs. Ensuite, cliquez sur Appliquer ou Continuer.
  4. Pour mettre à jour l'étendue des ressources pour la restriction, vous pouvez sélectionner Toutes les ressources ou Ressources spécifiques en fonction des attributs disponibles, tels que le groupe de ressources ou l'emplacement. Ensuite, cliquez sur Appliquer ou Continuer.
  5. Cliquez sur l'icône Editer Icône d'édition dans le panneau de synthèse pour mettre à jour un contexte existant.
    1. Mettre à jour les types de terminaux autorisés.
      • Mettez l'interrupteur sur Non pour autoriser tous les types de terminaux pris en charge par le service.
      • Réglez la bascule sur Oui pour n'autoriser que certains types de points d'extrémité.
    2. Mettre à jour les zones de travail. Vous pouvez sélectionner de nouvelles zones de réseau ou désélectionner des zones de réseau pour les supprimer.
  6. Cliquez ensuite sur Appliquer.
  7. Cliquez sur l'icône Retirer Supprimer l'icône dans le panneau de synthèse pour supprimer un contexte.
  8. Configurez un nouveau contexte en sélectionnant tous les noeuds finaux ou un noeud final spécifique et en sélectionnant vos zones réseau. Cliquez ensuite sur Ajouter.
  9. Cliquez sur Appliquer ou Continuer.
  10. Indiquez une nouvelle description pour la règle. Cliquez sur Appliquer pour mettre à jour la description ou cliquez sur Continuer.
  11. Pour mettre à jour l'application d'une règle, cliquez sur l'icône Editer Icône d'édition. Vous pouvez activer, désactiver ou définir la règle sur Rapport uniquement.
  12. Cliquez sur Appliquer pour terminer.

Mise à jour des règles à l'aide de la CLI

Pour mettre à jour les restrictions contextuelles sur vos ressources cloud, utilisez la commande ibmcloud cbr rule-update. L'exemple suivant met à jour la description, le type de terminal autorisé et la zone réseau d'une règle portant l'ID 30fd58c9b75f40e854b89c432318b4a2.

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

Mise à jour des règles à l'aide de l'API

Pour mettre à jour les restrictions applicables à vos ressources en nuage en créant des règles, appelez l'API "Restrictions basées sur le contexte".

  1. Obtenez la règle que vous souhaitez remplacer. Dans le corps de la réponse, copiez l'ID de la règle et dans les en-têtes de la réponse, copiez l'en-tête 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. L'exemple suivant remplace une règle par une version mise à jour. La valeur ETag est requise dans l'en-tête If-Match de la demande de remplacement.

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

Mise à jour des zones du réseau à l'aide de la console

Vous pouvez modifier la liste des emplacements autorisés depuis lesquels une demande d'accès peut provenir. Un ensemble d'un ou de plusieurs emplacements réseau peut être spécifié à l'aide d'adresses IP (adresses individuelles, plages ou sous-réseaux), de clouds privés virtuels ou de références de service. Vous pouvez mettre à jour une zone réseau qui est utilisée dans une règle ou intégrer les nouvelles zones réseau mises à jour dans vos règles ultérieurement.

  1. Dans la console IBM Cloud, cliquez sur Gérer > Restrictions basées sur le contexte, puis sélectionnez Zones réseau.
  2. Sélectionnez l'icône Actions Actions sur la zone réseau que vous souhaitez mettre à jour, puis sélectionnez Modifier.
  3. Vous pouvez mettre à jour le nom et la description de votre zone.
  4. Vous pouvez éditer la liste des adresses IP autorisées depuis lesquelles une demande d'accès peut provenir. Incluez les exceptions dans la liste des adresses refusées, si nécessaire.
  5. Vous pouvez ajouter ou retirer des clouds privés virtuels autorisés.
  6. Vous pouvez ajouter ou retirer des références de service. Sélectionnez un service pour associer ses adresses IP à votre zone réseau.
  7. Cliquez sur Suivant pour vérifier votre nouvelle configuration.
  8. Pour appliquer les modifications, cliquez sur Mettre à jour.

Mise à jour des zones réseau à l'aide de la CLI

Pour mettre à jour une zone réseau, procédez comme suit.

  1. Récupérez l'ID de la zone réseau que vous souhaitez mettre à jour en utilisant la commande ibmcloud cbr zones pour répertorier toutes les zones du compte. 
    ibmcloud cbr zones
  2. Mettez à jour la zone réseau en utilisant la commande ibmcloud cbr zone-update. L'exemple suivant met à jour le nom de la zone, les adresses autorisées et les adresses exclues pour une zone réseau avec l'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

Mise à jour des zones du réseau à l'aide de l'API

Pour mettre à jour une zone réseau, procédez comme suit.

  1. Prenez la zone que vous souhaitez remplacer. Dans le corps de la réponse, copiez l'ID de la zone et dans les en-têtes de la réponse, copiez l'en-tête 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. Mettez à jour la zone réseau à l'aide de la méthode Remplacer la zone. La valeur ETag est requise dans l'en-tête If-Match de la demande de remplacement.

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

Suppression d'une règle à l'aide de la console

La suppression de règles retire des restrictions basées sur le contexte de la ressource indiquée, et les demandes de tous les contextes sont autorisées si l'utilisateur dispose des droits appropriés. Vous pouvez retirer une règle de vos ressources de cloud en procédant comme suit :

  1. Dans la console IBM Cloud, accédez à Gérer > Restrictions basées sur le contexte, puis sélectionnez Règles.
  2. Cliquez sur l'icône Actions Icône Actions dans la ligne contenant la règle, puis sur Supprimer.

Suppression d'une règle à l'aide de l'interface de ligne de commande

Vous pouvez retirer une règle de vos ressources de cloud en procédant comme suit :

  1. Récupérez l'ID de la règle que vous souhaitez supprimer à l'aide de la commande context-based restrictions rules(règles de restriction basées sur le contexte). Vous pouvez limiter les résultats de la liste en spécifiant des attributs en tant qu'options de commande.
    ibmcloud cbr rules --serviceName "iam-identity"
  2. Supprimez la règle pour l'ID de règle spécifié à l'aide de la commande cbr rule-delete.
    ibmcloud cbr rule-delete 30fd58c9b75f40e854b89c432318b4a2

Suppression d'une règle à l'aide de l'API

Vous pouvez retirer une règle de vos ressources de cloud en procédant comme suit :

  1. Récupérez l'ID de la règle que vous souhaitez supprimer à l'aide de la méthode 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. Supprime la règle correspondant à l'ID de règle spécifié.
    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)
 }

Suppression d'une zone réseau à l'aide de la console

Le retrait d'une zone réseau retire l'ensemble des emplacements réseau autorisés à partir desquels une demande d'accès peut être créée. Si une zone réseau est ajoutée à une règle, vous devez d'abord retirer la zone de la règle. Procédez comme suit pour supprimer une zone réseau :

  1. Dans la console IBM Cloud, allez à Gérer > Restrictions basées sur le contexte, et sélectionnez Zones de réseau.
  2. Cliquez sur l'icône Actions Icône Actions dans la ligne contenant la zone réseau, puis sur Supprimer.

Suppression d'une zone réseau à l'aide de la CLI

Le retrait d'une zone réseau retire l'ensemble des emplacements réseau autorisés à partir desquels une demande d'accès peut être créée. Si une zone réseau est ajoutée à une règle, vous devez d'abord retirer la zone de la règle. Pour plus d'informations sur la suppression d'une zone d'une règle, voir Mise à jour des restrictions basées sur le contexte. Ensuite, procédez comme suit :

  1. Récupérez l'ID de la zone réseau que vous souhaitez supprimer à l'aide de la commande contxt-based restrictions zones. Vous pouvez restreindre les résultats de la liste en spécifiant le nom de la zone.
    ibmcloud cbr zones --name "Example zone"
  2. Supprimez la zone réseau pour l'ID de zone spécifié à l'aide de la commande cbr zone-delete.
    ibmcloud cbr zone-delete 65810ac762004f22ac19f8f8edf70a34

Suppression d'une zone réseau à l'aide de l'API

Le retrait d'une zone réseau retire l'ensemble des emplacements réseau autorisés à partir desquels une demande d'accès peut être créée. Si une zone réseau est ajoutée à une règle, vous devez d'abord retirer la zone de la règle. Voir Mise à jour des restrictions basées sur le contexte pour plus d'informations sur le retrait d'une zone depuis une règle. Ensuite, procédez comme suit :

  1. Récupérez l'ID de la règle que vous souhaitez supprimer à l'aide de la méthode Zones de la liste des restrictions basées sur le contexte.
    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. Supprime la zone réseau pour l'ID de zone spécifié.
    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)
 }

Restreindre la possibilité de gérer les règles et les zones du réseau à l'aide de la console

Pour configurer cette règle, ciblez le service Restrictions basées sur le contexte. Pour plus d'informations sur les étapes de configuration d'une règle, voir Création de règles. Une règle portant sur toutes les ressources s'applique à toutes les ressources actuelles et futures gérées par le service. Si vous souhaitez restreindre les opérations pour une ressource spécifique, étendez la règle à Ressources spécifiques > Type de ressource. Pour mener à bien une règle ou une opération de gestion de zone réseau, un utilisateur doit se voir attribuer le rôle adéquat dans le cadre d'une politique d'accès IAM et satisfaire à la règle de restriction contextuelle.

Restreindre la possibilité de gérer des règles et des zones de réseau à l'aide de l'API

L'exemple suivant montre une règle au format JSON qui protège les opérations de gestion des règles et des zones de réseau :

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

Une règle qui ne spécifie que les attributs des ressources accountId et serviceName s'applique à toutes les ressources actuelles et futures gérées par le service. Si vous souhaitez restreindre les opérations pour une ressource spécifique, incluez l'attribut de ressource resourceType correspondant. Les valeurs valides de resourceType pour le service de restrictions basées sur le contexte sont rule et zone.

Pour mener à bien une règle ou une opération de gestion de zone réseau, un utilisateur doit se voir attribuer le rôle adéquat dans le cadre d'une politique d'accès IAM et satisfaire à la règle de restriction contextuelle.