Création de restrictions basées sur le contexte

Les restrictions basées sur le contexte vous permettent de gérer l'accès des utilisateurs et des services à des ressources de cloud spécifiques. Vous pouvez définir des restrictions sur les ressources qui sont basées sur des contextes, telles que des zones réseau et des types de noeud final. Pour plus d'informations, voir Que sont les restrictions basées sur le contexte ?.

Les restrictions d'adresse IP au niveau de l'utilisateur et du compte peuvent également affecter la capacité des utilisateurs à accéder aux ressources. Vous pouvez afficher les restrictions d'adresses IP au niveau du compte sur la page Paramètres. Pour visualiser les paramètres d'un utilisateur individuel, allez à la page Utilisateurs et affichez les restrictions d'adresse IP de chaque utilisateur dans l'onglet Détails.

Avant de commencer

  • Pour effectuer des actions de règles, vous devez disposer d'une politique Identity and Access Management (IAM) sur le service cible.
  • Pour effectuer des actions sur la zone réseau, vous devez disposer d'une politique IAM sur le service de restrictions contextuelles.

Pour plus d'informations, voir Restrictions basées sur le contexte - rôles et actions.

Création de zones réseau

En créant des zones de réseau, vous établissez une liste d'emplacements autorisés d'où provient une demande d'accès. Un ensemble d'un ou de plusieurs emplacements réseau peut être spécifié à l'aide d'adresses IP, de plages ou de sous-réseaux et d'ID de cloud privé virtuel. Après avoir créé une zone réseau, vous pouvez l'ajouter à une règle.

Pour créer une zone réseau, procédez comme suit.

  1. Dans la console IBM Cloud, cliquez sur Gérer > Restrictions basées sur le contexte, puis sélectionnez Zones réseau.

  2. Cliquez sur Créer.

    Au lieu de créer une zone en utilisant des entrées de l'interface utilisateur, vous pouvez utiliser le formulaire de code JSON pour entrer directement un code JSON permettant de créer une zone en cliquant sur Saisir au format JSON.

  3. Entrez un nom unique et une description.

  4. Entrez les adresses IP autorisées depuis lesquelles une demande d'accès peut provenir. Incluez les exceptions d'adresse IP dans la liste des adresses refusées, si nécessaire.

  5. Entrez les clouds privés virtuels autorisés.

    Si vous souhaitez autoriser l'accès aux points d'extrémité publics à partir du VPC dans votre règle, incluez toutes les adresses IP de la passerelle publique dans la définition de la zone, ainsi que le VPC.

  6. Référencez un service. Sélectionnez le type de service, puis sélectionnez un service. Cliquez sur Ajouter pour associer les adresses IP du service à votre zone réseau.

    Si vous n'êtes pas sûr du type de service, consultez le tableau Services intégrés avec des restrictions basées sur le contexte.

  7. Cliquez sur Suivant pour vérifier votre zone réseau.

  8. Cliquez sur Créer.

Vous pouvez continuer en créant d'autres zones réseau ou en créant des règles.

Création de zones réseau à l'aide de l'interface de ligne de commande

En créant des zones de réseau, vous établissez une liste d'emplacements autorisés d'où provient une demande d'accès. Un ensemble d'un ou de plusieurs emplacements réseau peut être spécifié à l'aide d'adresses IP, de plages ou de sous-réseaux et d'ID de cloud privé virtuel. Après avoir créé une zone réseau, vous pouvez l'ajouter à une règle.

  1. Installez le plug-in Context-based restrictions CLI en exécutant la commande suivante :

    ibmcloud plugin install cbr

  2. Pour créer une zone réseau, utilisez la commande cbr zone-create.

    L'exemple suivant crée une zone réseau avec une liste d'emplacements réseau autorisés.

    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'exemple suivant crée une zone de réseau avec une référence de service. Pour plus d'informations, voir Références des services.

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

    Pour obtenir une liste des références de service disponibles, exécutez la commande ibmcloud cbr service-ref-targets.

Création de zones de réseau à l'aide de l'API

En créant des zones de réseau, vous établissez une liste d'emplacements autorisés d'où provient une demande d'accès. Un ensemble d'un ou plusieurs emplacements de réseau peut être spécifié par des adresses IP telles que des adresses individuelles, des plages ou des sous-réseaux, des ID VPC et des références de service. Après avoir créé une zone réseau, vous pouvez l'ajouter à une règle.

Pour créer une zone réseau, appelez l'API Restrictions basées sur le contexte, comme indiqué dans l'exemple suivant :

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

Pour obtenir une liste des références de services disponibles, appelez la méthode ListAvailableServicerefTargets méthode.

Création de zones réseau à l'aide de Terraform

En créant des zones de réseau, vous établissez une liste d'emplacements autorisés d'où provient une demande d'accès. Un ensemble d'un ou plusieurs emplacements de réseau peut être spécifié par des adresses IP telles que des adresses individuelles, des plages ou des sous-réseaux, des ID VPC et des références de service. Après avoir créé une zone réseau, vous pouvez l'ajouter à une règle.

Pour créer une zone réseau, utilisez la ressource Terraform cbr_zone.

  1. Pour installer l'interface de ligne de commande de Terraform et configurer le plug-in IBM Cloud Provider pour Terraform, suivez le tutoriel d'initiation à Terraform sur IBM Cloud®. Ce plug-in résume les API IBM Cloud utilisées pour effectuer cette tâche.

  2. Créez un fichier de configuration Terraform nommé main.tf. Dans ce fichier, vous ajoutez la configuration pour créer une zone réseau en utilisant le langage de configuration HashiCorp. Pour plus d'informations, voir la documentation de Terraform.

    L'exemple suivant crée une zone réseau qui autorise une seule adresse IP et exclut explicitement une adresse IP unique.

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

Vous pouvez également utiliser Terraform IBM Modules(TIM)for CBR Zone pour créer une zone pour les restrictions basées sur le contexte ou mettre à jour les adresses dans une zone existante. Découvrez les modules Terraform IBM.

L'exemple suivant montre comment définir une zone réseau à l'aide du module :

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

Pour obtenir la liste complète des entrées et des exemples d'utilisation, voir le module Restrictions basées sur le contexte sur GitHub.

Création de règles

Définissez les restrictions applicables à vos ressources de cloud en créant des règles.

Pour créer une règle, 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. Cliquez sur Créer.

  3. Sélectionnez le service que vous souhaitez cibler dans votre règle. Ensuite, cliquez sur Suivant.

    Lorsque vous créez une restriction basée sur le contexte pour le service IAM Access Groups, les utilisateurs qui ne satisfont pas à la règle ne peuvent pas voir les groupes du compte, y compris le groupe d'accès public.

  4. (Facultatif) Sélectionnez l'étendue des API dont les opérations sont restreintes par votre règle. Pour plus d'informations, voir Définir la portée d'une règle.

    Tous les services ne permettent pas de définir l'étendue d'une règle par API.

  5. Étendre la restriction à toutes les ressources ou à des ressources spécifiques en fonction des attributs sélectionnés.

  6. Cliquez sur Réviser > Continuer.

  7. Ajouter un ou plusieurs contextes. Sélectionnez des types de noeud final et des zones réseau, puis cliquez sur Ajouter.

    • Par défaut, l'accès est autorisé à partir de tous les types de terminaux pris en charge par le service lorsque la bascule est réglée sur Non. Réglez la bascule sur Oui pour n'autoriser que certains types de points d'extrémité.

    Si vous souhaitez autoriser l'accès aux points d'extrémité publics à partir d'un VPC dans votre règle, incluez toutes les adresses IP de la passerelle publique dans la définition de la zone, ainsi que le VPC.

    • Vous pouvez ajouter des zones réseau existantes à votre règle ou créer de nouvelles zones à ajouter à votre règle. Pour plus d'informations, voir Création de zones réseau.

  8. Cliquez sur Continu.

  9. Fournir une description unique.

  10. Sélectionnez la manière dont vous souhaitez appliquer la règle. Vous pouvez décider de la manière dont vous souhaitez appliquer une règle lors de sa création et mettre à jour l'application de la règle à tout moment.

    • Activer: Appliquer la règle. Les tentatives d'accès refusées sont signalées à l'adresse Activity Tracker Event Routing.
    • Désactiver: Ne pas appliquer la règle. Les restrictions ne s'appliquent pas à vos ressources de compte. Sélectionnez cette option si vous n'êtes pas prêt à activer la règle.
    • Rapport uniquement: Contrôle l'impact de la règle sur les utilisateurs sans l'appliquer. Toutes les tentatives d'accès aux ressources du compte sont enregistrées sur Activity Tracker Event Routing. La surveillance est recommandée pendant 30 jours avant d'appliquer la règle.

  11. Cliquez sur Créer.

Création de règles à l'aide de l'interface de programmation

Pour définir des restrictions à vos ressources cloud en créant des règles, utilisez la commande ibmcloud cbr rule-create. L'exemple suivant crée une règle qui cible le site Kubernetes Service et autorise uniquement les terminaux privés de la zone réseau spécifiée à accéder au service.

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

Pour l'option enforcement-mode, le CLI accepte les valeurs enabled, disabled, et report. Si aucune application n'est spécifiée, la règle est activée par défaut. Pour plus d'informations, voir Application des règles.

Création de règles en utilisant l'API

Pour créer des restrictions à vos ressources en nuage en créant des règles, appelez l'API "Restrictions basées sur le contexte". L'exemple suivant crée une règle activée qui cible le site Kubernetes Service et autorise uniquement les requêtes provenant de la zone réseau spécifiée à accéder au service.

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

Créer des règles à l'aide de Terraform

Pour définir des restrictions à vos ressources cloud en créant des règles, utilisez la ressource Terraform cbr_rule.

  1. Pour installer l'interface de ligne de commande de Terraform et configurer le plug-in IBM Cloud Provider pour Terraform, suivez le tutoriel d'initiation à Terraform sur IBM Cloud®. Ce plug-in résume les API IBM Cloud utilisées pour effectuer cette tâche.

  2. Créez un fichier de configuration Terraform nommé main.tf. Dans ce fichier, vous ajoutez la configuration pour créer une règle de restriction basée sur le contexte en utilisant le langage de configuration HashiCorp. Pour plus d'informations, voir la documentation de Terraform.

    L'exemple suivant crée une règle qui cible une API Kubernetes Service spécifique et autorise uniquement les terminaux privés de la zone réseau spécifiée à appeler les opérations associées à cette 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"
        }
  }
}