> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Référence Terraform pour ClickHouse Managed Postgres

> Référence pour gérer les services ClickHouse Managed Postgres avec le fournisseur Terraform de ClickHouse.

export const galaxyOnClick = eventName => () => {
  try {
    if (typeof window !== "undefined" && window.galaxy && eventName) {
      window.galaxy.track(eventName, {
        interaction: "click"
      });
    }
  } catch (e) {}
};

export const BetaBadge = ({link, galaxyTrack, galaxyEvent}) => {
  if (link) {
    return <a href={link} target="_blank" rel="noopener noreferrer" className="betaBadge" onClick={galaxyTrack && galaxyEvent ? galaxyOnClick(galaxyEvent) : undefined}>
                <Icon />
                <span>Beta</span>
            </a>;
  }
  return <div className="betaBadge">
            <Icon />
            <span>
                Fonctionnalité en bêta. 
                <u>
                    <a href="/docs/beta-and-experimental-features#beta-features">
                        En savoir plus.
                    </a>
                </u>
            </span>
        </div>;
};

Les services ClickHouse Managed Postgres peuvent être créés et gérés à l’aide de la ressource `clickhouse_postgres_service` du [fournisseur Terraform ClickHouse](https://registry.terraform.io/providers/ClickHouse/clickhouse/latest/docs/resources/postgres_service). Cette page présente la configuration du fournisseur ainsi que des exemples de configuration pour cette ressource et les sources de données associées.

<Note>
  Cette ressource est en alpha et son comportement peut évoluer dans les prochaines versions du fournisseur. Elle est incluse dans le build standard du fournisseur et disponible à partir de la version **v3.17.1** du fournisseur — consultez les [releases du fournisseur](https://github.com/ClickHouse/terraform-provider-clickhouse/releases) pour plus de détails.
</Note>

<div id="provider-setup">
  ## Configuration du fournisseur
</div>

Ajoutez le fournisseur ClickHouse à votre configuration Terraform :

```hcl theme={null}
terraform {
  required_providers {
    clickhouse = {
      source  = "ClickHouse/clickhouse"
      version = ">= 3.17.1"
    }
  }
}

provider "clickhouse" {
  organization_id = var.organization_id
  token_key       = var.token_key
  token_secret    = var.token_secret
}
```

Consultez [Gérer les clés API](/fr/products/cloud/features/admin-features/api/openapi) pour savoir comment créer une clé API à utiliser avec le fournisseur.

<div id="resource-overview">
  ## Aperçu de la ressource
</div>

La ressource `clickhouse_postgres_service` accepte les arguments suivants :

| Argument                   | Requis                     | Description                                                                                                                                                                                                |
| -------------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`                     | Oui                        | Nom du service lisible par un humain. Immuable — le modifier détruit et recrée le service.                                                                                                                 |
| `cloud_provider`           | Pour une création standard | Fournisseur Cloud hébergeant l’instance. Actuellement, seul `aws` est pris en charge. À omettre pour une réplique de lecture ou une restauration à un instant donné (hérité de la source).                 |
| `region`                   | Pour une création standard | Région Cloud (par exemple, `us-east-1`). À omettre pour une réplique de lecture ou une restauration à un instant donné (hérité de la source).                                                              |
| `size`                     | Pour une création standard | Taille de l’instance (SKU de VM), par exemple `m6gd.large`. Redimensionnable sur place. À omettre pour une restauration à un instant donné (l’instance restaurée démarre avec la taille de la sauvegarde). |
| `postgres_version`         | Non                        | Version majeure de Postgres (par exemple, `18`). Modifier la version majeure détruit et recrée le service.                                                                                                 |
| `ha_type`                  | Non                        | Mode de haute disponibilité : `none`, `async` ou `sync`. Voir [Haute disponibilité](#high-availability).                                                                                                   |
| `password`                 | Non                        | Mot de passe du superutilisateur. Omettez-le pour que le serveur en génère un. Stocké dans l’état (sensible).                                                                                              |
| `pg_config`                | Non                        | Paramètres du serveur Postgres sous forme de mappage clé-valeur.                                                                                                                                           |
| `pgbouncer_config`         | Non                        | Paramètres du pooler de connexions PgBouncer sous forme de mappage clé-valeur.                                                                                                                             |
| `tags`                     | Non                        | Tags de la ressource sous forme de mappage clé-valeur.                                                                                                                                                     |
| `read_replica_of`          | Non                        | ID d’un service principal à répliquer. Voir [Répliques de lecture](#read-replicas). Mutuellement exclusif avec `restore_to_point_in_time`.                                                                 |
| `restore_to_point_in_time` | Non                        | Crée le service en restaurant un autre service à un instant donné. Voir [Restauration à un instant donné](#point-in-time-restore). Mutuellement exclusif avec `read_replica_of`.                           |

Les attributs suivants sont en lecture seule et sont renseignés par ClickHouse Cloud après la création : `id`, `state`, `created_at`, `is_primary`, `hostname`, `port`, `username` et `connection_string` (sensible).

<Warning>
  Le `password` est stocké en texte brut dans votre état Terraform. Protégez votre fichier d’état en conséquence — par exemple, utilisez un backend distant avec chiffrement au repos. Si vous omettez `password`, le serveur en génère un et le fournisseur le relit dans l’état à chaque actualisation.
</Warning>

<div id="create-a-service">
  ## Créer un service
</div>

```hcl theme={null}
resource "clickhouse_postgres_service" "example" {
  name           = "my-postgres"
  cloud_provider = "aws"
  region         = "us-east-1"
  size           = "m6gd.large"

  # High-availability mode — number of standby replicas:
  #   "none"  – primary only, no standby (default)
  #   "async" – 1 standby, asynchronous replication
  #   "sync"  – 2 standbys, synchronous replication
  ha_type = "async"

  tags = {
    environment = "production"
    team        = "data"
  }
}
```

Pour gérer vous-même le mot de passe, définissez `password` — il doit contenir au moins 12 caractères, dont au moins une lettre minuscule, une lettre majuscule et un chiffre. Si vous l’omettez, le serveur en génère un.

<div id="high-availability">
  ## Haute disponibilité
</div>

L’argument `ha_type` détermine le nombre de répliques de secours :

| `ha_type` | Instances de secours         | Réplication                                                                                      |
| --------- | ---------------------------- | ------------------------------------------------------------------------------------------------ |
| `none`    | Aucune (primaire uniquement) | —                                                                                                |
| `async`   | 1 instance de secours        | Asynchrone — les écritures sont validées sans attendre l’instance de secours                     |
| `sync`    | 2 instances de secours       | Synchrone — l’instance primaire attend un accusé de réception d’au moins une instance de secours |

`ha_type` peut être modifié après la création ; le changer déclenche une transition de haute disponibilité. Voir [Haute disponibilité](/fr/products/managed-postgres/high-availability) pour plus de détails.

<div id="read-replicas">
  ## Répliques de lecture
</div>

Définissez `read_replica_of` sur l’`id` d’un service principal pour créer une réplique de lecture en streaming. Une réplique hérite du `cloud_provider`, de la `région`, de la `postgres_version` et du superutilisateur du principal — ne les indiquez donc pas (ni le `password`) :

```hcl theme={null}
resource "clickhouse_postgres_service" "replica" {
  name            = "my-postgres-replica"
  size            = "m6gd.large"
  read_replica_of = clickhouse_postgres_service.example.id
}
```

Consultez [les répliques en lecture](/fr/products/managed-postgres/read-replicas) pour en savoir plus.

<div id="point-in-time-restore">
  ## Restauration à un instant donné
</div>

Définissez `restore_to_point_in_time` pour créer un service en restaurant la sauvegarde d'un autre service à un instant donné. `cloud_provider`, `region` et `postgres_version` sont hérités du service source (ne les indiquez pas) ; `size` et `ha_type` doivent être omis :

```hcl theme={null}
resource "clickhouse_postgres_service" "restored" {
  name = "my-postgres-restored"

  restore_to_point_in_time = {
    source_id      = clickhouse_postgres_service.example.id
    restore_target = "2026-06-01T12:00:00Z"
  }
}
```

L’ensemble du bloc s’applique uniquement à la création : modifier `source_id` ou `restore_target`, ou supprimer le bloc, détruit puis recrée le service. Consultez [Sauvegarde et restauration](/fr/products/managed-postgres/backup-and-restore) pour plus de détails.

<div id="data-sources">
  ## Sources de données
</div>

Trois sources de données associées vous permettent de retrouver des services existants :

```hcl theme={null}
# A single service by ID.
data "clickhouse_postgres_service" "example" {
  id = clickhouse_postgres_service.example.id
}

# All Managed Postgres services in the organization.
data "clickhouse_postgres_services" "all" {}

# The CA certificates for a service, for TLS connections.
data "clickhouse_postgres_service_ca_certificates" "certs" {
  service_id = clickhouse_postgres_service.example.id
}
```

<div id="importing-existing-services">
  ## Importation de services existants
</div>

Les services Managed Postgres existants peuvent être importés dans l’état Terraform à l’aide de l’ID du service. Le mot de passe est restauré lors de l’importation — le serveur le renvoie via `GET` :

```bash theme={null}
terraform import clickhouse_postgres_service.example xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

<div id="unsupported-operations">
  ## Opérations non prises en charge
</div>

Les éléments suivants sont volontairement absents du schéma de ressource :

* Commandes opérationnelles (`restart`, `promote`, `switchover`).
* Listes d’autorisation d’IP, points de terminaison privés, configuration des sauvegardes, fenêtres de maintenance, clés de chiffrement gérées par le client et BYOC.
* Délais d’expiration du cycle de vie configurables — il n’existe pas de bloc `timeouts {}`.