Ativando a Compatibilidade com FIPS

Mantenha a conformidade com FIPS ao usar o provedor Terraform do Oracle Cloud Infrastructure.

Você poderá usar o Terraform e uma versão especial compatível com FIPS do provedor Terraform do Oracle Cloud Infrastructure (OCI), desde que alguns requisitos específicos e melhores práticas sejam empregados. Este tópico fornece orientações sobre esses requisitos e práticas.

Criptografia FIPS

Para garantir os mais altos padrões de segurança, o tráfego do Terraform para os pontos finais do OCI deve transitar por uma conexão TLS estabelecida com um cliente HTTP usando criptografia certificada pelo FIPS.

O provedor Terraform do OCI padrão é implementado no Go. As implementações de criptografia nativa do Go, embora totalmente capazes de estabelecer conexões TLS seguras com pontos finais do OCI, não foram certificadas pelo FIPS.

Para que o tráfego do Terraform transite para os pontos finais do OCI em conexões compatíveis com FIPS, use uma versão especial do provedor Terraform que utilize a criptografia certificada pelo FIPS. Essa versão do provedor Terraform do OCI usa o Oracle Cloud Infrastructure certificado pelo FIPS 140-2 para BoringCrypto em vez da implementação da criptografia nativa do Go. Leia mais sobre o Oracle Cloud Infrastructure para BoringCrypto aqui.

Instalando o Provedor Terraform Compatível com FIPS

O provedor Terraform do OCI compatível com FIPS só está disponível para o Oracle Linux. Você pode instalar o provedor usando o yum.

Dica

Antes de instalar o provedor Terraform do OCI, faça download e instale o Terraform pelo HashiCorp ou instale o Terraform usando o yum.

Se algum pacote do provedor Terraform do OCI já estiver instalado na máquina do Oracle Linux, remova-o primeiro:

yum remove terraform-provider-oci

Instale o provedor Terraform do OCI compatível com FIPS executando o seguinte comando do yum em uma máquina do Oracle Linux:

yum install terraform-provider-oci-fips

Configurando o Provedor Terraform

Adicione uma variável de ambiente para definir a região de destino do Terraform:
```
echo "export TF_VAR_region='<your_region>'" >> ${HOME}/.bash_profile
```
Adicione uma variável de ambiente para desativar a criptografia de tráfego interprocesso entre o Terraform e o provedor Terraform do OCI:
```
echo "export TF_DISABLE_PLUGIN_TLS=1" >> ${HOME}/.bash_profile
```
Adicione uma variável de ambiente para impedir que o Terraform acesse o serviço HashiCorp Checkpoint:
```
echo "export CHECKPOINT_DISABLE=1" >> ${HOME}/.bash_profile
```
Configure o método de autenticação para o provedor Terraform. Consulte Autenticação para obter mais informações.

Operando o Terraform em uma Única Região

Para garantir que o tráfego entre os serviços do Terraform e do OCI não transite pela infraestrutura de internet pública, recomendamos que você execute o Terraform e o provedor Terraform do OCI em uma instância do serviço Compute hospedada na mesma região dos recursos que eles criam e gerenciam.

Criando uma Instância do Compute

Depois que o Terraform e o provedor Terraform do OCI estiverem instalados em uma máquina do Oracle Linux, você poderá usar o Terraform e o seguinte arquivo de configuração de amostra do Terraform para:

Crie uma instância de computação designada que você possa usar para provisionar infraestrutura adicional na mesma região.
Instale na nova instância o Terraform e o provedor Terraform do OCI compatível com FIPS mais recente.
Restrinja a comunicação com a instância aos pontos finais do OCI e HTTPS usando um gateway de serviço.
Ative a autenticação do controlador de instâncias.

Consulte Criando Configurações para obter mais informações.

Para criar a instância de computação:

Copie o arquivo main.tf para a máquina do Oracle Linux.
Colete as informações necessárias para preencher as variáveis do arquivo de configuração do Terraform.
Consulte Imagens da Plataforma para localizar o valor do OCID da imagem do Oracle Linux da sua região. Modifique o valor oel-image no arquivo de configuração do Terraform.
Inicialize o Terraform no diretório que contém o arquivo de configuração do Terraform:
```
terraform init
```
Aplique a configuração do Terraform:
```
terraform plan
```
```
terraform apply
```

Importante

A variável de saída instance-ip fornece o endereço IP que você precisará usar para acessar a nova instância de computação.

main.tf

variable "tenancy_ocid" {
}
 
variable "user_ocid" {
}
 
variable "fingerprint" {
}
 
variable "private_key_path" {
}
 
variable "region" {
}
 
variable "compartment_ocid" {
}
 
variable "ssh_public_key" {
}
 
variable "ssh_private_key" {
}
 
locals {
  prefix    = "terraform"
  oel-image = "<Oracle_Linux_image_OCID>"
  vm-shape  = "<shape_name>"
 
  user-data = <<EOF
#!/bin/bash -x
echo "export TF_VAR_auth='InstancePrincipal'" >> ~/.bash_profile
echo "export TF_VAR_region='${var.region}'" >> ~/.bash_profile
yum install -y terraform terraform-provider-oci-fips
EOF
 
}
 
provider "oci" {
  tenancy_ocid     = var.tenancy_ocid
  user_ocid        = var.user_ocid
  fingerprint      = var.fingerprint
  private_key_path = var.private_key_path
  region           = var.region
}
 
resource "oci_core_vcn" "vcn1" {
  compartment_id = var.compartment_ocid
  display_name   = "${local.prefix}Vcn"
  cidr_block     = "10.0.0.0/16"
}
 
resource "oci_core_subnet" "subnet1" {
  compartment_id    = var.compartment_ocid
  vcn_id            = oci_core_vcn.vcn1.id
  cidr_block        = "10.0.0.0/24"
  display_name      = "${local.prefix}Subnet"
  security_list_ids = [oci_core_vcn.vcn1.default_security_list_id]
  route_table_id    = oci_core_vcn.vcn1.default_route_table_id
  dhcp_options_id   = oci_core_vcn.vcn1.default_dhcp_options_id
}
 
resource "oci_core_internet_gateway" "internet-gateway1" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.vcn1.id
  display_name   = "${local.prefix}InternetGateway"
}
 
resource "oci_core_default_route_table" "route-table1" {
  manage_default_resource_id = oci_core_vcn.vcn1.default_route_table_id
  display_name               = "${local.prefix}RouteTable"
 
  route_rules {
    destination       = "0.0.0.0/0"
    destination_type  = "CIDR_BLOCK"
    network_entity_id = oci_core_internet_gateway.internet-gateway1.id
  }
}
 
data "oci_core_services" "service-gateway-services" {
  filter {
    name   = "name"
    values = ["All .* Services In Oracle Services Network"]
    regex  = true
  }
}
 
resource "oci_core_service_gateway" "service-gateway1" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.vcn1.id
  display_name   = "${local.prefix}ServiceGateway"
 
  services {
    service_id = data.oci_core_services.service-gateway-services.services[0]["id"]
  }
}
 
resource "oci_core_default_security_list" "security-list1" {
  manage_default_resource_id = oci_core_vcn.vcn1.default_security_list_id
  display_name               = "${local.prefix}SecurityList"
 
  // inbound ssh traffic
  ingress_security_rules {
    protocol  = "6" // tcp
    source    = "0.0.0.0/0"
    stateless = false
 
    tcp_options {
      min = 22
      max = 22
    }
  }
 
  // outbound traffic to OCI services
  egress_security_rules {
    destination      = data.oci_core_services.service-gateway-services.services[0]["cidr_block"]
    destination_type = "SERVICE_CIDR_BLOCK"
    protocol         = "6"
 
    tcp_options {
      max = "443"
      min = "443"
    }
  }
 
  // outbound tcp traffic on all ports
  egress_security_rules {
    destination = "0.0.0.0/0"
    protocol    = "6"
  }
}
 
data "oci_identity_compartment" "compartment1" {
  id = var.compartment_ocid
}
 
resource "oci_identity_dynamic_group" "dynamic-group1" {
  compartment_id = var.tenancy_ocid
  name           = "${local.prefix}DynamicGroup"
  description    = "Dynamic Group for executing Terraform with Instance Principal authentication"
  matching_rule  = "ANY {instance.compartment.id = '${var.compartment_ocid}'}"
}
 
resource "oci_identity_policy" "instance-principal-policy1" {
  compartment_id = var.compartment_ocid
  name           = "${local.prefix}Policy"
  description    = "Policy to allow Instance Principal Terraform execution"
  statements     = ["ALLOW dynamic-group ${oci_identity_dynamic_group.dynamic-group1.name} to manage all-resources IN compartment ${data.oci_identity_compartment.compartment1.name}"]
}
 
data "oci_identity_availability_domain" "ad" {
  compartment_id = var.tenancy_ocid
  ad_number      = 1
}
 
resource "oci_core_instance" "instance1" {
  availability_domain = data.oci_identity_availability_domain.ad.name
  compartment_id      = var.compartment_ocid
  display_name        = "${local.prefix}Instance"
  shape               = local.vm-shape
 
  source_details {
    source_type = "image"
    source_id   = local.oel-image
  }
 
  metadata = {
    ssh_authorized_keys = var.ssh_public_key
    user_data           = base64encode(local.user-data)
    tenancy_ocid        = var.tenancy_ocid
  }
 
  create_vnic_details {
    subnet_id        = oci_core_subnet.subnet1.id
    assign_public_ip = true
  }
}
 
output "instance-ip" {
  value = [oci_core_instance.instance1.public_ip]
}

Acessando a Instância

Use o comando SSH a seguir para acessar a instância:

$ ssh –i <private_key_path> <username>@<instance_ip_address>

<private_key_path> é o caminho completo e o nome do arquivo que contém a chave privada associada à instância que você deseja acessar.

<username> é o nome do usuário padrão da instância. Para imagens do Oracle Linux, o nome do usuário padrão é opc.

<instance_ip_address> é o endereço IP da instância que foi a saída dos comandos do Terraform.

Instalando e Configurando o Terraform na Instância

Use o yum para instalar na instância o Terraform e o provedor Terraform do OCI compatível com FIPS:
```
yum install -y terraform terraform-provider-oci-fips
```
Adicione ao perfil bash uma variável de ambiente para ativar a autenticação do controlador de instâncias:
```
echo "export TF_VAR_auth='InstancePrincipal'" >> ${HOME}/.bash_profile
```
Adicione uma variável de ambiente para definir a região de destino do Terraform:
```
echo "export TF_VAR_region='<your_region>'" >> ${HOME}/.bash_profile
```
Adicione uma variável de ambiente para desativar a criptografia de tráfego interprocesso entre o Terraform e o provedor Terraform do OCI:
```
echo "export TF_DISABLE_PLUGIN_TLS=1" >> ${HOME}/.bash_profile
```
Adicione uma variável de ambiente para impedir que o Terraform acesse o serviço HashiCorp Checkpoint:
```
echo "export CHECKPOINT_DISABLE=1" >> ${HOME}/.bash_profile
```
Saia da instância:
```
exit
```

Implementando Regras de Segurança

Antes de usar a nova instância para executar o Terraform, atualize as regras de segurança para impedir o tráfego de saída para quaisquer pontos finais de terceiros que não sejam serviços do OCI. Você pode fazer isso removendo a seguinte regra de saída do recurso security-list1 do arquivo de configuração do Terraform e executando terraform apply na máquina do Oracle Linux:

// outbound tcp traffic on all ports
// remove this rule or comment it out to prevent egress traffic to third-party endpoints
#egress_security_rules {
#  destination = "0.0.0.0/0"
#  protocol    = "6"
#}