Activation de la compatibilité FIPS

Maintenez la conformité FIPS lors de l'utilisation du fournisseur Terraform pour Oracle Cloud Infrastructure.

Vous pouvez utiliser Terraform et une version spéciale compatible FIPS du fournisseur Oracle Cloud Infrastructure (OCI) Terraform, à condition de respecter certaines exigences et meilleures pratiques spécifiques. Cette rubrique fournit des conseils sur ces exigences et ces pratiques.

Cryptage FIPS

Pour respecter les normes de sécurité les plus strictes, le trafic entre les adresses Terraform et OCI doit transiter par une connexion TLS établie avec un client HTTP à l'aide d'un cryptage certifié FIPS.

Le fournisseur OCI Terraform standard est implémenté dans Go. Les implémentations de cryptographie native de Go, bien qu'elles soient entièrement capables d'établir des connexions TLS sécurisées avec des adresses OCI, ne sont pas certifiées FIPS.

Pour que le trafic Terraform transite vers les adresses OCI via des connexions compatibles FIPS, vous devez utiliser une version spéciale du fournisseur Terraform qui applique la cryptographie certifiée FIPS. Cette version du fournisseur OCI Terraform utilise la certification FIPS 140-2 d'Oracle Cloud Infrastructure pour BoringCrypto plutôt que l'implémentation de cryptographie native de Go. Découvrez Oracle Cloud Infrastructure pour BoringCrypto ici.

Installation du fournisseur Terraform compatible FIPS

Le fournisseur OCI Terraform compatible FIPS est disponible uniquement pour Oracle Linux. Vous pouvez installer le fournisseur à l'aide de YUM.

Conseil

Avant d'installer le fournisseur OCI Terraform, téléchargez et installez Terraform à partir de HashiCorp, ou installez Terraform à l'aide de YUM.

Si des packages du fournisseur OCI Terraform existants sont déjà installés sur l'ordinateur Oracle Linux, commencez par les enlever :

yum remove terraform-provider-oci

Installez le fournisseur OCI Terraform compatible FIPS en exécutant la commande YUM suivante à partir d'un ordinateur Oracle Linux :

yum install terraform-provider-oci-fips

Configuration du fournisseur Terraform

  1. Ajoutez une variable d'environnement afin de définir la région cible pour Terraform :

    echo "export TF_VAR_region='<your_region>'" >> ${HOME}/.bash_profile
  2. Ajoutez une variable d'environnement pour désactiver le cryptage du trafic inter-processus entre Terraform et le fournisseur OCI Terraform :

    echo "export TF_DISABLE_PLUGIN_TLS=1" >> ${HOME}/.bash_profile
  3. Ajoutez une variable d'environnement pour empêcher Terraform d'accéder au service HashiCorp Checkpoint :

    echo "export CHECKPOINT_DISABLE=1" >> ${HOME}/.bash_profile
  4. Configurez la méthode d'authentification pour le fournisseur Terraform. Pour plus d'informations, reportez-vous à Authentification.

Exploitation de Terraform dans une seule région

Pour vous assurer que le trafic entre les services Terraform et OCI ne transite pas par l'infrastructure Internet publique, nous vous recommandons d'exécuter Terraform et le fournisseur OCI Terraform à partir d'une instance Compute hébergée dans la même région que les ressources qu'ils créent et gèrent.

Création d'une instance Compute

Une fois Terraform et le fournisseur OCI Terraform installés sur un ordinateur Oracle Linux, vous pouvez utiliser Terraform et l'exemple de fichier de configuration Terraform suivant aux fins ci-dessous :

  • Créer une instance de calcul donnée que vous pouvez utiliser pour provisionner une infrastructure supplémentaire dans la même région
  • Installer Terraform et le dernier fournisseur OCI Terraform compatible FIPS sur la nouvelle instance
  • Limiter la communication avec l'instance aux adresses OCI et à HTTPS à l'aide d'une passerelle de service
  • Activer l'authentification par principal d'instance

Pour plus d'informations, reportez-vous à Création de configurations.

Pour créer l'instance de calcul, procédez comme suit :

  1. Copiez le fichier main.tf vers votre ordinateur Oracle Linux.
  2. Rassemblez les informations requises pour renseigner les variables du fichier de configuration Terraform.
  3. Reportez-vous à Images de plate-forme afin de localiser la valeur de l'OCID d'image Oracle Linux pour votre région. Modifiez la valeur oel-image dans le fichier de configuration Terraform.
  4. Initialisez Terraform dans le répertoire contenant le fichier de configuration Terraform :

    terraform init
  5. Appliquez la configuration Terraform :

    terraform plan
    terraform apply
Important

La variable de sortie instance-ip fournit l'adresse IP à utiliser pour vous connecter à la nouvelle instance de calcul.

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

Connexion à l'instance

Utilisez la commande SSH suivante pour accéder à l'instance:

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

<private_key_path> est le chemin complet et le nom du fichier contenant la clé privée associée à l'instance à laquelle vous souhaitez accéder.

<username> est le nom utilisateur par défaut de l'instance. Pour les images Oracle Linux, le nom utilisateur par défaut est opc.

<instance_ip_address> est l'adresse IP de l'instance qui a constitué la sortie des commandes Terraform.

Installation et configuration de Terraform sur l'instance

  1. Utilisez YUM pour installer Terraform et le fournisseur OCI Terraform compatible FIPS sur l'instance :

    yum install -y terraform terraform-provider-oci-fips
  2. Ajoutez une variable d'environnement pour activer l'authentification par principal d'instance sur le profil bash :

    echo "export TF_VAR_auth='InstancePrincipal'" >> ${HOME}/.bash_profile
  3. Ajoutez une variable d'environnement afin de définir la région cible pour Terraform :

    echo "export TF_VAR_region='<your_region>'" >> ${HOME}/.bash_profile
  4. Ajoutez une variable d'environnement pour désactiver le cryptage du trafic inter-processus entre Terraform et le fournisseur OCI Terraform :

    echo "export TF_DISABLE_PLUGIN_TLS=1" >> ${HOME}/.bash_profile
  5. Ajoutez une variable d'environnement pour empêcher Terraform d'accéder au service HashiCorp Checkpoint :

    echo "export CHECKPOINT_DISABLE=1" >> ${HOME}/.bash_profile
  6. Quittez l'instance :

    exit

Implémentation des règles de sécurité

Avant d'utiliser la nouvelle instance pour exécuter Terraform, vous devez mettre à jour les règles de sécurité afin d'empêcher le trafic sortant vers des adresses tierces autres que les services OCI. Pour ce faire, enlevez la règle sortante suivante de la ressource security-list1 du fichier de configuration Terraform et exécutez terraform apply à partir de l'ordinateur 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"
#}
Conseil

Vous pouvez également utiliser la console OCI pour mettre à jour vos règles de sécurité sur la nouvelle instance.

Exécution de Terraform à partir de l'instance

Après la création de l'instance, l'installation et la configuration de Terraform sur l'instance, et la mise à jour des règles de sécurité, vous pouvez utiliser Terraform pour provisionner une infrastructure OCI supplémentaire dans la même région. Copiez des fichiers de configuration Terraform supplémentaires vers votre instance, connectez-vous à l'instance et exécutez les commandes Terraform comme tout autre fournisseur Terraform :

ssh -i <private_key_path> opc@<instance_ip_address>
terraform init
terraform apply