Gérer les réplicas en lecture

Ce guide vous accompagne dans la création et la gestion de réplicas en lecture pour vos projets. Les réplicas en lecture séparent les tâches en lecture seule des opérations de votre base de données de production, avec des applications allant de la mise à l'échelle horizontale aux charges de travail analytiques. Pour des informations détaillées sur l'architecture et les cas d'utilisation des réplicas en lecture, consultez Réplicas en lecture.

Comprendre les réplicas en lecture

Les réplicas en lecture vous permettent de créer un ou plusieurs computes en lecture seule pour toute branch de votre projet. Vous pouvez configurer la taille du compute allouée à chaque réplique, et les fonctionnalités de mise à l'échelle automatique et de mise à l'échelle à zéro sont prises en charge, vous offrant ainsi un contrôle sur l'utilisation du compute des répliques en lecture.

Les étapes de création, de configuration et de connexion à un réplica en lecture sont les mêmes, quel que soit votre cas d’utilisation.

Dans l'API et les SDK, un réplica en lecture est un Endpoint avec son endpoint_type défini sur ENDPOINT_TYPE_READ_ONLY.

Prise en charge des régions

Lakebase prend en charge la création de réplicas en lecture **dans la même région** que votre projet. Les réplicas en lecture interrégions ne sont pas pris en charge.

Synchronisation des paramètres de compute

Pour les réplicas en lecture Lakebase, certains paramètres Postgres ne devraient pas avoir des valeurs inférieures à votre compute primaire en lecture-écriture. Pour cette raison, les paramètres suivants sur les computes de réplique en lecture sont synchronisés avec les paramètres du compute primaire en lecture-écriture lorsque le compute de réplique en lecture est start :

• max_connections
• max_prepared_transactions
• max_locks_per_transaction
• max_wal_senders
• max_worker_processes

Aucune action de l'utilisateur n'est requise. Les paramètres sont automatiquement synchronisés lorsque vous créez un réplica en lecture. Toutefois, si vous modifiez la configuration de la taille du compute sur le compute principal en lecture-écriture, vous devez redémarrer vos computes de réplicas en lecture pour vous assurer que les paramètres restent synchronisés. Pour plus d'informations, consultez Résoudre les retards de réplication.

Créer et gérer des réplicas en lecture

Limites

• Maximum de 6 réplicas en lecture par Branch .
• Les réplicas en lecture sont inclus dans la limite de projet de **20 instances de compute actives simultanément**. Consultez les limites de projet.

Prérequis

• Un projet Lakebase. Voir Créer un projet.

Créer un réplica en lecture

Pour créer un réplica en lecture :

UI

1. Dans l'application Lakebase, accédez à votre projet, votre Branch et l'onglet Compute .
2. Cliquez sur Ajouter un réplica en lecture .
3. Saisissez un nom pour votre réplique en lecture, configurez les paramètres du compute (plage de mise à l'échelle automatique et comportement de mise à l'échelle à zéro), puis cliquez sur Ajouter .

Python SDK

Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType

w = WorkspaceClient()

# Create read replica endpoint (READ_ONLY)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_ONLY,
    autoscaling_limit_max_cu=2.0
)

endpoint = Endpoint(spec=endpoint_spec)

result = w.postgres.create_endpoint(
    parent="projects/my-project/branches/production",
    endpoint=endpoint,
    endpoint_id="my-read-replica"
).wait()

print(f"Endpoint created: {result.name}")
print(f"Host: {result.status.hosts.host}")

Java SDK

Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;

WorkspaceClient w = new WorkspaceClient();

// Create read replica endpoint (READ_ONLY)
EndpointSpec endpointSpec = new EndpointSpec()
    .setEndpointType(EndpointType.ENDPOINT_TYPE_READ_ONLY)
    .setAutoscalingLimitMaxCu(2.0);

Endpoint endpoint = new Endpoint()
    .setSpec(endpointSpec);

Endpoint result = w.postgres().createEndpoint(
    new CreateEndpointRequest()
        .setParent("projects/my-project/branches/production")
        .setEndpoint(endpoint)
        .setEndpointId("my-read-replica")
).waitForCompletion();

System.out.println("Endpoint created: " + result.getName());
System.out.println("Host: " + result.getStatus().getHosts().getHost());

CLI

Bash

# Create a read replica for a branch
databricks postgres create-endpoint projects/my-project/branches/production my-read-replica \
  --json '{
    "spec": {
      "endpoint_type": "ENDPOINT_TYPE_READ_ONLY",
      "autoscaling_limit_min_cu": 0.5,
      "autoscaling_limit_max_cu": 4.0
    }
  }'

curl

Bash

curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints?endpoint_id=my-read-replica" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "endpoint_type": "ENDPOINT_TYPE_READ_ONLY",
      "autoscaling_limit_min_cu": 0.5,
      "autoscaling_limit_max_cu": 4.0
    }
  }' | jq

remarque

La configuration de la taille du compute détermine la puissance de traitement de votre base de données. En savoir plus : Gérer les computes

Votre réplica en lecture est provisionné en quelques secondes et apparaît dans la tab Compute pour la Branch.

Afficher les réplicas en lecture

Pour afficher les répliques en lecture pour une Branch, accédez à votre projet dans l'application Lakebase, sélectionnez une Branch sur la page Branches , puis affichez l'onglet Computes où tous les computes de répliques en lecture sont répertoriés.

Connecter à une réplique en lecture

La connexion à un réplica en lecture suit le même processus que la connexion à votre compute principal en lecture-écriture, sauf que vous sélectionnez un compute de réplica en lecture lors de l'obtention de vos informations de connexion.

Pour obtenir des informations de connexion pour un réplica en lecture :

1. Dans l'application Lakebase, cliquez sur Connecter sur le tableau de bord de votre projet.
2. Sélectionnez la branch, la base de données, le rôle et le compute de réplique en lecture dans le menu déroulant Compute, puis copiez la chaîne de connexion fournie.

Vous pouvez vous connecter à l’aide d’un rôle OAuth Postgres, comme vous le feriez avec votre compute primaire en lecture-écriture.

important

Les opérations d'écriture ne sont pas autorisées sur les connexions de réplica en lecture. Toute tentative d'exécution d'Opérations d'écriture entraînera une erreur.

Pour des informations complètes sur les méthodes d'authentification et les options de connexion, consultez Connectez-vous à votre projet.

Modifier un réplica en lecture

Vous pouvez modifier un réplica en lecture pour changer la taille du compute ou la configuration de la mise à l'échelle à zéro.

Pour modifier un réplica en lecture :

UI

1. Accédez à l'onglet **Computes** de votre Branch dans l'application Lakebase.
2. Recherchez le réplica en lecture, cliquez sur Modifier , mettez à jour les paramètres de compute et cliquez sur Enregistrer .

Python SDK

Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask

w = WorkspaceClient()

# Update read replica size
endpoint_name = "projects/my-project/branches/production/endpoints/my-read-replica"

endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_ONLY,
    autoscaling_limit_min_cu=1.0,
    autoscaling_limit_max_cu=8.0
)
endpoint = Endpoint(name=endpoint_name, spec=endpoint_spec)
update_mask = FieldMask(field_mask=[
    "spec.autoscaling_limit_min_cu",
    "spec.autoscaling_limit_max_cu"
])

result = w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=endpoint,
    update_mask=update_mask
).wait()

print(f"Updated read replica size: {result.status.autoscaling_limit_min_cu}-{result.status.autoscaling_limit_max_cu} CU")

Java SDK

Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.FieldMask;

WorkspaceClient w = new WorkspaceClient();

// Update read replica size
String endpointName = "projects/my-project/branches/production/endpoints/my-read-replica";

EndpointSpec endpointSpec = new EndpointSpec()
    .setAutoscalingLimitMinCu(1.0)
    .setAutoscalingLimitMaxCu(8.0);

FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.autoscaling_limit_min_cu")
    .addPaths("spec.autoscaling_limit_max_cu")
    .build();

w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

System.out.println("Update initiated");

CLI

Bash

# Update a read replica's autoscaling settings
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-read-replica "spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  --json '{
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }'

curl

Bash

# Update a read replica's autoscaling settings
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-read-replica?update_mask=spec.autoscaling_limit_min_cu,spec.autoscaling_limit_max_cu" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-read-replica",
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }' | jq

En savoir plus : Gérer les computes

Supprimer un réplica en lecture

La suppression d'un réplica en lecture est une action permanente. Cependant, vous pouvez rapidement créer un nouveau réplica en lecture si vous en avez besoin.

Pour supprimer un réplica en lecture :

UI

1. Accédez à l'onglet **Computes** de votre Branch dans l'application Lakebase.
2. Trouvez le réplica en lecture, cliquez sur Modifier , Supprimer et confirmez la suppression.

Python SDK

Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Delete endpoint
w.postgres.delete_endpoint(
    name="projects/my-project/branches/production/endpoints/my-read-replica"
).wait()

print("Endpoint deleted")

L'opération de suppression est asynchrone. La méthode .wait() se bloque jusqu'à ce que la suppression soit terminée.

Java SDK

Java

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

// Delete endpoint
w.postgres().deleteEndpoint(
    "projects/my-project/branches/production/endpoints/my-read-replica"
);

System.out.println("Delete initiated");

CLI

Bash

# Delete a read replica
databricks postgres delete-endpoint projects/my-project/branches/production/endpoints/my-read-replica

curl

Bash

curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-read-replica" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Réponse :

JSON

{
  "name": "projects/my-project/branches/production/endpoints/my-read-replica/operations/...",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Résoudre le délai de réplication.

Si vos réplicas en lecture prennent du retard, suivez ces étapes pour diagnostiquer et résoudre le problème :

Vérifier l'alignement de la configuration

Si un retard de réplication est détecté, assurez-vous que les configurations des computes principal et de réplique en lecture sont alignées. Plus précisément, confirmez que les paramètres suivants correspondent entre votre compute principal et votre compute de réplique en lecture :

• max_connections
• max_prepared_transactions
• max_locks_per_transaction
• max_wal_senders
• max_worker_processes

Vous pouvez exécuter la query suivante sur votre compute de lecture-écriture principal et sur votre compute de réplique en lecture en utilisant l'éditeur SQL Lakebase ou un client SQL comme psql:

SQL

SELECT name, setting
FROM pg_settings
WHERE name IN (
  'max_connections',
  'max_prepared_transactions',
  'max_locks_per_transaction',
  'max_wal_senders',
  'max_worker_processes'
);

Comparez les résultats des deux computes pour identifier tout paramètre mal aligné.

Redémarrer les computes de répliques en lecture

Si les configurations ne sont pas alignées, redémarrez vos computes de réplicas en lecture pour mettre à jour automatiquement leurs paramètres. Accédez à l' tab Computes de votre Branch, trouvez le réplica en lecture, et cliquez sur Modifier , puis sur Redémarrer.

remarque

Lorsque vous augmentez la taille de votre compute principale en lecture-écriture, redémarrez toujours les réplicas de lecture associés pour garantir que leurs configurations restent alignées.

Ressources supplémentaires

• Vue d'ensemble des réplicas en lecture
• Gérer les computes
• Connectez-vous à votre base de données