Activation de la compatibilité FIPS

Maintenez la conformité FIPS tout en utilisant le fournisseur Terraform Oracle Cloud Infrastructure.

Cette page décrit les exigences et les meilleures pratiques d'utilisation de Terraform avec une version compatible FIPS du fournisseur OCI Terraform.

Chiffrement FIPS

Pour respecter les normes de sécurité les plus strictes, déplacez le trafic entre les adresses Terraform et OCI sur 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 natives de Go sont tout à fait capables d'établir des connexions TLS sécurisées avec des adresses OCI, mais elles ne sont pas certifiées FIPS.

Pour que le trafic Terraform passe aux adresses OCI via des connexions compatibles FIPS, vous devez utiliser une version spéciale du fournisseur Terraform qui utilise la cryptographie certifiée FIPS. Cette version du fournisseur OCI Terraform utilise la certification FIPS 140-2 Oracle Cloud Infrastructure pour BoringCrypto au lieu de 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 d'yum.

Conseil

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

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 de calcul 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 pour :

  • Créer une instance de calcul donnée que vous pouvez utiliser pour provisionner plus d'infrastructure 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 un ordinateur Oracle Linux.
  2. Rassemblez les informations requises pour renseigner les variables du fichier de configuration Terraform.
  3. Remplacez la valeur oel-image dans le fichier de configuration Terraform par la valeur d'OCID d'image Oracle Linux pour votre région.

    Afin de trouver la valeur d'OCID d'image Oracle Linux pour une région, reportez-vous à Images de plate-forme.

  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 accessible.

<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, mettez à jour les règles de sécurité afin d'empêcher le trafic sortant vers des adresses tierces autres que les services OCI. Pour effectuer cette mise à jour, 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 avoir créé l'instance, installé et configuré Terraform sur l'instance, et mis à jour les règles de sécurité, vous pouvez utiliser Terraform pour provisionner plus d'infrastructure OCI dans la même région. Copiez d'autres fichiers de configuration Terraform vers une instance, connectez-vous à l'instance et exécutez des commandes Terraform comme avec tout autre fournisseur Terraform :

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