Note :

Introduction à Terraform dans Oracle Cloud Infrastructure

Présentation

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

Ce tutoriel vous aidera à commencer votre parcours vers l'utilisation de IaC pour le déploiement et la gestion de votre infrastructure en nuage.

Flux de travail d'architecture Terraform

Flux de travail d'architecture Terraform

Objectifs

Préalables

Tâche 1 : Déclarer le fournisseur

Un fournisseur Terraform fait référence à un plugiciel qui est responsable de la compréhension et de l'interaction avec un type spécifique d'infrastructure ou de service. Les fournisseurs sont le pont entre Terraform et les API des services ou plates-formes que vous voulez gérer. Les fournisseurs permettent à Terraform de communiquer et d'interagir avec les plates-formes en nuage efficacement. En d'autres termes, le fournisseur Terraform est comme un traducteur qui aide Terraform à parler à différents services ou systèmes en nuage, 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 en nuage 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 dans 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
}

    Note : Nous avons utilisé le code de la page du registre Terraform officiel. Pour plus d'informations, voir Fournisseur Oracle Cloud Infrastructure et Dernière version (5.30.0).

Tâche 2 : Créer une configuration OCI

Nous avons besoin de l'identificateur Oracle Cloud de l'utilisateur OCI (OCID), de l'OCID de la location et de l'OCID du compartiment pour configurer le fournisseur.

  1. Connectez-vous à la console OCI.

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

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

    1. Sous Ressources, sélectionnez Clés 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. Assurez-vous de télécharger la clé privée et la clé publique.

    3. Cliquez sur Ajouter. Une zone de prévisualisation du fichier de configuration s'affiche.

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

    4. Copiez les détails fournis dans la prévisualisation du fichier de configuration et enregistrez-les quelque part. Elle sera utilisée dans le fichier variables.tf.

      Elle doit se présenter comme suit :

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

    OU

    Pour obtenir une paire de clés d'API, voir Générer une configuration de clé d'API dans la console OCI.

Tâche 3 : Configurer l'environnement Terraform avec les données d'identification OCI

  1. Allez à l'éditeur de code VS et créez un nouveau fichier nommé variables.tf sous le dossier terraform-beginners-demo et 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

    Note : 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, voir Fichiers de définitions de variable (.tfvars).

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

  1. Créez un nouveau 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 nouveau 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

    Flux de travail d'exécution Terraform

    Vous devriez maintenant 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 passerons en revue quelques exemples pour vous aider à mieux comprendre le processus d'ajout, d'enchaînement et de destruction des ressources à l'aide de Terraform.

Tâche 5 : (Exemple) Déployer une instance de calcul OCI à l'aide de Terraform

Nous allons maintenant nous appuyer sur ce que vous avez créé dans les tâches précédentes pour déployer les 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
}

    Note : Pour plus d'informations sur les variables core-vcn avec des configurations supplémentaires, voir oci_core_vcn.

  2. Modifiez votre 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

    Note : Si vous avez déjà un VCN existant, réglez create_new_vcn à Faux 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]
}

      Note : Pour plus d'informations sur les variables de sous-réseau de base avec des configurations supplémentaires, voir 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é de 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 nouveaux fichiers, compute_linux.tf et compute_windows.tf, pour déployer une machine virtuelle Linux et 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/

    Note : Les OCID d'image sont propres à chaque région. Dans le code ci-dessus, il existe des OCID d'image pour les régions populaires et 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 imprimera 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, un nsg, une machine virtuelle Linux et une machine virtuelle Windows doivent être créés.

    Exemple d'exécution de terminal Terraform

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

    Command: terraform destroy

Étapes suivantes

Vous avez maintenant établi 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 d'architecte d'OCI, consultez Accélérer la certification professionnelle d'architecte d'Oracle Cloud Infrastructure avec Terraform.

Nous souhaitons la bienvenue aux contributions des lecteurs pour améliorer et élargir ce tutoriel. Vos contributions sont très appréciées dans l'amélioration de cette ressource pour les futurs apprenants Terraform.

Confirmation

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.