Gérer Auth0 avec Terraform : configuration as code complète

Le provider Terraform Auth0 permet de gérer tout votre tenant en code versionné : applications, connexions, rôles, actions et email templates.

Par Auth0.Expert · 2025-03-18 · 11 min de lecture

Terraform Infrastructure as Code DevOps

Auth0 avec Terraform : guide complet

TL;DR

Le provider Terraform auth0/auth0 permet de gérer votre tenant Auth0 entièrement en code. Versionnez votre configuration IAM, automatisez les déploiements et détectez les drifts.

---

Setup : provider Auth0

Ce premier bloc montre comment initialiser le provider Terraform Auth0, pour permettre à Terraform d'interagir avec votre tenant Auth0 de façon sécurisée.

# providers.tf
terraform {
  required_providers {
    auth0 = {
      source  = "auth0/auth0"
      version = "~> 1.0"
    }
  }
}

provider "auth0" {
  domain        = var.auth0_domain
  client_id     = var.auth0_client_id
  client_secret = var.auth0_client_secret
}

# Variables
variable "auth0_domain"        { type = string }
variable "auth0_client_id"     { type = string }
variable "auth0_client_secret" {
  type      = string
  sensitive = true
}

---

Application (SPA)

Cette ressource configure une application SPA dans Auth0. Elle définit ses callbacks, ses origines, ses types de tokens autorisés et la politique de rotation des refresh tokens pour renforcer la sécurité.

# applications.tf
resource "auth0_client" "spa_app" {
  name            = "YourApp Frontend"
  app_type        = "spa"
  oidc_conformant = true

  callbacks = [
    "https://yourapp.com/callback",
    "http://localhost:3000/callback",
  ]
  allowed_logout_urls = [
    "https://yourapp.com",
    "http://localhost:3000",
  ]
  web_origins = [
    "https://yourapp.com",
    "http://localhost:3000",
  ]

  grant_types = ["authorization_code", "refresh_token"]

  jwt_configuration {
    alg = "RS256"
  }

  refresh_token {
    rotation_type   = "rotating"
    expiration_type = "expiring"
    token_lifetime  = 2592000  # 30 jours
    idle_token_lifetime = 1296000  # 15 jours
    leeway = 3
    infinite_idle_token_lifetime = false
    infinite_token_lifetime      = false
  }
}

Ce bloc crée une application front-end sécurisée avec gestion avancée des refresh tokens et OIDC.

---

Resource Server (API)

Cette ressource définit un "Resource Server", c’est-à-dire l’API à protéger avec Auth0. Elle configure la durée de vie des tokens, la gestion des scopes et l’algorithme de signature.

resource "auth0_resource_server" "main_api" {
  name       = "Main API"
  identifier = "https://api.yourapp.com"

  signing_alg                 = "RS256"
  token_lifetime              = 86400
  skip_consent_for_verifiable_first_party_clients = true
  enforce_policies            = true
  token_dialect               = "access_token_authz"

  scopes {
    value       = "read:posts"
    description = "Lire les articles"
  }
  scopes {
    value       = "write:posts"
    description = "Créer et modifier des articles"
  }
  scopes {
    value       = "delete:posts"
    description = "Supprimer des articles"
  }
  scopes {
    value       = "admin:all"
    description = "Accès administrateur complet"
  }
}

Ce code configure les permissions de votre API pour une gestion fine de l'accès selon les scopes.

---

Connexion sociale (Google)

Ici, nous intégrons une connexion Google OAuth2 et une connexion classique email/mot de passe pour permettre différents modes d'authentification à l’application.

resource "auth0_connection" "google" {
  name     = "google-oauth2"
  strategy = "google-oauth2"

  options {
    client_id     = var.google_client_id
    client_secret = var.google_client_secret
    scopes        = ["email", "profile"]
    set_user_root_attributes = "on_each_login"
  }

  enabled_clients = [auth0_client.spa_app.client_id]
}

resource "auth0_connection" "email_password" {
  name     = "Username-Password-Authentication"
  strategy = "auth0"

  options {
    password_policy = "excellent"
    password_history {
      enable = true
      size   = 5
    }
    password_no_personal_info { enable = true }
    password_dictionary { enable = true }
    brute_force_protection = true
    requires_username      = false
  }

  enabled_clients = [auth0_client.spa_app.client_id]
}

Ce bloc offre l’accès par Google ou par email avec une sécurité renforcée côté mot de passe.

---

Rôles et permissions

Cette section gère les rôles (RBAC) et leurs permissions associées, pour contrôler finement qui peut accéder à quelles ressources sur l’API.

resource "auth0_role" "admin" {
  name        = "admin"
  description = "Administrateur complet"
}

resource "auth0_role" "editor" {
  name        = "editor"
  description = "Peut lire et écrire des articles"
}

resource "auth0_role_permissions" "editor_permissions" {
  role_id = auth0_role.editor.id

  permissions {
    resource_server_identifier = auth0_resource_server.main_api.identifier
    name                       = "read:posts"
  }
  permissions {
    resource_server_identifier = auth0_resource_server.main_api.identifier
    name                       = "write:posts"
  }
}

Ce code définit des rôles et leurs droits, pour une gestion des accès personnalisée sur votre API.

---

Action Post Login

Cette ressource déploie une Action Auth0 déclenchée après login, pour enrichir le token ou effectuer des appels externes grâce à des secrets et des dépendances.

resource "auth0_action" "post_login_enrich" {
  name    = "Post Login - Enrich Token"
  runtime = "node18"
  deploy  = true

  code = file("${path.module}/actions/post_login_enrich.js")

  supported_triggers {
    id      = "post-login"
    version = "v3"
  }

  dependencies {
    name    = "axios"
    version = "1.6.7"
  }

  secrets {
    name  = "STRIPE_SECRET_KEY"
    value = var.stripe_secret_key
  }
}

resource "auth0_trigger_actions" "post_login" {
  trigger = "post-login"

  actions {
    id           = auth0_action.post_login_enrich.id
    display_name = auth0_action.post_login_enrich.name
  }
}

Cette configuration automatise un enrichissement des tokens après authentification, avec accès à des secrets et des librairies externes.

---

Multi-environnements avec Terraform Workspaces

Cette section montre comment gérer plusieurs environnements (dev, staging, prod) avec Terraform workspaces pour isoler vos configurations Auth0.

# Structure des workspaces
terraform workspace new dev
terraform workspace new staging
terraform workspace new prod

# Variables par workspace (terraform.tfvars)
# dev.tfvars
auth0_domain = "myapp-dev.eu.auth0.com"

# prod.tfvars
auth0_domain = "myapp.eu.auth0.com"

Ce bloc permet d’adapter les variables selon l’environnement cible.

# Conditional selon l'environnement
locals {
  env = terraform.workspace
  is_prod = local.env == "prod"
}

resource "auth0_client" "spa_app" {
  callbacks = local.is_prod
    ? ["https://yourapp.com/callback"]
    : ["http://localhost:3000/callback", "https://${local.env}.yourapp.com/callback"]
}

Grâce à cette logique conditionnelle, vous pouvez personnaliser vos endpoints selon l'environnement.

---

Import de la configuration existante

Cette partie explique comment importer des ressources Auth0 déjà existantes dans votre état Terraform, pour unifier la gestion infrastructure-as-code.

# Importer un client Auth0 existant dans Terraform
terraform import auth0_client.spa_app CLIENT_ID

# Importer une connexion existante
terraform import auth0_connection.google CONNECTION_ID

# Générer la config depuis l'existant
terraform plan -generate-config-out=generated.tf

Importer vos configurations existantes accélère la migration vers une gestion centralisée IAM avec Terraform.

---

> 🔧 Migration Auth0 vers Terraform : nous importons votre configuration Auth0 existante dans Terraform et mettons en place un pipeline CI/CD pour tous vos tenants.

📧 [email protected]

Autres articles