Gérer les calculs

Un calcul est un service virtualisé qui exécute Postgres pour vos projets Lakebase. Chaque branche a une unité de calcul principal (lecture-écriture). Un calcul est nécessaire pour se connecter à une branche et accéder à ses données. Pour obtenir une vue d’ensemble de la relation entre les calculs et les points de terminaison, consultez Calculs et points de terminaison.

Présentation des calculs

Vue d’ensemble du calcul

Les ressources de calcul fournissent la puissance de traitement et la mémoire nécessaires pour exécuter des requêtes, gérer les connexions et gérer les opérations de base de données. Chaque projet a un calcul en lecture-écriture primaire pour sa branche par défaut.

Pour vous connecter à une base de données dans une branche, vous devez utiliser un calcul associé à cette branche. Les calculs plus volumineux consomment plus d’heures de calcul sur la même période de temps actif que les calculs plus petits.

Identificateurs de calcul

Chaque calcul comporte trois identificateurs, accessibles à partir du menu Obtenir l’ID sous l’onglet Calculs :

Le nom d’hôte de votre chaîne de connexion utilise le UID, et non le nom de calcul.

Dimensionnement des ressources de calcul

Tailles de calcul disponibles

Lakebase Postgres prend en charge les tailles de calcul suivantes :

• Calculs de mise à l’échelle automatique : 0,5 CU à 64 CU (0,5, puis incréments entiers : 1, 2, 3... 64)
• Instances de calcul de taille fixe plus grandes : 65 CU à 112 CU

Qu’est-ce qui se trouve dans une unité de calcul ?

Chaque unité de calcul alloue environ 2 Go de RAM à l’instance de base de données, ainsi que toutes les ressources UC et SSD locales associées. L'augmentation de l'échelle augmente ces ressources de manière linéaire. Postgres distribue la mémoire allouée sur plusieurs composants :

• Caches de base de données
• Mémoire de travail
• Autres processus avec des exigences de mémoire fixes

Les performances varient en fonction de la taille des données et de la complexité des requêtes. Avant la mise à l’échelle, testez et optimisez les requêtes. Le stockage s'adapte automatiquement.

Spécifications de calcul

Limites de connexion pour les calculs de mise à l’échelle automatique : lorsque la mise à l’échelle automatique est activée, le nombre maximal de connexions est déterminé par le plus petit de votre cu maximum et 8× votre cu minimum. Par exemple, si vous configurez la mise à l’échelle automatique entre 2 et 8 CU, votre limite de connexion est de 1 795 (la limite de 8 CU).

Limites de connexion des réplicas en lecture : les limites de connexion de calcul des réplicas en lecture sont synchronisées avec vos paramètres d'instance de calcul principale en lecture-écriture. Consultez Gérer les réplicas en lecture pour plus de détails.

Conseils de dimensionnement

Lorsque vous sélectionnez une taille de calcul, tenez compte des facteurs suivants :

Stratégie de dimensionnement optimale

Sélectionnez une taille de calcul en fonction de vos besoins en données :

• Jeu de données complet en mémoire : choisissez une taille de calcul qui peut contenir l’intégralité de votre jeu de données en mémoire pour optimiser les performances
• Ensemble de travail en mémoire : pour les jeux de données volumineux, assurez-vous que vos données fréquemment sollicitées s’intègrent en mémoire
• Limites de connexion : sélectionnez une taille qui prend en charge vos connexions simultanées maximales prévues

Mise à l’échelle automatique

Lakebase prend en charge les configurations de calcul de taille fixe et de mise à l’échelle automatique. La mise à l’échelle automatique ajuste dynamiquement les ressources de calcul en fonction de la demande de charge de travail, en optimisant les performances et le coût.

Limite de mise à l’échelle automatique : La mise à l’échelle automatique est prise en charge pour les calculs jusqu’à 64 CU (128 Go). Pour les charges de travail nécessitant plus de 64 CU, des instances de calcul de taille fixe plus grandes de 80, 96 ou 112 CU sont disponibles.

Configuration de la mise à l’échelle automatique

Pour activer ou ajuster la mise à l’échelle automatique pour un calcul, modifiez le calcul et utilisez le curseur pour définir des tailles de calcul minimales et maximales.

Pour obtenir une vue d’ensemble du fonctionnement de la mise à l’échelle automatique, consultez mise à l’échelle automatique.

Considérations relatives à la mise à l’échelle automatique

Pour optimiser les performances de mise à l’échelle automatique :

• Définissez votre taille de calcul minimale suffisamment grande pour mettre en cache votre ensemble de travail en mémoire
• Considérez que des performances médiocres peuvent se produire jusqu’à ce que le calcul augmente et met en cache vos données
• Vos limites de connexion sont basées sur la plus petite de vos cu maximum et 8× votre cu minimum

Contraintes de plage de mise à l’échelle automatique : la différence entre vos tailles de calcul maximale et minimale ne peut pas dépasser 16 CU (autrement dit, max - min ≤ 16 CU). Par exemple, vous pouvez configurer la mise à l’échelle automatique de 8 à 24 CU, ou de 48 à 64 CU, mais pas de 0,5 à 32 CU (qui serait une plage de 31,5 CU). Le curseur dans l’application Lakebase applique cette contrainte automatiquement. Pour les charges de travail nécessitant plus de 64 CU, utilisez des instances de calcul de taille fixe allant jusqu’à 112 CU.

Réduire à zéro

La fonctionnalité de scale-to-zero de Lakebase transfère automatiquement un calcul en état d’inactivité après une période d’inactivité, ce qui réduit les coûts des bases de données qui ne sont pas actives en permanence.

Pour obtenir une vue d’ensemble du fonctionnement de la mise à l’échelle à zéro, consultez Mise à l’échelle à zéro. Pour configurer l’échelle à zéro pour un calcul, consultez Configurer l’échelle à zéro.

Créer et gérer des calculs

Afficher les calculs

Affichage dans l’interface utilisateur

Pour afficher les calculs d’une branche, accédez à la page Branches de votre projet dans l’application Lakebase, puis sélectionnez une branche pour afficher son onglet Calculs .

L’onglet Calculs affiche des informations sur tous les calculs associés à la branche. Les informations affichées sous l’onglet Calculs sont décrites dans le tableau suivant.

Pour chaque calcul, vous pouvez :

• Cliquez sur Se connecter pour ouvrir une boîte de dialogue de connexion avec les détails de connexion de la branche associée au calcul. La boîte de dialogue inclut un bouton bascule de regroupement de connexions pour les rôles de mot de passe Postgres natifs. Consultez Se connecter à votre base de données et utiliser le regroupement de connexions.
• Cliquez sur Modifier pour modifier la taille de calcul (plage fixe ou de mise à l’échelle automatique) et configurez les paramètres de mise à l’échelle à zéro. Consultez Modifier un calcul.
• Cliquez sur l’icône de menu pour accéder aux options supplémentaires :
  • Surveiller l’activité : affichez l’activité de calcul et les métriques de performances. Consultez Surveiller votre base de données.
  • Redémarrer le calcul : redémarrez le calcul pour résoudre les problèmes de connexion ou appliquer des modifications de configuration. Consultez Redémarrer un calcul.

Pour ajouter un calcul de réplica en lecture à la branche, cliquez sur Ajouter un réplica en lecture. Les réplicas en lecture sont des calculs en lecture seule qui activent la mise à l’échelle horizontale en vous permettant de décharger la charge de travail de lecture à partir de votre calcul principal. Consultez Réplicas en lecture et Gérer les réplicas en lecture.

Obtenir un calcul par programmation

Pour obtenir des détails sur un calcul spécifique à l’aide de l’API Postgres :

SDK Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Get endpoint details
endpoint = w.postgres.get_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute"
)

print(f"Endpoint: {endpoint.name}")
print(f"Type: {endpoint.status.endpoint_type}")
print(f"State: {endpoint.status.current_state}")
print(f"Host: {endpoint.status.hosts.host}")
print(f"Min CU: {endpoint.status.autoscaling_limit_min_cu}")
print(f"Max CU: {endpoint.status.autoscaling_limit_max_cu}")

Dans le Kit de développement logiciel (SDK), accédez à l’hôte via endpoint.status.hosts.host (et non endpoint.status.host).

SDK Java

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

WorkspaceClient w = new WorkspaceClient();

// Get endpoint details
Endpoint endpoint = w.postgres().getEndpoint(
    "projects/my-project/branches/production/endpoints/my-compute"
);

System.out.println("Endpoint: " + endpoint.getName());
System.out.println("Type: " + endpoint.getStatus().getEndpointType());
System.out.println("State: " + endpoint.getStatus().getCurrentState());
System.out.println("Host: " + endpoint.getStatus().getHosts().getHost());
System.out.println("Min CU: " + endpoint.getStatus().getAutoscalingLimitMinCu());
System.out.println("Max CU: " + endpoint.getStatus().getAutoscalingLimitMaxCu());

Interface de ligne de commande (CLI)

# Get endpoint details
databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq

curl

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

Répertorier les calculs par programmation

Pour répertorier tous les calculs et réplicas en lecture d’une branche à l’aide de l’API Postgres :

SDK Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# List all endpoints for a branch
endpoints = list(w.postgres.list_endpoints(
    parent="projects/my-project/branches/production"
))

for endpoint in endpoints:
    print(f"Endpoint: {endpoint.name}")
    print(f"  Type: {endpoint.status.endpoint_type}")
    print(f"  State: {endpoint.status.current_state}")
    print(f"  Host: {endpoint.status.hosts.host}")
    print(f"  CU Range: {endpoint.status.autoscaling_limit_min_cu}-{endpoint.status.autoscaling_limit_max_cu}")
    print()

Dans le Kit de développement logiciel (SDK), accédez à l’hôte via endpoint.status.hosts.host (et non endpoint.status.host).

SDK Java

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

WorkspaceClient w = new WorkspaceClient();

// List all endpoints for a branch
for (Endpoint endpoint : w.postgres().listEndpoints("projects/my-project/branches/production")) {
    System.out.println("Endpoint: " + endpoint.getName());
    System.out.println("  Type: " + endpoint.getStatus().getEndpointType());
    System.out.println("  State: " + endpoint.getStatus().getCurrentState());
    System.out.println("  Host: " + endpoint.getStatus().getHosts().getHost());
    System.out.println("  CU Range: " + endpoint.getStatus().getAutoscalingLimitMinCu() +
        "-" + endpoint.getStatus().getAutoscalingLimitMaxCu());
    System.out.println();
}

Interface de ligne de commande (CLI)

# List endpoints for a branch
databricks postgres list-endpoints projects/my-project/branches/production --output json | jq

curl

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

Modifier un calcul

Vous pouvez modifier un calcul pour modifier sa taille, sa configuration de mise à l’échelle automatique ou les paramètres de mise à l’échelle à zéro. Les noms de calcul sont en lecture seule et ne peuvent pas être renommés.

Pour modifier un calcul :

IU

1. Accédez à l’onglet Calculs de votre branche dans l’application Lakebase.
2. Cliquez sur Modifier pour le calcul, ajustez vos paramètres, puis cliquez sur Enregistrer.

SDK Python

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

w = WorkspaceClient()

# Update a single field (max CU)
endpoint_spec = EndpointSpec(endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE, autoscaling_limit_max_cu=6.0)
endpoint = Endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    spec=endpoint_spec
)

result = w.postgres.update_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    endpoint=endpoint,
    update_mask=FieldMask(field_mask=["spec.autoscaling_limit_max_cu"])
).wait()

print(f"Updated max CU: {result.status.autoscaling_limit_max_cu}")

Pour mettre à jour plusieurs champs, incluez-les dans les spécifications et le masque de mise à jour :

# Update multiple fields (min and max CU)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    autoscaling_limit_min_cu=1.0,
    autoscaling_limit_max_cu=8.0
)
endpoint = Endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    spec=endpoint_spec
)

result = w.postgres.update_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute",
    endpoint=endpoint,
    update_mask=FieldMask(field_mask=[
        "spec.autoscaling_limit_min_cu",
        "spec.autoscaling_limit_max_cu"
    ])
).wait()

print(f"Updated min CU: {result.status.autoscaling_limit_min_cu}")
print(f"Updated max CU: {result.status.autoscaling_limit_max_cu}")

SDK Java

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

WorkspaceClient w = new WorkspaceClient();

// Update a single field (max CU)
EndpointSpec endpointSpec = new EndpointSpec()
    .setAutoscalingLimitMaxCu(6.0);

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

w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName("projects/my-project/branches/production/endpoints/my-compute")
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

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

Pour mettre à jour plusieurs champs, incluez-les dans les spécifications et le masque de mise à jour :

// Update multiple fields (min and max CU)
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("projects/my-project/branches/production/endpoints/my-compute")
        .setEndpoint(new Endpoint().setSpec(endpointSpec))
        .setUpdateMask(updateMask)
);

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

Interface de ligne de commande (CLI)

# Update a single field (max CU)
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-compute spec.autoscaling_limit_max_cu \
  --json '{
    "spec": {
      "autoscaling_limit_max_cu": 6.0
    }
  }'

# Update multiple fields (min and max CU)
databricks postgres update-endpoint projects/my-project/branches/production/endpoints/my-compute "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

# Update a single field (max CU)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.autoscaling_limit_max_cu" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "autoscaling_limit_max_cu": 6.0
    }
  }' | jq

# Update multiple fields (min and max CU)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?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-compute",
    "spec": {
      "autoscaling_limit_min_cu": 1.0,
      "autoscaling_limit_max_cu": 8.0
    }
  }' | jq

Définir l’échelle sur zéro

Pour configurer la mise à l’échelle sur zéro, incluez spec.suspension dans le masque de mise à jour. Définissez suspend_timeout_duration (60s-604800s) pour définir le délai d’inactivité ou no_suspension: true pour le désactiver. Ne les définissez pas ensemble. Le paramètre no_suspension: false n’est pas valide et retourne une erreur. Par défaut, la branche production a l’option de mise à l’échelle à zéro activée, avec un délai d’expiration de 24 heures.

IU

1. Accédez à l’onglet Calculs de votre branche dans l’application Lakebase.
2. Cliquez sur Modifier pour le calcul, puis activez ou désactivez le paramètre scale-to-zero. Lorsque cette option est activée, configurez le délai d’inactivité compris entre 60 secondes et 7 jours.
3. Cliquez sur Enregistrer.

SDK Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Endpoint, EndpointSpec, EndpointType, FieldMask
from google.protobuf.duration_pb2 import Duration

w = WorkspaceClient()
endpoint_name = "projects/my-project/branches/production/endpoints/my-compute"

# Disable scale to zero (compute stays active indefinitely)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    no_suspension=True
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.suspension"])
).wait()

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    suspend_timeout_duration=Duration(seconds=300)
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.suspension"])
).wait()

SDK Java

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

WorkspaceClient w = new WorkspaceClient();
String endpointName = "projects/my-project/branches/production/endpoints/my-compute";

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

// Disable scale to zero (compute stays active indefinitely)
EndpointSpec noSuspensionSpec = new EndpointSpec()
    .setNoSuspension(true);
w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(noSuspensionSpec))
        .setUpdateMask(updateMask)
);

// Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
EndpointSpec timeoutSpec = new EndpointSpec()
    .setSuspendTimeoutDuration(
        Duration.newBuilder().setSeconds(300).build()
    );
w.postgres().updateEndpoint(
    new UpdateEndpointRequest()
        .setName(endpointName)
        .setEndpoint(new Endpoint().setSpec(timeoutSpec))
        .setUpdateMask(updateMask)
);

Interface de ligne de commande (CLI)

# Disable scale to zero (compute stays active indefinitely)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.suspension \
  --json '{
    "spec": {
      "no_suspension": true
    }
  }'

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.suspension \
  --json '{
    "spec": {
      "suspend_timeout_duration": "300s"
    }
  }'

curl

# Disable scale to zero (compute stays active indefinitely)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.suspension" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "no_suspension": true
    }
  }' | jq

# Enable scale to zero with a 5-minute inactivity timeout (60s–604800s)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.suspension" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "suspend_timeout_duration": "300s"
    }
  }' | jq

Désactiver ou activer un calcul

La désactivation d’un calcul l’interrompt et bloque toutes les nouvelles connexions. Contrairement à la mise à l’échelle jusqu’à zéro, une ressource de calcul désactivée ne peut pas être réactivée par une tentative de connexion ni depuis l’application Lakebase. Pour le réactiver, utilisez l’API.

SDK Python

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

w = WorkspaceClient()
endpoint_name = "projects/my-project/branches/production/endpoints/my-compute"

# Disable a compute (blocks all connections)
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    disabled=True
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.disabled"])
).wait()

# Re-enable a compute
endpoint_spec = EndpointSpec(
    endpoint_type=EndpointType.ENDPOINT_TYPE_READ_WRITE,
    disabled=False
)
w.postgres.update_endpoint(
    name=endpoint_name,
    endpoint=Endpoint(name=endpoint_name, spec=endpoint_spec),
    update_mask=FieldMask(field_mask=["spec.disabled"])
).wait()

Pour vérifier si un calcul est actuellement désactivé, lisez la valeur à partir de l’état du point de terminaison. Vous définissez la valeur sur spec.disabled, mais vous la relisez depuis status.disabled :

endpoint = w.postgres.get_endpoint(
    name="projects/my-project/branches/production/endpoints/my-compute"
)
print(endpoint.status.disabled)  # True = disabled, False or None = enabled

Interface de ligne de commande (CLI)

# Disable a compute (blocks all connections)
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.disabled \
  --json '{
    "spec": {
      "disabled": true
    }
  }'

# Re-enable a compute
databricks postgres update-endpoint \
  projects/my-project/branches/production/endpoints/my-compute \
  spec.disabled \
  --json '{
    "spec": {
      "disabled": false
    }
  }'

Pour vérifier si un calcul est actuellement désactivé, lisez status.disabled à partir du point de terminaison :

databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq '.status.disabled'

curl

# Disable a compute (blocks all connections)
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.disabled" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "disabled": true
    }
  }' | jq

# Re-enable a compute
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute?update_mask=spec.disabled" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/endpoints/my-compute",
    "spec": {
      "disabled": false
    }
  }' | jq

Pour vérifier si un calcul est actuellement désactivé, lisez status.disabled à partir du point de terminaison :

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq '.status.disabled'

Redémarrer un calcul

Redémarrez un calcul pour appliquer des mises à jour, résoudre les problèmes de performances ou récupérer les modifications de configuration.

Pour redémarrer un calcul :

1. Accédez à l’onglet Calculs de votre branche dans l’application Lakebase.
2. Cliquez sur pour le calcul, sélectionnez Redémarrer, puis confirmez l’opération.

Ressources supplémentaires

• Tableau de bord des métriques
• Mise à l’échelle automatique
• Réduire à zéro
• Réplicas en lecture