Blog
Qovery
Terraform
Product
6
minutes

The Qovery Terraform Provider is Available Now

Big news! The Qovery Terraform Provider is now publicly available for everyone! This article will show you what you can do and why you should consider using Terraform with Qovery.
January 27, 2026
Romaric Philogène
CEO & Co-founder
Summary
Twitter icon
linkedin icon

What is Terraform

Terraform is an open-source infrastructure as code software tool created by HashiCorp. Thousands of products provide Terraform plugins (called providers) to manage them. Basically, you describe in a file how you want to configure your software and how you want to connect them, and Terraform manages everything for you. It is not magic. Thanks to the big Terraform community for providing and maintaining all the Terraform Providers. This is where the Qovery team provides and supports their Terraform Provider officially. Every contribution is appreciated.

Why should you use Terraform in the context of Qovery?

The main reason why using Terraform in the context of Qovery is to keep track of the changes across the configuration of your Qovery clusters, applications, and databases.

Demo

Watch our complete Terraform demo

Qovery Terraform Provider features

Create a Kubernetes cluster

AWS EKS cluster

Here is the Terraform configuration to create a Kubernetes cluster (EKS) on AWS.

terraform {
required_providers {
qovery = {
source = "qovery/qovery"
}
}
}

# Configure the Qovery provider
provider "qovery" {
token = ""
}

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

resource "qovery_aws_credentials" "my_aws_creds" {
organization_id = var.organization_id
name = "my_aws_creds"
access_key_id = ""
secret_access_key = ""
}

resource "qovery_cluster" "my_cluster" {
organization_id = var.organization_id
credentials_id = qovery_aws_credentials.my_aws_creds.id
name = "test_terraform_provider"
description = "Kubernetes cluster created with Terraform"
cloud_provider = "AWS"
region = "us-east-2"
cpu = 2000 # 2000 mCPU = 2 vCPU
memory = 4096 # 4096 MB = 4GB
min_running_nodes = 3 # min auto scaling nodes
max_running_nodes = 10 # max auto scaling nodes

depends_on = [
qovery_aws_credentials.my_aws_creds
]
}

Note: Qovery supports VPC configuration and static IPs for AWS EKS.

Scaleway Kapsule

Here is the Terraform configuration to create a Kubernetes cluster (Kapsule) on Scaleway.

terraform {
required_providers {
qovery = {
source = "qovery/qovery"
}
}
}

# Configure the Qovery provider
provider "qovery" {
token = ""
}

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

resource "qovery_scaleway_credentials" "my_scaleway_creds" {
organization_id = var.organization_id
name = "my_scaleway_creds"
scaleway_access_key = ""
scaleway_secret_key = ""
scaleway_project_id = ""
}

resource "qovery_cluster" "my_cluster" {
organization_id = var.organization_id
credentials_id = qovery_scaleway_credentials.my_scaleway_creds.id
name = "test_terraform_provider"
description = "Kubernetes cluster created with Terraform"
cloud_provider = "SCALEWAY"
region = "fr-par-1"
cpu = 2000 # 2000 mCPU = 2 vCPU
memory = 4096 # 4096 MB = 4GB
min_running_nodes = 3 # min auto scaling nodes
max_running_nodes = 10 # max auto scaling nodes

depends_on = [
qovery_scaleway_credentials.my_scaleway_creds
]
}

Digital Ocean Kubernetes

Here is the Terraform configuration to create a Kubernetes cluster on Digital Ocean.

terraform {
required_providers {
qovery = {
source = "qovery/qovery"
}
}
}

# Configure the Qovery provider
provider "qovery" {
token = ""
}

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

resource "qovery_digitalocean_credentials" "my_digitalocean_creds" {
organization_id = var.organization_id
name = "my_digitalocean_creds"
token = ""
spaces_access_id = ""
spaces_secret_key = ""
}

resource "qovery_cluster" "my_cluster" {
organization_id = var.organization_id
credentials_id = qovery_digitalocean_credentials.my_digitalocean_creds.id
name = "test_terraform_provider"
description = "Kubernetes cluster created with Terraform"
cloud_provider = "DIGITAL_OCEAN"
region = "nyc3"
cpu = 2000 # 2000 mCPU = 2 vCPU
memory = 4096 # 4096 MB = 4GB
min_running_nodes = 3 # min auto scaling nodes
max_running_nodes = 10 # max auto scaling nodes

depends_on = [
qovery_digitalocean_credentials.my_digitalocean_creds
]
}

Google Cloud Platform and Microsoft Azure?

We plan to support GCP and Azure this year. Check out our public roadmap.

Deploy an application

Here is a Terraform file to deploy an application in a Project and production Environment on my Kubernetes cluster via Qovery.

resource "qovery_project" "my_project" {
organization_id = var.organization_id
name = "MyProject"
}

resource "qovery_environment" "my_environment" {
project_id = qovery_project.my_project.id
name = "Production"

depends_on = [
qovery_project.my_project
]
}

resource "qovery_application" "my_backend_app" {
environment_id = qovery_environment.my_environment.id
name = "my backend app 1"
description = "My first app in my prod environment"
cpu = 500 # 500 mCPU = 0.5 vCPU
memory = 1024 # 1024 MB = 1GB
min_running_instances = 1 # min auto scaling app instances
max_running_instances = 3 # max auto scaling app instances
git_repository {
# you can set a private or public repository - Qovery manages it automatically for you
url = "https://github.com/evoxmusic/ShortMe-URL-Shortener"
branch = "main"
root_path = "/" change the root path for mono repositories
}

# Qovery provides a temporary domain and a TLS certificate auto-renew with CertManager
ports = [{
internal_port = 8080
external_port = 443
protocol = "HTTPS"
publicly_accessible = true
}]

depends_on = [
qovery_environment.my_environment
]
}

Qovery provides tons of options to custom your application settings. Check out the app documentation or API to see all the capabilities.

Second application within the same environment

To add a second application (you can add more) within the same environment, it is as simple as adding a "qovery_application" object with a different name.

resource "qovery_application" "my_backend_app_2" {
environment_id = qovery_environment.my_environment.id
name = "my backend app 2"
description = "My first app in my prod environment"
# ... add other params
}

Deploy a Postgres database

Qovery supports the deployment of Postgres in managed mode (with backups) and container mode (without backups). Check out the documentation to understand all the differences.

resource "qovery_database" "my_postgres" {
environment_id = qovery_environment.my_environment.id
name = "MyPostgres"
type = "POSTGRESQL"
version = "13"
mode = "CONTAINER" # and MANAGED
accessibility = "PRIVATE" # you can make your DB publicly accessible with PUBLIC
cpu = 250
memory = 256
storage = 10240 # in MB

depends_on = [
qovery_environment.my_environment
]
}

Deploy a Redis database

Here is another example with Redis

resource "qovery_database" "my_redis" {
environment_id = qovery_environment.my_environment.id
name = "MyRedis"
type = "REDIS"
version = "6"
mode = "CONTAINER" # and MANAGED
accessibility = "PRIVATE" # you can make your DB publicly accessible with PUBLIC
cpu = 250
memory = 256
storage = 10240 # in MB

depends_on = [
qovery_environment.my_environment
]
}

How to connect to a service not managed by Qovery?

Qovery's Kubernetes management platform does not limit you. You can still connect to a service not managed by Qovery with VPC peering.

What else

Check out the exhaustive documentation to see all the capabilities. If something is missing, feel free to contribute by opening a Pull Request. Our Terraform provider uses our open API and our Golang SDK.

Wrapping up

Feel free to try out our Qovery Terraform Provider yourself and share your feedback on Discord and our forum.

Share on :
Twitter icon
linkedin icon
Tired of fighting your Kubernetes platform?
Qovery provides a unified Kubernetes control plane for cluster provisioning, security, and deployments - giving you an enterprise-grade platform without the DIY overhead.
See it in action

Suggested articles

Kubernetes
 minutes
Building a single pane of glass for enterprise Kubernetes fleets

A Kubernetes single pane of glass is a centralized management layer that unifies visibility, access control, cost allocation, and policy enforcement across § cluster in an enterprise fleet for all cloud providers. It replaces the fragmented practice of switching between AWS, GCP, and Azure consoles to govern infrastructure, giving platform teams a single source of truth for multi-cloud Kubernetes operations.

Mélanie Dallé
Senior Marketing Manager
Kubernetes
 minutes
How to deploy a Docker container on Kubernetes (and why manual YAML fails at scale)

Deploying a Docker container on Kubernetes requires building an image, authenticating with a registry, writing YAML deployment manifests, configuring services, and executing kubectl commands. While necessary to understand, executing this manual workflow across thousands of clusters causes severe configuration drift. Enterprise platform teams use agentic platforms to automate the entire deployment lifecycle.

Mélanie Dallé
Senior Marketing Manager
Kubernetes
Terraform
 minutes
Managing Kubernetes deployment YAML across multi-cloud enterprise fleets

At enterprise scale, managing provider-specific Kubernetes YAML across multiple clouds creates crippling configuration drift and operational toil. By adopting an agentic Kubernetes management platform, infrastructure teams abstract cloud-specific configurations (like ingress controllers and storage classes) into a single, declarative intent that automatically reconciles across 1,000+ clusters.

Mélanie Dallé
Senior Marketing Manager
Kubernetes
Cloud
AI
FinOps
 minutes
GPU orchestration guide: How to auto-scale Kubernetes clusters and slash AI infrastructure costs

To stop GPU costs from destroying SaaS margins, teams must transition from static to consumption-based infrastructure by utilizing Karpenter for dynamic provisioning, maximizing hardware density with NVIDIA MIG, and leveraging Qovery to tie scaling directly to business metrics.

Mélanie Dallé
Senior Marketing Manager
Product
AI
Deployment
 minutes
Stop Guessing, Start Shipping. AI-Powered Deployment Troubleshooting

AI is helping developers write more code, faster than ever. But writing code is only half the story. What happens after? Building, deploying, debugging, scaling. That's where teams still lose hours.We're building Qovery for this era. Not just to deploy your code, but to make everything that comes after writing it just as fast.

Alessandro Carrano
Head of Product
AI
Developer Experience
Kubernetes
 minutes
MCP Server is the future of your team's incident’s response

Learn how to use the Model Context Protocol (MCP) to transform static runbooks into intelligent, real-time investigation tools for Kubernetes and cert-manager.

Romain Gérard
Staff Software Engineer
Compliance
Developer Experience
 minutes
Beyond the spreadsheet: Using GitOps to generate DORA-compliant audit trails.

By adopting GitOps and utilizing management platforms like Qovery, fintech teams can automatically generate DORA-compliant audit trails, transforming regulatory compliance from a manual, time-consuming chore into an automated, native byproduct of their infrastructure.

Mélanie Dallé
Senior Marketing Manager
Kubernetes
7
 minutes
Day 2 operations: an executive guide to Kubernetes operations and scale

Kubernetes success is determined by Day 2 execution, not Day 1 deployment. While migration is a bounded project, maintenance is an infinite loop that often consumes 40% of senior engineering capacity. To protect margins and velocity, enterprises must transition from manual toil to agentic automation that handles scaling, security, and cost.

Mélanie Dallé
Senior Marketing Manager

It’s time to change
the way you manage K8s

Turn Kubernetes into your strategic advantage with Qovery, automating the heavy lifting while you stay in control.