Criando zonas de rede

Ao criar zonas de rede, você estabelece uma lista de locais permitidos onde se origina uma solicitação de acesso. Um conjunto de um ou mais locais de rede pode ser especificado por endereços IP, como endereços individuais, intervalos ou sub-redes e IDs de VPC. Depois de criar uma zona de rede, é possível incluí-la em uma regra.

Para criar uma zona de rede, conclua as etapas a seguir.

1. No console do IBM Cloud, clique em Gerenciar > Restrições baseadas em contexto e selecione Zonas de rede.

2. Clique em Criar.

   Em vez de criar uma zona usando entradas de IU, é possível usar o formulário de código JSON para inserir o JSON diretamente para criar uma zona clicando em Inserir como código JSON.

3. Insira um nome exclusivo e uma descrição.

4. Insira os endereços IP permitidos onde uma solicitação de acesso pode ser originada. Inclua exceções de endereço IP na lista de negação, se necessário.

5. Insira os VPCs permitidos.

   Se você quiser permitir o acesso da VPC a pontos de extremidade públicos em sua regra, inclua qualquer endereço IP de gateway público na definição da zona junto com a VPC.

6. Faça referência a um serviço. Selecione o tipo de serviço e, em seguida, selecione um serviço. Clique em Add (Adicionar ) para associar os endereços IP do serviço à sua zona de rede.

   Se não tiver certeza de qual é o tipo de serviço, consulte a tabela Serviços integrados com restrições baseadas em contexto.

7. Clique em Avançar para revisar sua zona de rede.

8. Clique em Criar.

É possível continuar criando mais zonas de rede, ou criando regras.

Criação de zonas de rede usando a CLI

Ao criar zonas de rede, você estabelece uma lista de locais permitidos onde se origina uma solicitação de acesso. Um conjunto de um ou mais locais de rede pode ser especificado por endereços IP, como endereços individuais, intervalos ou sub-redes e IDs de VPC. Depois de criar uma zona de rede, é possível incluí-la em uma regra.

1. Instale o plug-in CLI de restrições baseadas em contexto executando o seguinte comando:

   ibmcloud plugin install cbr
   

2. Para criar uma zona de rede, use o comando cbr zone-create.

   O exemplo a seguir cria uma zona de rede com uma lista de locais de rede permitidos.

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

   O exemplo a seguir cria uma zona de rede com uma referência de serviço. Para obter mais informações, consulte Referências de serviço.

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

   Para encontrar uma lista de referências de serviço disponíveis, execute o comando ibmcloud cbr service-ref-targets.

Criação de zonas de rede usando a API

Ao criar zonas de rede, você estabelece uma lista de locais permitidos onde se origina uma solicitação de acesso. Um conjunto de um ou mais locais de rede pode ser especificado por endereços IP, como endereços individuais, intervalos ou sub-redes, IDs de VPC e referências de serviço. Depois de criar uma zona de rede, é possível incluí-la em uma regra.

Para criar uma zona de rede, chame a API de restrições baseadas em contexto, conforme mostrado no exemplo a seguir:

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 uma lista de referências de serviço disponíveis, chame o método ListAvailableServicerefTargets método.

Criação de zonas de rede usando o Terraform

Ao criar zonas de rede, você estabelece uma lista de locais permitidos onde se origina uma solicitação de acesso. Um conjunto de um ou mais locais de rede pode ser especificado por endereços IP, como endereços individuais, intervalos ou sub-redes, IDs de VPC e referências de serviço. Depois de criar uma zona de rede, é possível incluí-la em uma regra.

Para criar uma zona de rede, use o recurso cbr_zone do Terraform.

1. Para instalar a CLI do Terraform e configurar o plug-in do IBM Cloud Provider para o Terraform, siga o tutorial de Introdução ao Terraform no IBM Cloud®. O plug-in abstrai as APIs do IBM Cloud que são usadas para concluir esta tarefa.

2. Crie um arquivo de configuração do Terraform que seja denominado main.tf. Nesse arquivo, você adiciona a configuração para criar uma zona de rede usando a HashiCorp Configuration Language. Para obter mais informações, consulte a documentação do Terraform.

   O exemplo a seguir cria uma zona de rede que permite um único endereço IP e exclui explicitamente um único endereço IP.

   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, você também pode usar o Terraform IBM Modules(TIM)for CBR Zone para criar uma zona para restrições baseadas em contexto ou atualizar endereços em uma zona existente. Saiba mais sobre o Terraform IBM Modules.

O exemplo a seguir mostra como definir uma zona de rede usando o 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 obter a lista completa de entradas e exemplos de uso, consulte o módulo Context-Based Restrictions(Restrições baseadas em contexto ) em GitHub.

Criando regras

Defina restrições para seus recursos em nuvem criando regras.

Para criar uma regra, conclua as etapas a seguir.

1. No console do IBM Cloud, clique em Gerenciar > Restrições baseadas em contexto e selecione Regras.

2. Clique em Criar.

3. Selecione o serviço que deseja destinar em sua regra. Em seguida, clique em Avançar.

   Quando você cria uma restrição baseada em contexto para o serviço IAM Access Groups, os usuários que não satisfazem a regra não podem visualizar nenhum grupo na conta, inclusive o grupo de acesso público.

4. (Opcional) Selecione o escopo das APIs cujas operações são restritas por sua regra. Para obter mais informações, consulte Definição do escopo de uma regra.

   Nem todos os serviços oferecem suporte à capacidade de escopo de uma regra por API.

5. Escopo da restrição para Todos os recursos ou Recursos específicos com base nos atributos selecionados.

6. Clique em Revisão > Continuar.

7. Adicione um ou mais contextos. Selecione tipos de endpoints e zonas de rede e clique em Incluir.

   • Por padrão, o acesso é permitido a partir de todos os tipos de terminais compatíveis com o serviço quando a alternância é definida como No (Não). Defina a alternância como Yes para permitir apenas tipos específicos de pontos de extremidade.

   Se você quiser permitir o acesso de uma VPC a pontos de extremidade públicos em sua regra, inclua qualquer endereço IP de gateway público na definição da zona junto com a VPC.

   • É possível incluir zonas de rede existentes em sua regra ou criar novas zonas para incluir em sua regra. Para obter mais informações, consulte Criação de zonas de rede.

8. Clique em Continuar.

9. Forneça uma descrição exclusiva.

10. Selecione como você deseja aplicar a regra. Você pode decidir como deseja aplicar uma regra na criação e atualizar a aplicação da regra a qualquer momento.

    • Habilitar: Aplicar a regra. As tentativas de acesso negadas são relatadas em Activity Tracker Event Routing.
    • Desativar: Não aplique a regra. As restrições não se aplicam aos recursos de sua conta. Selecione essa opção se você não estiver pronto para ativar a regra.
    • Somente relatório: Monitora como a regra afeta os usuários sem aplicá-la. Todas as tentativas de acesso aos recursos da conta são registradas em Activity Tracker Event Routing. O monitoramento é recomendado por 30 dias antes da aplicação da regra.

11. Clique em Criar.

Criação de regras usando a CLI

Para definir restrições aos seus recursos de nuvem por meio da criação de regras, use o comando ibmcloud cbr rule-create. O exemplo a seguir cria uma regra que tem como alvo o site Kubernetes Service e permite que apenas endpoints privados da zona de rede especificada acessem o serviço.

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

Para a opção enforcement-mode, a CLI aceita os valores enabled, disabled e report. Se nenhuma imposição for especificada, a regra será ativada por padrão. Para obter mais informações, consulte Aplicação de regras.

Criando regras usando a API

Para criar restrições aos seus recursos de nuvem por meio da criação de regras, chame a API de restrições baseadas em contexto. O exemplo a seguir cria uma regra habilitada que tem como alvo o site Kubernetes Service e permite que apenas solicitações da zona de rede especificada acessem o serviço.

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

Criação de regras usando o Terraform

Para definir restrições aos seus recursos de nuvem por meio da criação de regras, use o recurso cbr_rule do Terraform.

1. Para instalar a CLI do Terraform e configurar o plug-in do IBM Cloud Provider para o Terraform, siga o tutorial de Introdução ao Terraform no IBM Cloud®. O plug-in abstrai as APIs do IBM Cloud que são usadas para concluir esta tarefa.

2. Crie um arquivo de configuração do Terraform que seja denominado main.tf. Nesse arquivo, você adiciona a configuração para criar uma regra de restrições baseada em contexto usando a HashiCorp Configuration Language. Para obter mais informações, consulte a documentação do Terraform.

   O exemplo a seguir cria uma regra que visa a uma API Kubernetes Service específica e permite que somente endpoints privados da zona de rede especificada chamem as operações associadas a essa 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"
           }
     }
   }