Getting Started with Cloud Databases via Terraform

Learn how to order a PostgreSQL instance of a managed Cloud Database service using Terraform.

Managed Databases (also called Cloud Databases) allow you to focus on building and deploying cloud applications while OVHcloud takes care of the database infrastructure and maintenance.

Requirements

• Terraform >= 0.17.1 installed
• access to the OVHcloud API (create your credentials by consulting this guide)
• a Public Cloud project in your OVHcloud account

Instructions

Step 1: Gather the OVHcloud required parameters

Getting your cluster/API tokens information

The "OVH provider" needs to be configured with a set of credentials:

• an application_key
• an application_secret
• a consumer_key

Why?

Because, behind the scenes, the "OVH Terraform provider" is doing requests to OVHcloud APIs.

To retrieve this necessary information, please follow our First Steps with the OVHcloud API tutorial.

Specifically, you have to generate these credentials via the OVHcloud token generation page with the following rights:

When you have successfully generated your OVHcloud tokens, please save them as you will have to use them very soon.

The last needed information is the service_name: it is the ID of your Public Cloud project.

How to get it?

In the Public Cloud section, you can retrieve your service name ID thanks to the Copy to clipboard button.

You will also use this information in Terraform resources definition files.

Step 2: Gather the set of required parameters

To create a new PostgreSQL cluster, you will need to specify at least:

• the version (e.g. "15")
• the region (e.g. "US-EAST-VA")
• the plan (e.g. "business")
• the flavor of the cluster (e.g. "db1-7")

Step 3: Create Terraform files

First, create a main.tf file defining the resources that will be created

terraform {
  required_providers {
    ovh = {
      source  = "ovh/ovh"
      version = "0.22"
    }
  }

  required_version = ">= 0.17.1"
}

provider "ovh" {
  endpoint           = var.ovh.endpoint
  application_key    = var.ovh.application_key
  application_secret = var.ovh.application_secret
  consumer_key       = var.ovh.consumer_key
}

resource "ovh_cloud_project_database" "service" {
  service_name = var.product.project_id
  description  = var.product.name
  engine       = "postgresql"
  version      = var.product.version
  plan         = var.product.plan
  nodes {
    region = var.product.region
  }
  flavor = var.product.flavor
}

resource "ovh_cloud_project_database_postgresql_user" "dbuser" {
  service_name = ovh_cloud_project_database.service.service_name
  cluster_id   = ovh_cloud_project_database.service.id
  name         = var.access.name
}

resource "ovh_cloud_project_database_ip_restriction" "iprestriction" {
  service_name = ovh_cloud_project_database.service.service_name
  engine       = ovh_cloud_project_database.service.engine
  cluster_id   = ovh_cloud_project_database.service.id
  ip           = var.access.ip
}

Then, create a variables.tf file defining the variables used in main.tf:

variable "ovh" {
  type = map(string)
  default = {
    endpoint           = "ovh-us"
    application_key    = ""
    application_secret = ""
    consumer_key       = ""
  }
}

variable "product" {
  type = map(string)
  default = {
    name       = "postgresql-terraform"
    project_id = ""
    region     = "US-EAST-VA"
    plan       = "business"
    flavor     = "db1-7"
    version    = "15"
  }
}

variable "access" {
  type = map(string)
  default = {
    name = "new_user"
    ip = "xx.xx.xx.xx/32"
  }
}

Here, we defined the ovh-us endpoint because we want to call the OVHcloud US API.

Then, create a secrets.tfvars file containing the required variables values:

ovh = {
  endpoint           = "ovh-us"
  application_key    = "<application_key>"
  application_secret = "<application_secret>"
  consumer_key       = "<consumer_key>"
}

product = {
  project_id = "<service_name>"
  name       = "postgresql-terraform"
  region     = "US-EAST-VA"
  plan       = "business"
  flavor     = "db1-7"
  version    = "15"
}

access = {
  name = "new_usert"
  ip = "<ip_range>"
}

Finally, create an outputs.tf file defining the resources that will be exported:

output "cluster_uri" {
  value = ovh_cloud_project_database.service.endpoints.0.uri
}

output "user_name" {
  value = postgresql.dbuser.name
}

output "user_password" {
  value     = ovh_cloud_project_database_postgresql_user.dbuser.password
  sensitive = true
}

Step 4: Run

Now we need to initialize Terraform, generate a plan, and apply it.

$ terraform init

The init command will initialize your working directory which contains .tf configuration files.

It’s the first command to execute for a new configuration, or after doing a checkout of an existing configuration in a given git repository for example.

The init command will:

• Download and install Terraform providers/plugins
• Initialize backend (if defined)
• Download and install modules (if defined)

Now, we can generate our plan:

$ terraform plan -var-file=secrets.tfvars

Thanks to the plan command, we can check what Terraform wants to create, modify, or remove.

The plan is OK for us, so let's apply it:

$ terraform apply -var-file=secrets.tfvars -auto-approve

Finally, export the user credentials and the URI.

export PASSWORD=$(terraform output -raw user_password)
export USER=$(terraform output -raw user_name)
export URI=$(terraform output -raw cluster_uri)

How to deploy with other engines

In this guide, we explained how to deploy a PostgreSQL service but you can find examples for other database engines here and tweak them according to your needs :

• MySQL
• Kafka
• Cassandra

Go further

For more information and tutorials, please see our other Cloud Databases support guides or explore the guides for other OVHcloud products and services.