Remarques :

Introduction à Terraform dans Oracle Cloud Infrastructure

Introduction

Terraform est un outil Infrastructure-as-Code (IaC) développé par Hashicorp qui vous permet de définir, de provisionner et de gérer votre infrastructure auprès de plusieurs fournisseurs cloud à l'aide de la syntaxe de langage Terraform, HCL. Terraform vous permet d'automatiser l'intégralité du cycle de vie de votre infrastructure cloud, ce qui facilite la création, la mise à jour et l'évolutivité des ressources de manière cohérente et reproductible. Terraform est largement utilisé par les équipes DevOps pour gérer les ressources cloud, améliorer l'efficacité de l'infrastructure, réduire les erreurs manuelles et les ressources cloud de contrôle des versions.

Ce tutoriel vous aide à commencer votre parcours en tirant parti de IaC pour le déploiement et la gestion de votre infrastructure cloud.

Workflow de l'architecture Terraform

Workflow de l'architecture Terraform

Objectifs

Prérequis

Tâche 1 : déclaration du soignant

Un fournisseur Terraform fait référence à un module d'extension chargé de comprendre un type spécifique d'infrastructure ou de service et d'interagir avec lui. Les fournisseurs sont le pont entre Terraform et les API des services ou des plates-formes à gérer. Les fournisseurs permettent à Terraform de communiquer et d'interagir efficacement avec les plates-formes cloud. En d'autres termes, le fournisseur Terraform est comme un traducteur qui aide Terraform à parler à différents services ou systèmes cloud, ce qui lui permet de créer, de gérer et de supprimer des ressources telles que des machines virtuelles, des bases de données et des réseaux.

Chaque fournisseur correspond généralement à une plate-forme cloud spécifique (par exemple, OCI, AWS, Azure, GCP) ou à un service d'infrastructure (par exemple, Kubernetes, Docker).

  1. Créez un dossier nommé terraform-beginners-demo et ouvrez-le dans VS Code.

  2. Installez l'extension HashiCorp Terraform dans VS Code.

  3. Créez les fichiers provider.tf et variables.tf sous le dossier terraform-beginners-demo.

  4. Copiez le code suivant dans le fichier provider.tf.

    terraform {
  required_providers {
    oci = {
      source = "oracle/oci"
      version = "5.30.0"
    }
  }
}

provider "oci" {
  tenancy_ocid          = var.tenancy_id
  user_ocid             = var.user_id
  fingerprint           = var.api_fingerprint
  private_key_path      = var.api_private_key_path
  region                = var.region
}

    Remarque : nous avons utilisé le code de la page de registre Terraform officielle. Pour plus d'informations, reportez-vous à Fournisseur Oracle Cloud Infrastructure et à Dernière version (5.30.0).

Tâche 2 : création d'une configuration OCI

Pour configurer le fournisseur, nous avons besoin de l'OCID (identificateur Oracle Cloud) de l'utilisateur OCI, de l'OCID de location et de l'OCID de compartiment.

  1. Connectez-vous à la console OCI.

  2. Cliquez sur l'icône de profil utilisateur et sélectionnez Mon profil.

  3. Pour obtenir la paire de clés d'API, procédez comme suit :

    1. Sous Ressources, sélectionnez Clé d'API et cliquez sur Ajouter une clé d'API.

    2. Vous pouvez générer une nouvelle paire de clés d'API ou utiliser votre clé publique existante pour générer une paire de clés d'API. Sélectionnez Générer une paire de clés d'API. Veillez à télécharger la clé privée et la clé publique.

    3. Cliquez sur Ajouter. Une zone d'aperçu du fichier de configuration s'affiche.

      Création de paire de clés d'API

    4. Copiez les détails fournis dans l'aperçu du fichier de configuration et enregistrez-le quelque part. Elle sera utilisée dans le fichier variables.tf.

      Elle doit ressembler à :

      [DEFAULT]
user=ocid1.user.oc1..xxxxxxxxxxx
fingerprint=xx:xx:xx:xx:xx
tenancy=ocid1.tenancy.oc1..xxxxxxxxx
region=us-phoenix-1 # your region ID
key_file=<path to your private keyfile> # TODO

    5. Cliquez sur Fermer.

    OR (OU)

    Pour obtenir une paire de clés d'API, reportez-vous à Génération d'une configuration de clé d'API dans la console OCI.

Tâche 3 : configuration de l'environnement Terraform avec les informations d'identification OCI

  1. Accédez à l'éditeur de code VS et créez un fichier nommé variables.tf sous le dossier terraform-beginners-demo, puis collez le code suivant.

    variable "api_fingerprint" {
  description = "Fingerprint of OCI API private key for Tenancy"
  type        = string
}

variable "api_private_key_path" {
  description = "Path to OCI API private key used for Tenancy"
  type        = string
}

variable "tenancy_id" {
  description = "Tenancy ID where to create resources for Tenancy"
  type        = string
}

variable "user_id" {
  description = "User ID that Terraform will use to create resources for Tenancy"
  type        = string
}

variable "region" {
  description = "OCI region where resources will be created for Tenancy"
  type        = string
}

  2. Créez un autre fichier nommé terraform.tfvars et collez le code suivant. Définissez chaque variable à partir de variables.tf à l'aide des valeurs de fichier de configuration de la tâche 2.3.

    # Identity and access parameters
api_fingerprint      = "REPLACE_BY_YOUR_FINGERPRINT" # Fingerprint of OCI API private key for Tenancy
api_private_key_path = "~/.oci/oci_api_key.pem"      # Path to OCI API private key used for Tenancy
region               = "us-phoenix-1"                # OCI region where resources will be created for Tenancy
tenancy_id           = "REPLACE_YOUR_TENACY_OCID"    # Tenancy ID where to create resources
user_id              = "REPLACE_BY_YOUR_USER_OCID"   # Path to OCI API private key used for Tenancy

    Remarque : dans l'environnement de production, il est recommandé d'utiliser le fichier terraform.tfvars pour définir les variables terraform afin de promouvoir la sécurité et l'évolutivité. Pour plus d'informations, reportez-vous à Fichiers de définitions de variable (.tfvars).

Tâche 4 : test de la connectivité Terraform avec votre location OCI

  1. Créez un fichier nommé data_source.tf sous le dossier terraform-beginners-demo et copiez le code suivant.

    data "oci_identity_availability_domains" "ad" {
    #Required
    compartment_id = var.tenancy_id
}

  2. Créez un fichier nommé output.tf sous le dossier terraform-beginners-demo et copiez le code suivant.

    output "list_ads" {
  value = data.oci_identity_availability_domains.ad.availability_domains
}

  3. Ouvrez un nouveau terminal dans VS Code et exécutez les commandes suivantes pour exécuter le script terraform.

    Command 1: terraform init

Command 2: terraform plan #to view your deployments what is going to be created

Command 3: terraform apply #then type "yes" once prompted alternatively run "apply -auto-approve

    Workflow d'exécution Terraform

    Vous devriez maintenant pouvoir voir la liste des domaines de disponibilité et le compartiment qui leur est associé sous les sorties.

    Domaines de disponibilité OCI

    Vous avez maintenant configuré votre système pour déployer des ressources dans votre location OCI dans Terraform. Vous avez transmis les variables mais vous n'avez apporté aucune modification à votre location. Nous vous présenterons quelques exemples pour vous aider à mieux comprendre le processus d'ajout, de chaînage et de destruction de ressources à l'aide de Terraform.

Tâche 5 : (exemple) déploiement d'une instance OCI Compute à l'aide de Terraform

Nous allons maintenant nous appuyer sur ce que vous avez créé lors des tâches précédentes pour déployer des ressources de réseau et de calcul.

  1. Créez un fichier nommé networking.tf et copiez le code suivant.

    resource "oci_core_vcn" "test_vcn" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id


  cidr_block   = var.vcn_cidr_block
  display_name = var.vcn_display_name
  dns_label    = var.vcn_dns_label
}

    Remarque : pour plus d'informations sur la variable core-vcn avec des configurations supplémentaires, reportez-vous à oci_core_vcn.

  2. Modifiez le fichier variables.tf et ajoutez les variables suivantes.

    #VCN specific variables
variable "create_new_vcn" {
  description = "Boolean variable to specify whether to create a new VCN or to reuse an existing one."
  type        = bool
}

variable "compartment_id" {
  description = "OCI compartment where resources will be created"
  type        = string
}

variable "vcn_cidr_block" {
  description = "The list of IPv4 CIDR blocks the VCN will use"
  type        = string
}

variable "vcn_display_name" {
  description = "provide a descriptive name for the VCN - this is what you will see displayed in the OCI console"
  type        = string
}

variable "vcn_dns_label" {
  description = "provide a descriptive alphanumeric name for the DNS - this is what you will see displayed in the OCI console"
  type        = string
}

variable "vcn_id" {
  description = "provide your existing VCN OCID if create_new_vcn = false"
  type = string
}

variable "private_subnet_id" {
  description = "provide existing private subnet OCID"
  type = string
}

variable "public_subnet_id" {
  description = "provide existing public subnet OCID"
  type = string
}

  3. Ajoutez les nouvelles variables dans terraform.tfvars et définissez chaque variable en fonction de la configuration de votre location.

    # VCN specific variables
create_new_vcn = true # Set this to true if you want terraform to crearte the network for you, otherwise set it to false.
compartment_id   = "REPLACE_BY_YOUR_COMPARTMENT_OCID" # add your own compartment id where the vcn will be created 
vcn_cidr_block   = "10.0.0.0/16"                      # The list of IPv4 CIDR blocks the VCN will use
vcn_display_name = "terraform_vcn_example"   # provide a descriptive name for the VCN - this is what you will see displayed in the OCI console
vcn_dns_label    = "terraformvcn"                     # provide a descriptive alphanumeric name for the DNS - this is what you will see displayed in the OCI console

# Configure CIDR Blocks, Subnet(Public, Private) OCIDS for an existing VCN. #
vcn_id            = "REPLACE_BY_YOUR_VCN_OCID"             #ADD WITH YOUR VCN OCID
private_subnet_id = "REPLACE_BY_YOUR__PRIVATE_SUBNET_OCID" #ADD WITH YOUR PRIVATE SUBNET
public_subnet_id  = "REPLACE_BY_YOUR_PUBLIC_SUBNET__OCID"  #AA WITH YOUR PUBLIC SUBNET

    Remarque : si vous disposez déjà d'un VCN existant, définissez create_new_vcn sur false et modifiez les variables vcn_id, private_subnet_id et public_subnet_id.

  4. Créez des sous-réseaux pour votre nouveau VCN.

    1. Dans le fichier networking.tf, ajoutez le code suivant pour créer vos sous-réseaux publics et privés.

      resource "oci_core_subnet" "private_subnet" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  cidr_block     = var.private_subnet_cidr_block
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]

  display_name               = var.private_subnet_display_name
  prohibit_public_ip_on_vnic = var.private_subnet_prohibit_public_ip_on_vnic
}

resource "oci_core_subnet" "public_subnet" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  cidr_block     = var.public_subnet_cidr_block
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]


  display_name               = var.public_subnet_display_name
  prohibit_public_ip_on_vnic = var.public_subnet_prohibit_public_ip_on_vnic
  route_table_id             = oci_core_route_table.test_route_table.*.id[0]
}

      Remarque : pour plus d'informations sur la variable de sous-réseau principal avec des configurations supplémentaires, reportez-vous à oci_core_subnet.

    2. Ajoutez les nouvelles variables de sous-réseau dans le fichier variables.tf en copiant le code suivant.

        #Private subnet variables
variable "private_subnet_cidr_block" {
  description = "OCI private subnet CIDR block range"
  type        = string
}


variable "private_subnet_display_name" {
  description = "provide a descriptive name for the private subnet - this is what you will see displayed in the OCI console"
  type        = string
}


variable "private_subnet_prohibit_public_ip_on_vnic" {
  description = "Allow public IP address to the VNIC"
  type        = bool
}


#Public subnet variables
variable "public_subnet_cidr_block" {
  description = "OCI public subnet CIDR block range"
  type        = string
}


variable "public_subnet_display_name" {
  description = "provide a descriptive name for the public subnet - this is what you will see displayed in the OCI console"
  type        = string
}


variable "public_subnet_prohibit_public_ip_on_vnic" {
  description = "Allow public IP address to the VNIC"
  type        = bool
}

    3. Déclarez les nouvelles variables de sous-réseau dans le fichier terrform.tfvars.

      #Private subnet variables
private_subnet_cidr_block                 = "10.0.1.0/24"                               # OCI private subnet CIDR block range
private_subnet_display_name               = "terraform_private_subnet_example" # provide a descriptive name for the private subnet - this is what you will see displayed in the OCI console
private_subnet_prohibit_public_ip_on_vnic = false                                       # Allow public IP address to the VNIC

#Public subnet variables
public_subnet_cidr_block                 = "10.0.2.0/24"                              # OCI public subnet CIDR block range
public_subnet_display_name               = "terraform_public_subnet_example" # provide a descriptive name for the public subnet - this is what you will see displayed in the OCI console
public_subnet_prohibit_public_ip_on_vnic = false

  5. Ajoutez le code suivant dans le fichier networking.tf pour créer une passerelle Internet.

    resource "oci_core_internet_gateway" "test_internet_gateway" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id
  display_name   = "INTERNET_GTWFOR_${var.vcn_display_name}"
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]
  #route_table_id = oci_core_route_table.test_route_table.id
}

  6. Ajoutez le code suivant dans networking.tf pour la table de routage afin de gérer le trafic vers Internet.

    resource "oci_core_route_table" "test_route_table" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]


  route_rules {
    #Required
    network_entity_id = oci_core_internet_gateway.test_internet_gateway.*.id[0]


    description      = "route rule internet access for ${var.vcn_display_name}"
    destination      = "0.0.0.0/0"
    destination_type = "CIDR_BLOCK"
  }
}

  7. Créez le groupe de sécurité réseau associé au VCN. Copiez le code suivant dans le fichier networking.tf.

    resource "oci_core_network_security_group" "test_nsg" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]
  display_name   = "NETWORK_SECURITY_GROUP_${var.vcn_display_name}"
  freeform_tags  = { "Lab" = "Terraofm 101 Guide" }
}

  8. Nous allons maintenant créer 2 fichiers, compute_linux.tf et compute_windows.tf, pour le déploiement d'une machine virtuelle Linux et d'une machine virtuelle Windows.

  9. Dans compute_linux.tf, copiez le code suivant pour créer une instance de calcul avec un système d'exploitation Linux.

    resource "oci_core_instance" "test_linux_instance" {
  #Required
  count = var.create_linux_instance ? 1 : 0

  availability_domain = data.oci_identity_availability_domains.ad.availability_domains[0].name
  compartment_id      = var.compartment_id


  create_vnic_details {
    assign_public_ip       = "true"
    display_name           = var.instance_display_name
    nsg_ids                = []
    skip_source_dest_check = "false"
    subnet_id              = var.create_new_vcn ? oci_core_subnet.public_subnet.*.id[0] : var.public_subnet_id
  }

  display_name = "${var.instance_display_name}_linux"

  metadata = {
    ssh_authorized_keys = "${file(var.public_ssh_key)}"
  }

  shape = var.instance_shape
  shape_config {

    memory_in_gbs = var.instance_flex_memory_in_gbs
    ocpus         = var.instance_flex_ocpus
  }

  launch_options {
    boot_volume_type                    = "PARAVIRTUALIZED"
    firmware                            = "UEFI_64"
    is_consistent_volume_naming_enabled = "true"
    is_pv_encryption_in_transit_enabled = "true"
    network_type                        = "PARAVIRTUALIZED"
    remote_data_volume_type             = "PARAVIRTUALIZED"

  }

  source_details {
    #Required
    source_id   = var.linux_image_ocid
    source_type = "image"

  }
  preserve_boot_volume = false
}

  10. Dans compute_windows.tf, copiez le code suivant.

    resource "oci_core_instance" "test_windows_instance" {
  #Required
  count = var.create_windows_instance ? 1 : 0


  availability_domain = data.oci_identity_availability_domains.ad.availability_domains[0].name
  compartment_id      = var.compartment_id



  create_vnic_details {
    assign_public_ip       = "true"
    display_name           = var.instance_display_name
    nsg_ids                = []
    skip_source_dest_check = "false"
    subnet_id              = var.create_new_vcn ? oci_core_subnet.public_subnet.*.id[0] : var.public_subnet_id


  }

  display_name = "${var.instance_display_name}_windows"

  metadata = {
  }

  shape = var.instance_shape
  shape_config {

    memory_in_gbs = var.instance_flex_memory_in_gbs
    ocpus         = var.instance_flex_ocpus
  }

  launch_options {
    boot_volume_type                    = "PARAVIRTUALIZED"
    firmware                            = "UEFI_64"
    is_pv_encryption_in_transit_enabled = "true"
    network_type                        = "PARAVIRTUALIZED"
    remote_data_volume_type             = "PARAVIRTUALIZED"

  }

  source_details {
    #Required
    source_id   = var.windows_image_ocid
    source_type = "image"

  }
  preserve_boot_volume = false
}

  11. Mettez à jour variables.tf avec les nouvelles variables pour dans compute_linux et compute_windows.

    #Compute variables
variable "instance_shape" {
  description = "value"
  type        = string
}


variable "instance_flex_memory_in_gbs" {
  description = "(Updatable) The total amount of memory available to the instance, in gigabytes."
  type        = number
}


variable "instance_flex_ocpus" {
  description = "(Updatable) The total number of OCPUs available to the instance."
  type        = number
}


variable "instance_create_vnic_details_assign_public_ip" {
  description = "To allow compute connectivity from internet"
  type        = bool
}


variable "instance_display_name" {
  description = "provide a descriptive name for the compute instance - this is what you will see displayed in the OCI console"
  type        = string
}


variable "public_ssh_key" {
  description = "Add your public ssh key - for provisioning your compute instance"
  type        = string
}


variable "private_ssh_key" {
  description = "Add your private ssh key - for accessing your compute instance after creation"
  type        = string
}


variable "create_linux_instance" {
  description = "Boolean variable to specify whether to provision a Linux instances"
  type        = bool
}


variable "create_windows_instance" {
  description = "Boolean variable to specify whether to provision a Windows instances"
  type        = bool
}


variable "windows_image_ocid" {
  description = "OCID of the Windows image to use"
  type        = string
}


variable "linux_image_ocid" {
  description = "OCID of the Linux image to use"
  type        = string
}

  12. Ajoutez et définissez les nouvelles variables dans terraform.tfvars.

    #Compute variables - Make sure to select a compatible shape (e.g.: VM.Standard.E4.Flex)
instance_shape                                = "VM.Standard.E5.Flex"                # Shape of the compute instance 
instance_flex_memory_in_gbs                   = 16                                   # (Updatable) The total amount of memory available to the instance, in gigabytes.
instance_flex_ocpus                           = 1                                    # (Updatable) The total number of OCPUs available to the instance.
instance_create_vnic_details_assign_public_ip = true                                 # To allow compute connectivity from internet
instance_display_name                         = "terraform_compute_example" # provide a descriptive name for the compute instance - this is what you will see displayed in the OCI console

#SSH keys https://docs.oracle.com/en/learn/generate_ssh_keys/index.html#introduction
public_ssh_key  = "~/cloudshellkey.pub" # Add your public ssh key
private_ssh_key = "~/cloudshellkey"     # Add your private ssh key

create_linux_instance   = true # if set to true a test linux instance will be created and false no linux instance will be deployed.
create_windows_instance = true # # If set to true a test windows instance will be created and false no windows instance will be deployed.

linux_image_ocid   = "REPLACE_BY_YOUR_REGION_LINUX_IMAGE_OCID"   # OCID for chosen image (Oracle Linux 9 example) specific to the test region (us-phoenix-1)
windows_image_ocid = "REPLACE_BY_YOUR_REGION_WINDOWS_IMAGE_OCID" # OCID for chosen image (Windows example) specific to each region (us-phoenix-1)

# Here are other image OCIDs for popular region (Ashburn, San Jose, Toronto)
# Ashburn
# Oracle linux image_id = ocid1.image.oc1.iad.aaaaaaaau7uaok7n5qd4nivgiyfatfdddhltmxddtfbyqg3bsg3fxk6z6aqq
# Windows image_id = ocid1.image.oc1.iad.aaaaaaaamaaiupezxbrw6fji5ndk3jdujwhjuexcafheqjqf45g6nzyblz6a

#San Jose
# Oracle linux image_id = ocid1.image.oc1.us-sanjose-1.aaaaaaaabjixxpfouczgpcnpvgny5pcqtgjgi3nincszbfdkd2xr4jvzahua
# Windows image_id = ocid1.image.oc1.us-sanjose-1.aaaaaaaatmjlzoqw5gzohjvygzcm5rpugomxyfho5xi6subjchoxnxo4wcfa

#Toronto
# Oracle linux image_id = ocid1.image.oc1.ca-toronto-1.aaaaaaaai6uhjrtajuuitl5hara5brnvwqvq4aebenmnbehv2cila75xbvzq
# Windows image_id = ocid1.image.oc1.ca-toronto-1.aaaaaaaaeged3obrrmmwvyruvknszy23btvb2fqu7vn3c5azeecbj2prm64q

# for other image OCIDs: https://docs.oracle.com/en-us/iaas/images/

    Remarque : les OCID d'image sont propres à chaque région. Dans le code ci-dessus, il existe des OCID d'image pour les régions les plus populaires. Vous pouvez trouver des OCID d'image pour toutes les autres régions ici : Toutes les familles d'images.

  13. Dans output.tf, copiez le code suivant. Cela affichera les ressources créées dans le terminal.

    # Regions
output "linux_instance_region" {
  value = oci_core_instance.test_linux_instance.*.region
}

output "windows_instance_region" {
  value = oci_core_instance.test_windows_instance.*.region
}

# Networking
output "network_vcn_name" {
  value = oci_core_vcn.test_vcn.*.display_name
}

# Compute: Linux Test Instance
output "output_linux_instance_display_name" {
  value = oci_core_instance.test_linux_instance.*.display_name
}

output "output_linux_instance_public_ip" {
  value = oci_core_instance.test_linux_instance.*.public_ip
}

output "output_linux_instance_state" {
  value = oci_core_instance.test_linux_instance.*.state
}

# Compute: Windows Test Instance
output "output_windows_instance_display_name" {
  value = oci_core_instance.test_windows_instance.*.display_name
}

output "output_windows_instance_public_ip" {
  value = oci_core_instance.test_windows_instance.*.public_ip
}

output "output_windows_instance_state" {
  value = oci_core_instance.test_windows_instance.*.state
}

  14. Ouvrez un nouveau terminal pour terraform-example et exécutez les commandes suivantes.

    Command 1: terraform init

Command 2: terraform plan

Commnad 3: terraform apply (and then respond "yes") OR terraform apply -auto-approve

    Vous devriez voir la sortie suivante et un VCN, un sous-réseau privé et un sous-réseau public, une table de routage, une passerelle Internet, nsg, une machine virtuelle Linux et une machine virtuelle Windows doivent être créés.

    Exemple d'exécution de terminal Terraform

  15. Les ressources ont désormais été déployées à l'aide de Terraform. Une fois que vous avez vérifié la création de ressources dans votre location OCI, utilisez la commande suivante pour détruire toutes les ressources.

    Command: terraform destroy

Etapes suivantes

Vous avez désormais créé la connexion à Terraform et appris à déployer, mettre à jour et détruire des ressources à l'aide d'un exemple simple. Pour poursuivre votre parcours Terraform dans OCI et vous configurer pour la certification professionnelle OCI Architect, consultez Accélérer la certification professionnelle Oracle Cloud Infrastructure Architect avec Terraform.

Nous saluons les contributions des lecteurs pour améliorer et développer ce tutoriel. Vos contributions sont très appréciées pour améliorer cette ressource pour les futurs apprenants Terraform.

Remerciements

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.