Remarques :

Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. A la fin de l'exercice, remplacez ces valeurs par des valeurs propres à votre environnement cloud.

Déployer une base de données gérée par OCI avec le service PostgreSQL à l'aide de Terraform

Introduction

PostgreSQL, une base de données relationnelle d'objets open source largement acclamée, occupe une position de premier plan en raison de son architecture robuste et de son intégrité inébranlable des données, ce qui en fait un choix privilégié dans les environnements d'entreprise. Sa disponibilité sur Oracle Cloud Infrastructure (OCI) introduit un service de base de données entièrement géré et performant avec son dimensionnement intelligent, son réglage rentable et sa durabilité. PostgreSQL soutient les entreprises, les petites et moyennes entreprises (PME) et un large éventail d'environnements de développement, démontrant ainsi son adaptabilité et sa robustesse.

Dans ce tutoriel, nous allons découvrir comment déployer trois noeuds d'un système de base de données PostgreSQL géré par OCI dans une location cloud OCI et nous connecter en privé via une instance de calcul à l'aide d'un script Terraform.

Objectifs

Déployez une base de données gérée par OCI avec PostgreSQL et une instance de calcul pour connecter le service de base de données en privé à l'aide de scripts Terraform. Nous allons déployer l'architecture suivante dans OCI à l'aide du code Terraform.

Remarque : si la région sélectionnée a un seul domaine de disponibilité, la création d'un système de base de données hautement disponible répartira toutes les instances PostgreSQL sur tous les domaines de pannes de la région, qu'il s'agisse d'un sous-réseau spécifique ou d'un sous-réseau régional.

Prérequis

Une location Oracle Cloud Infrastructure.
Compte utilisateur doté des privilèges permettant de créer des utilisateurs, d'ajouter des utilisateurs à des groupes d'utilisateurs et de créer des stratégies de sécurité.
L'utilisateur doit disposer des droits d'accès OCI IAM. Pour plus d'informations, reportez-vous à OCI Database avec des stratégies PostgreSQL.

Tâche 1 : créer des fichiers script Terraform dans un dossier

Créez le script providers.tf.

Commençons par créer un fichier providers.tf. Créez un dossier local et copiez le code ci-dessous dans le fichier créé. Les valeurs pour tenancy_id, user_id, région, etc. seront remplacées dans le fichier variables.tf, que nous créerons ultérieurement. Pour obtenir les valeurs des configurations OCI, générez des clés d'API dans OCI en accédant aux paramètres utilisateur, créez une paire de clés d'API, téléchargez en toute sécurité la clé privée, puis utilisez-la avec les OCID d'utilisateur et de location dans le code Terraform pour l'authentification afin de déployer des ressources OCI. Pour plus d'informations, reportez-vous à Génération d'une clé de signature d'API.
```
terraform {
    required_providers {
    oci =  {
        source = "oracle/oci"
        version = "5.22.0"
    }
  }
}
# Provider configuration for Tenancy
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
}
```

Créez le script vcn.tf.

Nous avons besoin d'un réseau VCN avec des sous-réseaux privés et publics pour déployer et accéder au système de base de données OCI PostgreSQL, en gardant à l'esprit que la base de données PostgreSQL sera déployée uniquement sur un sous-réseau privé. Créez un fichier nommé vcn.tf à l'aide du code suivant. Le code garantit que seul le CIDR VCN peut accéder au port 5432 pour PostgreSQL, et qu'il autorise l'accès à l'instance de calcul via SSH sur le port 22 de la liste de sécurité. Vous n'avez pas à vous soucier du remplacement des valeurs ici. Vous pouvez le faire dans le fichier variables.tf.

resource oci_core_vcn psql_vcn_tf {
    #Required
    compartment_id = var.compartment_id

    #Optional
    cidr_block = var.vcn_cidr_block
    display_name = var.vcn_display_name
}

resource oci_core_subnet public_subnet {
    #Required
    cidr_block = var.public_subnet_cidr_block
    compartment_id = var.compartment_id
    vcn_id = oci_core_vcn.psql_vcn_tf.id

    #Optional
    display_name = var.public_subnet_display_name
    route_table_id = oci_core_route_table.tf_public_route_table.id
}

resource oci_core_subnet private_subnet {
    #Required
    cidr_block = var.private_subnet_cidr_block
    compartment_id = var.compartment_id
    vcn_id = oci_core_vcn.psql_vcn_tf.id

    display_name = var.private_subnet_display_name
    route_table_id = oci_core_route_table.tf_private_route_table.id
    prohibit_internet_ingress = true
    security_list_ids = [oci_core_security_list.tf_private_security_list.id]
}

resource oci_core_internet_gateway vcntf_igw {
  vcn_id       = oci_core_vcn.psql_vcn_tf.id
  compartment_id = var.compartment_id
  display_name = var.internet_gateway_name
}

resource oci_core_nat_gateway tf_nat_gateway {
  vcn_id       = oci_core_vcn.psql_vcn_tf.id
  compartment_id = var.compartment_id
  display_name = example-ngw
  # Add route tables to direct traffic through this NAT gateway
}

data oci_core_services test_services {
}

variable create_service_gateway {
  description = whether to create a service gateway. If set to true, creates a service gateway.
  default     = true
  type        = bool
}

data oci_core_services all_oci_services {
  filter {
    name   = name
    values = [All .* Services In Oracle Services Network]
    regex  = true
  }
  count = var.create_service_gateway == true ? 1 : 0
}

resource oci_core_service_gateway service_gateway {
  compartment_id = var.compartment_id
  display_name   = var.service_gateway_displayname
  services {
    service_id = lookup(data.oci_core_services.all_oci_services[0].services[0], id)
  }
  vcn_id = oci_core_vcn.psql_vcn_tf.id
  count = var.create_service_gateway == true ? 1 : 0
}

resource oci_core_security_list tf_public_security_list {
  vcn_id         = oci_core_vcn.psql_vcn_tf.id
  compartment_id = var.compartment_id
  display_name   = var.public_subnet_security_list_display_name

  ingress_security_rules {
    protocol    = 6  # TCP protocol for SSH
    source      = 0.0.0.0/0  # Allow inbound traffic from all sources
    tcp_options {
            #Optional
            max = 22
            min = 22
        }
    description = Allow SSH from all sources
  }
}

resource oci_core_security_list tf_private_security_list {
  vcn_id         = oci_core_vcn.psql_vcn_tf.id
  compartment_id = var.compartment_id
  display_name   = var.private_subnet_security_list_disply_name

  ingress_security_rules {
    protocol    = 6  # TCP protocol to connect Postgress service from compute instance in public subnet
    source      = oci_core_vcn.psql_vcn_tf.cidr_block  # Allow inbound traffic from CIDR Block of VCN sources
    tcp_options {
            #Optional
            max = 5432
            min = 5432
        }
    description = Allow psql service connections from all ranges cidr vcn
  }
}

resource oci_core_route_table tf_public_route_table {
  vcn_id     = oci_core_vcn.psql_vcn_tf.id
  compartment_id = var.compartment_id
  display_name = var.public_subnet_route_table_display_name
  route_rules {
    // Define route rules for public subnet
    network_entity_id = oci_core_internet_gateway.vcntf_igw.id
    destination = 0.0.0.0/0
    destination_type = CIDR_BLOCK
  }
}

resource oci_core_route_table tf_private_route_table {
  vcn_id     = oci_core_vcn.psql_vcn_tf.id
  compartment_id = var.compartment_id
  display_name = var.private_subnet_route_table_display_name
  route_rules {
    // Define route rules for private subnet
    network_entity_id = oci_core_nat_gateway.tf_nat_gateway.id
    destination = 0.0.0.0/0
    destination_type = CIDR_BLOCK
  }
  route_rules {
    network_entity_id = oci_core_service_gateway.service_gateway.0.id
    destination = all-iad-services-in-oracle-services-network
    destination_type  = SERVICE_CIDR_BLOCK
  }
  }

resource oci_core_route_table_attachment public_route_table_attachment {
  #Required
  subnet_id = oci_core_subnet.public_subnet.id
  route_table_id =oci_core_route_table.tf_public_route_table.id
}

resource oci_core_route_table_attachment private_route_table_attachment {
  #Required
  subnet_id = oci_core_subnet.private_subnet.id
  route_table_id =oci_core_route_table.tf_private_route_table.id
  depends_on = [oci_core_service_gateway.service_gateway]
}

Créez le script instance.tf.

Pour accéder à la base de données PostgreSQL, nous avons besoin d'une instance de calcul dans le sous-réseau public. Nous nous connecterons à l'instance, puis accéderons à PostgreSQL car il est accessible uniquement via le sous-réseau privé. Pour ce faire, créez un fichier nommé instance.tf à l'aide du code suivant. Vous pouvez facilement mettre à jour les valeurs de variable de calcul dans le fichier variables.tf ultérieurement.

# Resources
data "oci_identity_availability_domains" "ads" {
  compartment_id = var.compartment_id
}

resource "oci_core_instance" "tf_compute" {
  # Required
  availability_domain = data.oci_identity_availability_domains.ads.availability_domains[0].name
  compartment_id      = var.compartment_id
  shape               = var.compute_shape
  source_details {
    source_id         = var.source_operating_system_image_id
    source_type       = "image"
  }
  display_name        = var.compute_instance_display_name
  shape_config {
    ocpus         = var.compute_cpus
    memory_in_gbs = var.compute_memory_in_gbs
  }
  create_vnic_details {
    subnet_id = oci_core_subnet.public_subnet.id
    assign_public_ip  = true
  }
  metadata = {
    ssh_authorized_keys = file(var.compute_ssh_authorized_keys)
  }
  preserve_boot_volume = false
  provisioner "remote-exec" {
    inline = [
      "sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm",
      "sudo dnf -qy module disable postgresql",
      "sudo dnf install -y postgresql16-server",
      "sudo /usr/pgsql-16/bin/postgresql-16-setup initdb",
      "sudo systemctl enable postgresql-16",
      "sudo systemctl start postgresql-16"
    ]
    connection {
      type        = "ssh"
      host        = self.public_ip
      user        = "opc"
      private_key = file(var.api_private_key_for_ssh)
    }
  }

}

# Outputs
output "compute_id" {
  value = oci_core_instance.tf_compute.id
}

output "compute_state" {
  value = oci_core_instance.tf_compute.state
}

output "compute_public_ip" {
  value = oci_core_instance.tf_compute.public_ip
}

Créez le script postgresql.tf.

Configurez le système de base de données OCI PostgreSQL en ajoutant le code Terraform dans un fichier nommé postgresql.tf. Ce code détaille la configuration du système, y compris la forme, les coeurs et les noeuds. Pour une configuration optimisée, envisagez un système de base de données à trois noeuds : un noeud principal et deux répliques dans différentes zones de disponibilité. Commencez par créer le fichier postgresql.tf et insérer le code fourni. Vous pouvez facilement ajouter les valeurs de variable de la base de données PostgreSQL dans le fichier variables.tf pour répondre à vos besoins spécifiques.

resource "oci_psql_db_system" "test_db_system" {
    #Required
    compartment_id = var.compartment_id
    db_version = var.db_system_db_version
    display_name = var.db_system_display_name
    network_details {
        #Required
        subnet_id = oci_core_subnet.private_subnet.id
    }
    shape = var.db_system_shape
    storage_details {
        #Required
        is_regionally_durable = var.db_system_storage_details_is_regionally_durable
        system_type = var.db_system_storage_details_system_type
        #Optional
        # availability_domain = var.db_system_storage_details_availability_domain
        # iops = var.db_system_storage_details_iops
    }
    credentials {
        #Required
        password_details {
            #Required
            password_type = var.db_system_credentials_password_details_password_type
            #Optional
            password = var.db_system_credentials_password_details_password
        }
        username = var.db_system_credentials_username
    }
    instance_count = var.db_system_instance_count
    instance_memory_size_in_gbs = var.db_system_instance_memory_size_in_gbs
    instance_ocpu_count = var.db_system_instance_ocpu_count

}

Créez le script variables.tf.

Dans cette section, l'utilisateur doit ajuster et mettre à jour les valeurs des ressources à créer dans sa location OCI. Créez un fichier variables.tf et ajoutez le code suivant. N'oubliez pas qu'il s'agit du fichier final à créer dans le même dossier. Examinez et modifiez soigneusement chaque variable en fonction de vos besoins. Certaines valeurs seront préremplies dans la section "valeur" de chaque code, tandis que d'autres, spécifiques à vos besoins, nécessiteront votre saisie. Une fois que toutes les valeurs ont été ajoutées ou modifiées dans le fichier, passez à la phase d'exécution.

# Provider identity parameters - Replace these values from API Key Values from OCI User

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

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

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

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

variable "region" {
  description = "OCI region where resources will be created for Requestor Tenancy"
  type        = string
  default     = "us-ashburn-1"  # example value
  # check this document, if you want to use different region - https://docs.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm#About
}


# compartment OCID - Replace these values

variable "compartment_id" {
  description = "Compartment ID where to create resources for Requestor Tenancy"
  type        = string
  default     = ""
}

variable "db_system_db_version" {
  description = "Version"
  type = number
  default = 14
}

variable "db_system_display_name" {
  description = "postgress db service name"
  type = string
  default = "psqlfromterraform" # example value
}


variable "db_system_shape" {
    description = "shape"
    type = string
    default = "PostgreSQL.VM.Standard.E4.Flex.4.64GB"  # example value
    #change the shape value as per your requirements
}

variable "db_system_instance_count" {
  description = "instance count"
  type = number
  default = 3  # example value
}

variable "db_system_instance_memory_size_in_gbs" {
  description = "RAM"
  type = number
  default = 64  # example value
}

variable "db_system_instance_ocpu_count" {
  description = "OCPU count"
  type = number
  default = 4  # example value
}

variable "db_system_storage_details_is_regionally_durable" {
  description = "regional"
  type = bool
  default = true
}
variable "db_system_credentials_password_details_password_type" {
    description = "type"
    type = string
    default = "PLAIN_TEXT"

}

variable "db_system_credentials_password_details_password" {
  description = "password"
  type = string
  default = ""
}

variable "db_system_credentials_username" {
  description = "username"
  type = string
  default = "admin" # example value
}

variable "db_system_storage_details_system_type" {
  description = "type"
  type = string
  default = "OCI_OPTIMIZED_STORAGE"
}



# OCI VCN parameters - psql instance deployed on this

variable "vcn_cidr_block" {
  description = "vcn cidr"
  type = string
  default = "172.16.0.0/16" # example value
}

variable "vcn_display_name" {
  description = "vcn name"
  type = string
  default = "vcn-from-tf-psql" # example value
}

variable "public_subnet_cidr_block" {
    description = "subnet cidr range"
    type = string
    default = "172.16.1.0/24" # example value
}

variable "private_subnet_cidr_block" {
    description = "subnet cidr range"
    type = string
    default = "172.16.2.0/24" # example value
}

variable "public_subnet_display_name" {
  description = "public subnet name"
  type = string
  default = "public-subnet" # example value

}

variable "private_subnet_display_name" {
  description = "public subnet name"
  type = string
  default = "private-subnet" # example value

}

variable "internet_gateway_name" {
  description = "internet gateway name"
  type = string
  default = "internetgateway" # example value
}

variable "service_gateway_displayname" {
  description = "Service Gateway Display Name"
  type = string
  default = "servicegateway" # example value
}

variable "public_subnet_security_list_display_name" {
  description = "Public Subnet Security List Display Name"
  type = string
  default = "public_subnet_security_list" # example value
}

variable "private_subnet_security_list_display_name" {
  description = "Public Subnet Security List Display Name"
  type = string
  default = "public_subnet_security_list" # example value
}

variable "public_subnet_route_table_display_name" {
  description = "Public Subnet Route table Display Name"
  type = string
  default = "public_subnet_route_table" # example value
}

variable "private_subnet_route_table_display_name" {
  description = "Public Subnet Route table Display Name"
  type = string
  default = "private_subnet_route_table" # example value
}


# OCI Compute Instance parameters - We will use this instance to connect postgreSQL db instance

variable "compute_shape" {
  type    = string
  default = "VM.Standard.E4.Flex" # example value
}

variable "compute_cpus" {
  type    = string
  default = "1" # example value
}

variable "compute_memory_in_gbs" {
  type    = string
  default = "1" # example value
}

variable "compute_ssh_authorized_keys" {
  type = string
  default = ""
}

variable "api_private_key_for_ssh" {
  type = string
  default = ""
}

variable "source_operating_system_image_id" {
  description = "Oracle Linux 8 image ocid"
  type = string
  default = "ocid1.image.oc1.iad.aaaaaaaaszr5wpipg6qskiol3fhbitm56qdmumpbcpv6irzxuofi2nfmlhma" # example value
  # if you change the region , then change the default value from the region you have selected from this document -https://docs.oracle.com/en-us/iaas/images/image/998f1273-d4fd-4e16-8673-dd2517ddd724/
}

variable "compute_instance_display_name" {
  description = "display name of the compute name"
  type = string
  default = ""
}

Après avoir créé les fichiers requis et ajusté le fichier variables.tf avec les valeurs nécessaires, votre structure de dossiers reflétera la configuration affichée dans la capture d'écran suivante.

tf-dossier

Tâche 2 : exécution des scripts Terraform

A l'aide de votre terminal ou de l'invite de commande, exécutez les commandes suivantes pour initialiser Terraform et créer des ressources dans votre location OCI. Ces commandes initialisent Terraform et déploient les ressources indiquées dans votre location OCI.

terraform init

terraform plan

terraform apply

postgreSQLdb_oci_console

Tâche 3 : connexion à la base de données OCI PostgreSQL

Une fois terminé, accédez à la console OCI pour localiser OCI PostgreSQL et une instance de calcul préchargée avec le client psql. Accédez à l'instance de calcul via SSH à l'aide de son adresse IP publique, puis exécutez la commande fournie pour établir une connexion avec le système de base de données OCI PostgreSQL (le port SSH 22 et le port de base de données 5432 sont créés automatiquement via le script vcn.tf ; aucune action n'est nécessaire pour la gestion des ports). Mettez à jour l'adresse IP de l'adresse privée, accessible à partir de la console de base de données OCI PostgreSQL, ainsi que le nom utilisateur et le mot de passe indiqués dans le fichier variable.tf. Une fois la commande exécutée, le système vous invite à saisir le mot de passe de connexion.

psql --version
psql -h endpoint_ip -U admin_username -d postgres

Après l'exécution des commandes ci-dessus, les utilisateurs doivent pouvoir voir la connexion établie à la base de données PostgreSQL gérée.

psqldb_access_from_instance

L'utilisateur a déployé trois noeuds de la base de données PostgreSQL gérée par OCI et les a connectés en privé à l'aide d'une instance de calcul.

Remerciements

Auteur - Akarsha I K (Architecte cloud)

Ressources de formation supplémentaires

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

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

Informations relatives au titre et au copyright

Deploy OCI Managed Database with PostgreSQL Service using Terraform

F91015-01

January 2024