Gérer les computes
Un compute est un service virtualisé qui exécute Postgres pour vos projets Lakebase. Chaque Branch a un compute principal (lecture-écriture). Un compute est requis pour se connecter à une branch et accéder à ses données. Pour un aperçu de la façon dont les computes et les Endpoints sont liés, consultez Computes et Endpoints.
Understanding compute
Vue d'ensemble du compute
Les ressources de compute fournissent la puissance de traitement et la mémoire nécessaires pour exécuter les requêtes, gérer les connexions et traiter les opérations de base de données. Chaque projet dispose d'un compute primaire en lecture-écriture pour sa branch default.
Pour vous connecter à une base de données dans une branch, vous devez utiliser un compute associé à cette branch. Les computes plus grands consomment plus d'heures de compute sur la même période d'activité que les computes plus petits.
Identifiants Compute
Chaque compute possède trois identifiants, accessibles depuis le menu Obtenir l'ID sur l'onglet Computes tab :
Identifiant | Source | Exemple | Utilisé dans |
|---|---|---|---|
Nom | L'ID de l'Endpoint, défini sur |
| Chemin d’accès aux ressources de l’API ( |
UID | Généré par système |
| Hostname de connexion |
Nom de la ressource | Chemin complet de l'API |
| Appels d'API |
The Hostname dans votre chaîne de connexion utilise l' UID , et non le nom du compute.
Dimensionnement du compute
Tailles de compute disponibles
Lakebase Postgres prend en charge les tailles de compute suivantes :
- Mise à l'échelle automatique des compute : de 0,5 CU à 64 CU (0,5, puis incréments entiers : 1, 2, 3... 64)
- Computes de taille fixe plus grands : de 65 CU à 112 CU
L'application Lakebase affiche un sous-ensemble de tailles couramment utilisées. À l’aide de l’ API Postgres, de Terraform, des Databricks Asset Bundles ou du SDK Databricks, vous pouvez définir n’importe quelle valeur CU entière : 1 à 64 pour les computes de mise à l’échelle automatique et 65 à 112 pour les computes plus grands de taille fixe.
Qu'est-ce qu'une unité de compute ?
Chaque unité de compute (CU) alloue environ 2 Go de RAM à l'instance de base de données, ainsi que toutes les ressources CPU et SSD locales associées. La mise à l'échelle supérieure augmente ces ressources linéairement. Postgres répartit la mémoire allouée entre plusieurs composants :
- Caches de base de données
- Mémoire du Worker.
- 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 Monter en charge automatiquement.
Lakebase provisionnée vs Autoscaling : Dans Lakebase provisionnée, chaque unité de compute a alloué environ 16 Go de RAM. Dans l'autoscaling de Lakebase, chaque UC alloue 2 Go de RAM. Cette modification offre des options de mise à l’échelle plus granulaires et un meilleur contrôle des coûts.
Spécifications de compute
Unités de compute | RAM | Nombre maximal de connexions |
|---|---|---|
0,5 CU | ~1 Go | 105 |
1 unité de contrôle | ~2 Go | 218 |
2 CU | ~4 Go | 443 |
3 CU | Environ 6 Go | 668 |
4 CU | ~8 Go | 894 |
5 unités de contrôle | Environ 10 Go | 1119 |
6 CU | environ 12 Go | 1344 |
7 CU | ~14 Go | 1570 |
8 CU | ~16 Go | 1795 |
9 CU | ~18 Go | 2020 |
10 CU | environ 20 Go | 2246 |
12 unités de contrôle | Environ 24 Go | 2696 |
14 CU | ~28 Go | 3 147 |
16 CU | ~32 Go | 3 597 |
24 unités de contrôle | ~48 Go | 3993 |
28 CU | Environ 56 Go | 3993 |
32 CU | ~64 Go | 3993 |
36 unités de contrôle | ~72 Go | 3993 |
40 CU | Environ 80 Go | 3993 |
44 CU | Environ 88 Go | 3993 |
48 CU | ~96 Go | 3993 |
52 CU | ~104 Go | 3993 |
56 CU | Environ 112 Go | 3993 |
60 unités de contrôle | Environ 120 Go | 3993 |
64 CU | ~128 Go | 3993 |
72 unités de contrôle | ~144 Go | 3993 |
80 unités de contrôle | ~160 Go | 3993 |
88 CU | ~ 176 Go | 3993 |
96 unités de contrôle | ~192 Go | 3993 |
104 unités de contrôle | ~208 Go | 3993 |
112 unités de contrôle | environ 224 Go | 3993 |
Limites de connexion pour les computes à mise à l’échelle automatique : lorsque la mise à l’échelle automatique est activée, le nombre maximal de connexions est déterminé par la plus petite valeur entre votre CU maximale et 8× votre CU minimale. Par exemple, si vous configurez l'autoscaling entre 2 et 8 CU, votre limite de connexion est de 1 795 (la limite pour 8 CU).
Limites de connexion des réplicas en lecture : Les limites de connexion du compute des réplicas en lecture sont synchronisées avec vos paramètres de compute principaux en lecture-écriture. Veuillez consulter Gérer les réplicas en lecture pour plus de détails.
Certaines connexions sont réservées pour une utilisation système et administrative. Pour cette raison, SHOW max_connections peut afficher une valeur supérieure à celle des connexions maximales affichées dans le tableau ci-dessus ou dans le tiroir Modifier le compute de l'application Lakebase. Les valeurs du tableau et du tiroir reflètent le nombre réel de connexions disponibles pour une utilisation directe, tandis que SHOW max_connections inclut les connexions réservées.
Guide de dimensionnement
Lorsque vous sélectionnez une taille de compute, prenez en compte ces facteurs :
Facteur | Recommandation |
|---|---|
Complexité des requêtes | Les requêtes d'analyse complexes bénéficient de tailles de compute plus importantes. |
Connexions simultanées | Plus de connexions nécessitent plus de CPU et de mémoire. |
Volume de données | Les datasets plus volumineux pourraient nécessiter plus de mémoire pour des performances optimales |
Temps de réponse | Les applications critiques peuvent nécessiter des computes plus grands pour des performances homogènes |
Stratégie de dimensionnement optimale
Sélectionnez une taille de compute selon vos besoins en données :
- Dataset complet en mémoire : Choisissez une taille de compute qui peut contenir l'intégralité de votre dataset en mémoire pour des performances optimales.
- **Ensemble de travail en mémoire** : Pour les grands datasets, assurez-vous que vos données fréquemment accédées tiennent en mémoire
- Limites de connexion : sélectionnez une taille qui prend en charge vos connexions simultanées maximales anticipées.
Dimensionnement automatique
Lakebase prend en charge les configurations de compute à taille fixe et à dimensionnement automatique. Le dimensionnement automatique ajuste dynamiquement les ressources de compute en fonction de la demande de charge de travail, optimisant à la fois les performances et les coûts.
Type de configuration | Description |
|---|---|
Taille fixe (de 0,5 à 64 CU) | Sélectionnez une taille de compute fixe qui ne s'adapte pas à la demande de workload. Disponible pour les computes de 0,5 CU à 64 CU |
Mise à l'échelle automatique (de 0,5 à 64 CU) | Utilisez un curseur pour spécifier les tailles de compute minimales et maximales. Lakebase s'adapte à la demande dans ces limites en fonction de la charge actuelle. Disponible pour les computes jusqu'à 64 CU (128 Go) |
Compute à taille fixe plus grands (80-112 CU) | Sélectionnez un compute de taille fixe plus grande allant jusqu'à 112 CU. Ces computes plus grands ne sont disponibles qu'en tailles fixes et ne prennent pas en charge la mise à l'échelle automatique. |
Autoscaling limit: La mise à l'échelle automatique est prise en charge pour les compute jusqu'à 64 CU (128 Go). Pour les workloads nécessitant plus de 64 CU, des computes de plus grande taille fixe, de 80, 96 ou 112 CU, sont disponibles.
Configuration de l’autoscaling
Pour activer ou ajuster l'auto-mise à l'échelle pour un compute, modifiez le compute et utilisez le curseur pour définir les tailles minimale et maximale du compute.
Pour une vue d'ensemble du fonctionnement du dimensionnement automatique, consultez Dimensionnement automatique.
Considérations relatives au dimensionnement automatique
Pour des performances d'autoscaling optimales :
- Définissez la taille minimale de votre compute suffisamment grande pour mettre en cache votre jeu de travail en mémoire.
- Considérez qu'une faible performance peut se produire jusqu'à ce que le compute monte en charge et mette en cache vos données.
- Vos limites de connexion sont basées sur le plus petit de votre CU maximum et de 8x votre CU minimum.
Contraintes de plage de mise à l'échelle automatique : la différence entre vos tailles de compute maximale et minimale ne peut pas dépasser 16 CU (soit 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 (ce qui représenterait 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 computes de taille fixe plus grands, jusqu'à 112 CU.
Monter en charge jusqu'à zéro
La fonctionnalité de mise à l'échelle à zéro de Lakebase fait automatiquement passer un compute à l'état inactif après une période d'inactivité, réduisant ainsi les coûts des bases de données qui ne sont pas continuellement actives.
Configuration | Description |
|---|---|
Monter en charge à zéro activé | Le compute se suspend automatiquement après inactivité pour réduire les coûts. |
Monter en charge à zéro désactivé | Maintenez un compute « toujours activé » qui élimine la latence de Startup. |
Pour un aperçu du fonctionnement de la mise à l'échelle à zéro, consultez Mise à l'échelle à zéro. Pour configurer la mise à l'échelle à zéro pour un compute, consultez Configurer la mise à l'échelle à zéro.
Créer et gérer des computes
Afficher les computes
Afficher dans l'interface utilisateur
Pour afficher les computes d'une Branch, accédez à la page **Branch** de votre projet dans l'application Lakebase et sélectionnez une Branch pour afficher son **Computes** tab.
L'onglet Computes affiche des informations sur tous les computes associés à la branch. Le tab Computes affiche des informations sur tous les computes associés à la branch.
Détail | Description |
|---|---|
Type de compute | Le type de compute est soit Primaire (lecture-écriture) soit Réplica en lecture (lecture seule). Une branch peut avoir un seul Primaire (lecture-écriture) et plusieurs computes Réplica en lecture (lecture seule). |
Statut | Statut actuel : Actif ou Suspendu (lorsque le compute a été suspendu en raison de la mise à l'échelle à zéro). Affiche la date et l'heure auxquelles le compute a été suspendu. |
UID | L'identifiant unique généré par le système pour le compute, qui commence par un préfixe |
Taille | La taille de compute en unités de compute (CU). Affiche une valeur CU unique (par exemple, 8 CU) pour les computes de taille fixe. Affiche une plage (par exemple, de 8 à 16) pour les computes avec autoscaling activé. |
Dernière activité | La date et l'heure de la dernière activité du compute. |
Pour chaque compute, vous pouvez :
- Cliquez sur Connecter pour ouvrir une boîte de dialogue de connexion avec les détails de connexion pour la Branch associée au compute. La boîte de dialogue inclut un bouton Pooling de connexions pour les rôles de mot de passe Postgres natifs. Voir Se connecter à votre base de données et Utiliser le pooling de connexions.
- Cliquez sur **Modifier** pour modifier la taille du compute (plage fixe ou de mise à l'échelle automatique) et configurer les paramètres de mise à l'échelle à zéro. Consultez Modifier un compute.
- Cliquez sur l'icône de menu pour accéder à des options supplémentaires :
- Surveiller l'activité : Afficher l'activité du compute et les métriques de performance. Voir Surveiller votre base de données.
- Redémarrer le compute : redémarrez le compute pour résoudre les problèmes de connexion ou appliquer les modifications de configuration. Consultez Redémarrer un compute.
Pour ajouter un compute réplica en lecture à la Branch, cliquez sur Ajouter un réplica en lecture . Les réplicas en lecture sont des computes en lecture seule qui permettent la mise à l’échelle horizontale en vous permettant de décharger la charge de travail en lecture de votre compute principal. Voir Réplicas en lecture et Gérer les réplicas en lecture.
Obtenir un compute par programmation
Pour obtenir des détails sur un compute spécifique à l’aide de l’API Postgres :
- Python SDK
- Java SDK
- CLI
- curl
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 SDK, accédez à l'hôte via endpoint.status.hosts.host (pas endpoint.status.host).
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());
# Get endpoint details
databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
Lister les computes par programmation
Pour lister tous les computes et les réplicas en lecture pour une Branch en utilisant l'API Postgres :
- Python SDK
- Java SDK
- CLI
- curl
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 SDK, accédez à l'hôte via endpoint.status.hosts.host (pas endpoint.status.host).
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();
}
# List endpoints for a branch
databricks postgres list-endpoints projects/my-project/branches/production --output json | jq
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq
Configurations typiques de branch :
- 1 Endpoint : compute primaire en lecture-écriture uniquement
- 2+ endpoints : compute primaire plus une ou plusieurs répliques en lecture
Modifier un compute
Vous pouvez modifier un compute pour modifier sa taille, sa configuration d'autoscaling ou les paramètres de mise à l'échelle à zéro. Les noms de compute sont en lecture seule et ne peuvent pas être renommés.
Pour modifier un compute :
- UI
- Python SDK
- Java SDK
- CLI
- curl
- Accédez à l'onglet **Computes** de votre branch dans l'application Lakebase.
- Cliquez sur **Modifier** pour le compute, ajustez vos paramètres, et cliquez sur **Enregistrer**.
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 à la fois dans la spécification et dans 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}")
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 à la fois dans la spécification et dans 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");
# 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
}
}'
# 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
Les modifications des paramètres de compute prennent effet immédiatement et peuvent provoquer de brèves interruptions de connexion pendant le redémarrage.
Configurez la mise à l'échelle à zéro
Pour configurer la mise à l'échelle jusqu'à 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 définissez pas les deux. Le paramètre no_suspension: false n'est pas valide et renvoie une erreur. Par default, la branch production a la mise à zéro activée avec un délai d'expiration de 24 heures.
- UI
- Python SDK
- Java SDK
- CLI
- curl
- Accédez à l'onglet **Computes** de votre branch dans l'application Lakebase.
- Cliquez sur Modifier pour le compute, puis activez ou désactivez le paramètre de mise à zéro. Lorsqu'il est activé, configurez le délai d'expiration d'inactivité entre 60 secondes et 7 jours.
- Cliquez sur Enregistrer .
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()
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)
);
# 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"
}
}'
# 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 compute
La désactivation d’un compute le suspend et bloque toutes les nouvelles connexions. Contrairement à la Monter en charge à zéro, un compute désactivé ne peut pas être activé par une tentative de connexion ou depuis l'application Lakebase. Pour le réactiver, utilisez l’API.
- Python SDK
- CLI
- curl
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 compute est actuellement désactivé, lisez la valeur de l'état de l'endpoint. Vous avez défini la valeur sur spec.disabled, mais vous l'avez lue à partir de 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
# 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 compute est actuellement désactivé, lisez status.disabled de l'endpoint :
databricks postgres get-endpoint projects/my-project/branches/production/endpoints/my-compute --output json | jq '.status.disabled'
# 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 compute est actuellement désactivé, lisez status.disabled de l'endpoint :
curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/endpoints/my-compute" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq '.status.disabled'
Après avoir réactivé un compute, de nouvelles tentatives de connexion peuvent échouer jusqu'à ce que le compute ait terminé son redémarrage.
Redémarrer un compute
Redémarrez un compute pour appliquer les mises à jour, résoudre les problèmes de performance ou prendre en compte les modifications de configuration.
Pour redémarrer un compute :
- Accédez à l'onglet **Computes** de votre branch dans l'application Lakebase.
- Cliquez sur le menu
pour le compute, sélectionnez Redémarrer , et confirmez l'opération.
Le redémarrage d'un compute interrompt toute connexion active. Configurez vos applications pour se reconnecter automatiquement afin d'éviter des interruptions prolongées.