Remarque
L’accès à cette page requiert une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page requiert une autorisation. Vous pouvez essayer de modifier des répertoires.
Les politiques de calcul serverless permettent aux administrateurs d’espaces de travail de contrôler l’accès aux produits de calcul serverless supportés, de limiter leur configuration et d’appliquer des balises sur les ressources de calcul nouvellement créées. Cette page explique comment créer des politiques, accorder l’accès et les utiliser avec Lakebase.
Important
Les politiques de calcul sans serveur sont en aperçu privé et sont gérées via l’API REST. L’aperçu prend en charge Lakebase. Contactez votre équipe de compte Databricks pour demander l’accès.
Spécifications
- Votre espace de travail doit être inscrit dans la version d’aperçu de la stratégie de calcul sans serveur et avoir accès à Lakebase. Voir Disponibilité régionale pour la disponibilité régionale Lakebase.
- Vous devez être administrateur d’espace de travail pour créer une règle. Pour lire ou utiliser une police existante, vous avez besoin
CAN_USEde cette police.CAN_MANAGEPour mettre à jour ou supprimer une politique personnalisée, ou gérer les permissions d’une politique, vous avez besoinCAN_MANAGEde . - Les exemples utilisent
curl,jq, et un jeton OAuth d’espace de travail. L’exemple d’authentification utilise l’interface de ligne de commande Databricks.
Comment fonctionnent les stratégies de calcul sans serveur
Une politique de calcul serverless appartient à un espace de travail. L’objet allowed_compute_products spécifie quels produits de calcul un utilisateur peut utiliser via la politique ainsi que les limites de configuration de chaque produit. Accorder l’accès à une politique permettant aux utilisateurs d’utiliser les produits qu’elle autorise dans ces limites.
Après la création, la stratégie attachée régit les modifications apportées à la configuration de la ressource de calcul tant que la stratégie existe. Le resserrement d’une stratégie ne modifie pas le compute existant. Les mises à jour ultérieures des paramètres régis par la stratégie doivent satisfaire à ses contraintes actuelles. Par exemple, un changement de capacité de Lakebase doit respecter le maximum actuel de la stratégie, mesuré en unités de calcul (CU).
Pour les politiques qui contrôlent le calcul classique, voir Créer et gérer les politiques de calcul classiques.
Autorisations pour les modifications de configuration
La mise à jour des paramètres d’une ressource ou le remplacement de sa stratégie de calcul nécessite les autorisations suivantes :
| Modification de configuration | Autorisations requises |
|---|---|
| Modifier les paramètres hors du champ d’application de la politique | Permission de gérer la ressource. L’autorisation d’utiliser la stratégie n’est pas requise. |
| Modifier les paramètres de calcul régis par la policy | Autorisation de gérer la ressource et CAN_USE ou CAN_MANAGE sur la stratégie, même si elle n’impose aucune limite pour le paramètre. |
| Remplacer la politique jointe | Autorisation de gérer la ressource et CAN_USE ou CAN_MANAGE sur la stratégie actuelle et celle de remplacement. |
L’autorisation de gérer une ressource dépend du produit. Par exemple, un utilisateur ayant CAN_MANAGE sur un projet Lakebase peut changer son nom d’affichage sans avoir accès à sa politique de calcul. Modifier la capacité de calcul ou les paramètres d’échelle à zéro nécessite l’autorisation d’utiliser la politique, même lorsque celle-ci ne définit aucune limite de capacité ou de temps d’inactivité.
L’autorisation d’utiliser une politique ne contourne pas ses contraintes. Les paramètres mis à jour doivent respecter les limites de la politique et préserver ses paires clé-valeur de balises requises.
Vous ne pouvez pas supprimer une règle d’une ressource sans attribuer une règle de remplacement. Pour un projet Lakebase, la politique de remplacement doit autoriser Lakebase. Le nettoyage spec.compute_policy_id attribue la politique Lakebase par défaut comme remplacement et nécessite les mêmes permissions.
Étiquettes de stratégie
Utilisez la carte de niveau supérieur tags optionnelle pour spécifier les balises clé-valeur, à côté display_name de et allowed_compute_products. Les clés et valeurs de balise sont des chaînes. Une politique peut comporter jusqu’à 20 balises, et chaque clé doit être non vide.
Les balises d’une politique de calcul serverless se propagent vers les ressources de calcul créées avec cette politique. La politique applique ces tags tant qu’elle existe et reste attachée. Les modifications apportées aux balises du compute doivent préserver les paires clé-valeur requises par la stratégie jointe.
Les politiques d’utilisation sans serveur, également appelées politiques budgétaires sans serveur, attribuent des étiquettes pour l’attribution des coûts et utilisent un identifiant de politique distinct. Vous pouvez utiliser une politique d’utilisation sans serveur ainsi qu’une politique de calcul sans serveur. Le compute créé reçoit l’union des balises des deux politiques. Par exemple, si la stratégie de calcul spécifie environment=development et la politique d’utilisation spécifie cost_center=engineering, le calcul reçoit les deux tags.
Paramètres de stratégie Lakebase
Pour autoriser Lakebase via une politique de calcul serverless, incluez lakebase dans allowed_compute_products.
Création du projet Lakebase
La création d’un projet Lakebase nécessite CAN_USE ou CAN_MANAGE sur une stratégie qui autorise Lakebase. Lorsque vous créez un projet Lakebase, vous y recevez CAN_MANAGE automatiquement.
Les autorisations de politique n’accordent pas l’accès aux projets Lakebase existants ni à leurs données. Les permissions de projet Lakebase contrôlent la gestion des ressources, avec des autorisations de stratégie supplémentaires nécessaires pour modifier les paramètres de calcul régis par une politique. Rôles et autorisations Postgres permettent de contrôler l’accès à la base de données.
Limites de capacité et de temps d’inactivité
Définissez l’un ou les deux des champs suivants sous allowed_compute_products.lakebase:
| Field | Description |
|---|---|
max_capacity_units_per_instance |
Capacité maximale à Lakebase CU. Pour un calcul à mise à l’échelle automatique, le maximum configuré doit respecter cette limite. |
max_idle_minutes_before_scale_to_zero |
Délai d’inactivité maximal, en minutes, avant que le calcul passe à zéro. Une instance de calcul soumise à cette limite doit avoir la mise à l’échelle jusqu’à zéro activée, avec un délai d’attente égal ou inférieur à la limite. |
Les deux champs acceptent les entiers positifs. Omettre un champ ne définit pas de limite de politique pour ce paramètre. Un objet vide lakebase permet Lakebase sans l’une ou l’autre des deux limites. Une politique doit inclure un objet lakebase pour autoriser Lakebase.
Par exemple, l’objet suivant lakebase limite chaque calcul à 16 CU et nécessite une mise à l’échelle à zéro après au plus 15 minutes d’inactivité :
{
"max_capacity_units_per_instance": 16,
"max_idle_minutes_before_scale_to_zero": 15
}
Ces limites complètent les tailles de calcul prises en charge et les paramètres de mise à l’échelle à zéro. Une stratégie ne rend pas disponible une configuration non prise en charge. Voir Limitations pour les configurations qui ne prennent pas en charge la mise à l’échelle jusqu’à zéro.
Politique Lakebase par défaut
La politique Lakebase par défaut de l’espace de travail permet Lakebase sans limites de capacité ni de temps d’inactivité. Les utilisateurs de l’espace de travail peuvent utiliser cette politique pour créer des projets Lakebase par défaut.
Les administrateurs d’espace de travail peuvent accorder ou révoquer des autorisations sur la politique Lakebase par défaut via l’API des autorisations. Ils ne peuvent pas supprimer la stratégie ni en modifier le nom ou la configuration.
Lorsque vous créez un projet Lakebase sans spécifier de politique de calcul, la requête utilise la Politique Lakebase par défaut. Vous devez avoir l’autorisation d’utiliser cette policy. La création d’une stratégie personnalisée ne révoque pas l’accès à la stratégie par défaut ni ne l’applique automatiquement aux projets Lakebase existants. Pour exiger des utilisateurs qu’ils sélectionnent une politique personnalisée, voir Exiger une politique personnalisée pour la création de projet Lakebase.
Configurer l’authentification API
Utilisez l’URL de votre espace de travail et un jeton OAuth de l’espace de travail pour ces requêtes. Voir Autoriser l’accès des utilisateurs à Azure Databricks avec OAuth pour les détails d’authentification.
Définissez
WORKSPACEà l’URL de votre espace de travail, sans oblique de suivi :export WORKSPACE="https://<workspace-host>"Authentifiez-vous à cet espace de travail :
databricks auth login --host "$WORKSPACE"Récupérez un jeton OAuth pour l’identité authentifiée :
export DATABRICKS_TOKEN="$(databricks auth token --host "$WORKSPACE" | jq -r .access_token)"
Actualisez le jeton s’il expire. Exécutez chaque requête en tant qu’identité avec les autorisations requises.
Créer une politique
L’exemple suivant crée une politique de calcul sans serveur qui autorise Lakebase :
En tant qu’administrateur d’espace de travail, envoyez la requête suivante. Elle crée une politique avec un maximum de 16 CU, un délai d’inactivité maximal de 15 minutes et un tag imposé
environment=development:curl --fail-with-body -sS -X POST "$WORKSPACE/api/2.0/policies/compute" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "display_name": "Lakebase development", "allowed_compute_products": { "lakebase": { "max_capacity_units_per_instance": 16, "max_idle_minutes_before_scale_to_zero": 15 } }, "tags": { "environment": "development" } }'Copiez le
compute_policy_idde la réponse et définissez-le pour les requêtes suivantes :export COMPUTE_POLICY_ID="<compute-policy-id>"Récupérez la politique pour vérifier son nom et ses contraintes de produit. Cette réponse n’inclut pas les tags de la politique :
curl --fail-with-body -sS "$WORKSPACE/api/2.0/policies/compute/$COMPUTE_POLICY_ID" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"
Le corps de la requête est l’objet de politique lui-même. Le service attribue compute_policy_id. Choisissez un nom d’affichage unique dans l’espace de travail, de 1 à 127 caractères.
Accorder l’accès à une politique
Utilisez Permissions API avec le type d’objet compute-policy. Le créateur de la politique a CAN_MANAGE.
En tant qu’identité avec
CAN_MANAGE, accordez à un groupe d’espace de travail existant l’autorisation d’utiliser la stratégie. Remplacezlakebase-developerspar le nom de votre groupe :curl --fail-with-body -sS -X PATCH \ "$WORKSPACE/api/2.0/permissions/compute-policy/$COMPUTE_POLICY_ID" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "access_control_list": [ { "group_name": "lakebase-developers", "permission_level": "CAN_USE" } ] }'Vérifiez l’autorisation :
curl --fail-with-body -sS \ "$WORKSPACE/api/2.0/permissions/compute-policy/$COMPUTE_POLICY_ID" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"
À utiliser user_name pour accorder l’accès à un utilisateur, ou service_principal_name avec l’ID d’application d’un principal de service. Accorder CAN_MANAGE pour permettre à un principal d’utiliser la stratégie et de gérer ses autorisations. Pour les politiques personnalisées, CAN_MANAGE permet également de mettre à jour la configuration et de supprimer la politique.
PATCH met à jour les autorisations spécifiées.
PUT remplace les assignations directes d’autorisations, incluez donc l’ensemble complet que vous souhaitez conserver.
Exiger une politique personnalisée pour la création de projet Lakebase
En tant qu’administrateur d’espace de travail, suivez les étapes suivantes pour exiger que les utilisateurs sélectionnent une stratégie personnalisée :
-
Listez les stratégies, en suivant toutes les valeurs
next_page_token. Trouvez la politique Lakebase par défaut par sa valeurlakebaseet l’entréeis_defaultdansallowed_compute_products. Copiez soncompute_policy_id. - Accordez aux utilisateurs ou groupes concernés l’accès à une politique personnalisée qui autorise Lakebase.
- Pour les projets Lakebase existants qui utilisent la politique par défaut, remplacez leur politique si les utilisateurs doivent continuer à modifier les paramètres de calcul gouvernés. La révocation de l’accès à la politique par défaut empêche ces modifications sur les ressources de calcul qui l’utilisent encore.
- Récupérez les autorisations d’accès de la politique par défaut avec
GET /api/2.0/permissions/compute-policy/<default-policy-id>. Examinez les autorisations d’utilisateurs et de groupe. La politique par défaut accorde initialement l’accès au groupeusers, donc supprimer une autorisation directe d’utilisateur ne supprime pas l’accès de cet utilisateur. -
Remplacez les attributions d’autorisations directes par
PUT /api/2.0/permissions/compute-policy/<default-policy-id>. Incluez les autorisations directes que vous souhaitez conserver dansaccess_control_list, et omettez les autorisations qui donnent aux utilisateurs concernés l’accès. Remplacez l’autorisation généraleuserspar des autorisations accordées à des groupes spécifiques si certains utilisateurs doivent conserver l’accès à la stratégie par défaut. Chaque entrée de demande utilise un nom principal etpermission_level, comme dans l’exemple de l’octroi. N’envoyez pas la réponse des GET permissions inchangée comme le corps PUT. - En tant qu’utilisateur concerné, listez à nouveau les politiques. Vérifiez que la stratégie personnalisée est disponible et que la stratégie par défaut n’est plus disponible. L’utilisateur doit désormais spécifier un ID de politique personnalisé lors de la création d’un projet Lakebase.
Utiliser une politique avec les projets Lakebase
Utilisez l’API Postgres (/api/2.0/postgres/) pour créer et gérer des projets Lakebase. Un projet Lakebase contient des branches, et les points de terminaison de calcul fournissent le calcul pour ces branches. Voir Ressources de calcul et endpoints.
Sélectionnez une compute policy spec.compute_policy_id lors de la création d’un projet Lakebase. La politique jointe régit la configuration de calcul et applique les balises requises sur le calcul associé. La gestion des politiques utilise l’API séparée /api/2.0/policies/compute .
Créer un projet Lakebase avec une politique
Utilisez une identité avec CAN_USE ou CAN_MANAGE sur la politique créée ci-dessus :
Créez un projet Lakebase avec une plage d’autoscaling de 2 à 8 CU et un délai d’inactivité de 15 minutes :
curl --fail-with-body -sS -X POST \ "$WORKSPACE/api/2.0/postgres/projects?project_id=policy-example" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d "$(jq -n --arg policy_id "$COMPUTE_POLICY_ID" '{ "spec": { "display_name": "Policy example", "compute_policy_id": $policy_id, "default_endpoint_settings": { "autoscaling_limit_min_cu": 2, "autoscaling_limit_max_cu": 8, "suspend_timeout_duration": "900s" } } }')"Les valeurs de capacité sont exprimées en Lakebase CU. Le maximum de 8 CU correspond à la limite de 16 CU prévue par la stratégie. Lakebase exprime le délai d’inactivité en secondes :
"900s"correspond à la limite de 15 minutes de la politique. Ces paramètres par défaut configurent le compute initial et fournissent les paramètres de départ pour les nouveaux computes dans le projet Lakebase.Pour appliquer également une politique d’utilisation serverless, ajoutez
"budget_policy_id": "<usage-policy-id>"insidespec, en utilisant l’ID d’une politique que vous pouvez utiliser. Compute reçoit les tags des deux stratégies.Copiez l’opération
namedepuis la réponse, et définissez-la pour la requête de statut :export OPERATION_NAME="<operation-name>"Récupérer l’opération jusqu’à ce que
donesoittrue:curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/$OPERATION_NAME" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"Si la réponse contient
error, résolvez-la avant de continuer. Créez, mettez à jour et supprimez des requêtes en utilisant ce modèle d’opération de longue durée.
Lire et lister les projets Lakebase
Récupérez le projet Lakebase :
curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/projects/policy-example" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"Vérifiez que cela
status.compute_policy_idcorrespond à la politique que vous avez sélectionnée.Listez les projets Lakebase auxquels vous pouvez accéder :
curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/projects" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"
Si la réponse de la liste inclut next_page_token, passez cette valeur comme page_token pour récupérer la page suivante.
Mettre à jour un projet Lakebase
Utilisez une identité avec CAN_MANAGE sur le projet Lakebase. Modifier son nom d’affichage ne nécessite pas d’autorisation pour utiliser sa politique de calcul.
Mettez à jour le nom affichable du projet Lakebase, en spécifiant le champ dans le masque de mise à jour :
curl --fail-with-body -sS -X PATCH \ "$WORKSPACE/api/2.0/postgres/projects/policy-example?update_mask=spec.display_name" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d '{"spec": {"display_name": "Lakebase development"}}'Attendez que l’opération renvoyée soit terminée, puis récupérez le projet Lakebase pour vérifier la modification.
Modifier la capacité ou les valeurs par défaut de calcul à échelle nulle d’un projet Lakebase nécessite CAN_USE également ou CAN_MANAGE sur la politique, même si elle ne définit aucune limite pour le paramètre. Les nouvelles valeurs doivent satisfaire à toutes les limites de politique applicables. Les valeurs par défaut s’appliquent lorsque de nouvelles instances de calcul sont créées. Pour modifier un compute existant, mettez à jour son point de terminaison comme indiqué dans la procédure suivante.
Pour modifier la politique jointe, voir Remplacer la politique d’un projet Lakebase.
Mettre à jour le compute Lakebase
L’exemple suivant élève le maximum du calcul existant à 16 CU et raccourcit son délai d’inactivité à 10 minutes. Vous devez CAN_MANAGE sur le projet Lakebase et CAN_USE / CAN_MANAGE ou sur la politique :
Listez les points de terminaison de la branche
productiondu projet Lakebase :curl --fail-with-body -sS \ "$WORKSPACE/api/2.0/postgres/projects/policy-example/branches/production/endpoints" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"Copiez le point de terminaison
namedu calcul initial depuis la réponse. Le nom inclut le projet Lakebase, la branche et le chemin de terminaison :export ENDPOINT_NAME="<endpoint-name>"Mettez à jour la CU maximale et les paramètres de mise à l’échelle à zéro. Utilisez
spec.suspensiondans le masque de mise à jour pour le délai d’inactivité :curl --fail-with-body -sS -X PATCH \ "$WORKSPACE/api/2.0/postgres/$ENDPOINT_NAME?update_mask=spec.autoscaling_limit_max_cu,spec.suspension" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "spec": { "autoscaling_limit_max_cu": 16, "suspend_timeout_duration": "600s" } }'Attendez que l’opération retournée soit terminée, puis récupérez le point de terminaison :
curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/$ENDPOINT_NAME" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"Vérifier
status.autoscaling_limit_max_cuetstatus.suspend_timeout_duration.
Le maximum mis à jour correspond à la limite de 16 CU prévue par la stratégie et "600s" est inférieur à sa limite d’inactivité de 15 minutes. Pour cette instance de calcul, les requêtes supérieures à 16 CU, les délais d’inactivité supérieurs à 15 minutes ou la désactivation du paramètre de mise à l’échelle à zéro échouent à la validation de la politique. Choisissez les paramètres à l’intérieur des limites de la stratégie ou demandez à un gestionnaire de politiques de les examiner.
Remplacer la politique d’un projet Lakebase
Vous devez disposer de CAN_MANAGE sur le projet Lakebase et de CAN_USE ou de CAN_MANAGE sur la stratégie actuelle et sur son remplacement. Le remplacement doit permettre l’utilisation de Lakebase.
La commutation de politiques est une mise à jour de configuration. Les paramètres de calcul et de calcul par défaut existants du projet Lakebase doivent satisfaire aux contraintes de la politique de remplacement avant que la mise à jour puisse s’achever.
Sélectionnez une politique de remplacement et définissez son ID :
export REPLACEMENT_COMPUTE_POLICY_ID="<replacement-policy-id>"Vérifiez que les paramètres de calcul par défaut du projet Lakebase et les ressources de calcul existantes respectent les limites de capacité et de temps d’inactivité de la politique de remplacement. Mettez à jour les ressources de calcul existantes et ajustez les paramètres par défaut si nécessaire.
Mettre à jour l’attribution de politique du projet Lakebase :
curl --fail-with-body -sS -X PATCH \ "$WORKSPACE/api/2.0/postgres/projects/policy-example?update_mask=spec.compute_policy_id" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d "$(jq -n --arg policy_id "$REPLACEMENT_COMPUTE_POLICY_ID" '{ "spec": { "compute_policy_id": $policy_id } }')"Attendez que l’opération renvoyée se termine avec
done: true. S’il contient unerror, résolvez-le avant de continuer.Récupérez le projet Lakebase et vérifiez que
status.compute_policy_idcorrespond à l’ID de stratégie de remplacement :curl --fail-with-body -sS "$WORKSPACE/api/2.0/postgres/projects/policy-example" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"
Effacer spec.compute_policy_id sélectionne la politique Lakebase par défaut et nécessite l’autorisation de l’utiliser. Cela ne laisse pas le projet Lakebase sans Policy.
Supprimer un projet Lakebase
Par défaut, la suppression d’un projet Lakebase le rend indisponible et le conserve pour la récupération pendant la période de rétention. La suppression d’un projet Lakebase ne supprime pas la stratégie de l’espace de travail.
Supprimez le projet Lakebase d’exemple :
curl --fail-with-body -sS -X DELETE \ "$WORKSPACE/api/2.0/postgres/projects/policy-example" \ -H "Authorization: Bearer $DATABRICKS_TOKEN"Attendez que l’opération renvoyée soit terminée. Pour savoir comment supprimer, y compris les branches protégées, voir Supprimer un projet.
Gérer les stratégies
Utilisez les opérations suivantes pour inspecter et maintenir les politiques dans votre espace de travail.
Récupérer et répertorier les stratégies
Obtenez une stratégie individuelle avec GET /api/2.0/policies/compute/{compute_policy_id}, comme indiqué dans Créer une stratégie. Pour lister les politiques que vous pouvez utiliser ou gérer, exécutez :
curl --fail-with-body -sS "$WORKSPACE/api/2.0/policies/compute?page_size=100" \
-H "Authorization: Bearer $DATABRICKS_TOKEN"
La réponse contient compute_policies et, lorsque d’autres résultats sont disponibles, next_page_token. Transmets ce jeton comme page_token dans la requête suivante. La taille de page par défaut est de 100, et la taille maximale est de 150. Les résultats ne sont pas triés. Chaque politique inclut can_use et can_manage pour l’identité appelante.
is_default identifie une politique par défaut.
Mettre à jour une politique
Les mises à jour de stratégie nécessitent un update_mask paramètre de requête. Les chemins pris en charge sont display_name et allowed_compute_products. Pour mettre à jour les deux, séparez les chemins par une virgule. Ce point de terminaison ne prend pas en charge la mise à jour de tags.
Récupérez la stratégie de sécurité et examinez les paramètres que vous souhaitez conserver.
Envoyez les champs modifiés. Par exemple, relâchez la limite de capacité de la police d’exemple à 32 CU et maintenez sa limite d’inactivité de 15 minutes :
curl --fail-with-body -sS -X PATCH \ "$WORKSPACE/api/2.0/policies/compute/$COMPUTE_POLICY_ID?update_mask=allowed_compute_products" \ -H "Authorization: Bearer $DATABRICKS_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "allowed_compute_products": { "lakebase": { "max_capacity_units_per_instance": 32, "max_idle_minutes_before_scale_to_zero": 15 } } }'Vérifiez la stratégie renvoyée pour vérifier la limite mise à jour.
La mise à jour de l’objet lakebase remplace ses contraintes. Incluez toutes les contraintes Lakebase que vous souhaitez conserver. Par exemple, omettre une limite de temps d’inactivité existante supprime cette limite. Un objet vide lakebase supprime ses limites tout en continuant à permettre Lakebase. Les chemins de masque imbriqués, tels que allowed_compute_products.lakebase.max_capacity_units_per_instance, ne sont pas pris en charge.
Pour renommer une politique sans modifier ses contraintes, utilisez update_mask=display_name et un corps tel que {"display_name": "Lakebase application policy"}.
Abaisser la limite de capacité d’une stratégie de 16 à 8 CU laisse la capacité de calcul existante à 16 CU inchangée. Tout changement de capacité ultérieur doit respecter la limite de 8 CU. Lors du passage à une autre politique, les ressources de calcul existantes doivent satisfaire aux contraintes de cette politique avant que la mise à jour puisse se terminer.
Supprimer une stratégie
La suppression d’une stratégie ne supprime pas les ressources de calcul créées à l’aide de cette stratégie. L’application de ses contraintes dépend du fait que la politique continue d’exister et reste attachée.
Avant de supprimer une politique personnalisée :
-
Listez les projets Lakebase, en fonction des valeurs
next_page_token. Trouvez les projets Lakebase dont lestatus.compute_policy_idcorrespond à la politique que vous prévoyez de supprimer. - Confirmez que l’inventaire couvre tous les projets Lakebase concernés.
CAN_MANAGEsur une politique ne donne pas accès à tous les projets Lakebase qui l’utilisent. Coordonnez-vous avec les propriétaires de projets Lakebase ou un administrateur de l’espace de travail pour les projets que vous ne pouvez pas consulter. - Remplacez la politique relative aux projets Lakebase concernés avant de la supprimer si ces projets doivent rester régis par une politique.
Pour supprimer une politique personnalisée, exécutez :
curl --fail-with-body -sS -X DELETE \
"$WORKSPACE/api/2.0/policies/compute/$COMPUTE_POLICY_ID" \
-H "Authorization: Bearer $DATABRICKS_TOKEN"
La politique Lakebase par défaut ne peut pas être supprimée.
Troubleshooting
| Erreur ou condition | Action |
|---|---|
PERMISSION_DENIED Assurez-vous de disposer de lors de la création d’un projet Lakebase |
Vérifiez que vous avez CAN_USE ou CAN_MANAGE êtes sur une politique qui autorise Lakebase. Si vous omettez l’ID de la politique, vous avez besoin d’accéder à la politique Lakebase par défaut. |
PERMISSION_DENIED lors de la mise à jour de la configuration de la ressource |
Vérifiez votre autorisation de gestion de la ressource. Les modifications des paramètres de calcul régis par la stratégie nécessitent également CAN_USE ou CAN_MANAGE sur la stratégie, même si la stratégie ne définit aucune limite pour ce paramètre. Voir Autorisations pour les modifications de configuration. |
PERMISSION_DENIED lors du remplacement d’une stratégie attachée |
Vérifiez que vous êtes autorisé à gérer la ressource et CAN_USE ou CAN_MANAGE sur la stratégie actuelle et sur celle de remplacement. |
BAD_REQUEST parce que la capacité dépasse le maximum de la politique |
Réduisez autoscaling_limit_max_cu dans la configuration du terminal ou les paramètres de calcul par défaut du projet Lakebase pour correspondre à la limite de CU de la politique. |
BAD_REQUEST parce que le délai d’attente dépasse le maximum de la politique |
Activez la mise à l’échelle à zéro et choisissez un délai d’inactivité égal ou inférieur à la limite de la politique, sur une ressource de calcul prenant en charge la mise à l’échelle à zéro. |
INVALID_PARAMETER_VALUE lors de la création ou de la mise à jour d’une stratégie |
Vérifiez que le nom n’est pas vide et qu’il ne compte pas au plus 127 caractères, qu’au moins un produit de calcul est présent, que les limites sont des entiers positifs et que le masque de mise à jour contient les chemins pris en charge. Les noms et la configuration par défaut des politiques ne peuvent pas être modifiés. |
ALREADY_EXISTS lors du nommage d’une stratégie |
Choisissez un autre nom. Les noms de politique par défaut sont réservés. |
Limites
Gestion des stratégies
- Les politiques sont limitées à un espace de travail. Créez et accordez l’accès aux politiques dans chaque espace de travail où vous les utilisez.
- La politique Lakebase par défaut ne peut pas être supprimée ni voir son nom ou sa configuration modifiée. Les administrateurs de l’espace de travail peuvent accorder ou révoquer des permissions sur celui-ci.
- Supprimer une politique d’une ressource nécessite un remplacement. Vous devez disposer des autorisations pour gérer la ressource et
CAN_USEouCAN_MANAGEsur les deux politiques. Le calcul existant doit satisfaire aux contraintes de la politique de remplacement avant que la mise à jour puisse être terminée. - Resserrer une politique ne modifie pas les ressources de calcul existantes. Les modifications ultérieures des paramètres régis doivent respecter les limites mises à jour.
- La suppression d’une stratégie personnalisée ne supprime pas les ressources de calcul créées à partir de cette stratégie. L’application des contraintes de cette politique dépend du maintien de la politique.
- L’API de politique ne renvoie pas les tags dans les réponses get ou list, et ne supporte pas la modification des tags via le point de terminaison de mise à jour de la politique.
Lakebase compute
- Modifier la capacité de calcul ou les paramètres de mise à l’échelle jusqu’à zéro nécessite
CAN_MANAGEsur le projet Lakebase etCAN_USEouCAN_MANAGEsur sa politique. Cela s’applique même si la politique ne définit aucune limite pour le paramètre. - L’échelle à zéro nécessite une taille maximale de calcul de 32 UC ou moins. Si une politique nécessite une limite de temps d’inactivité, choisissez une taille de calcul compatible. Voir Configurer la mise à l’échelle jusqu’à zéro.
- La haute disponibilité utilise un groupe de calcul avec plusieurs nœuds et nécessite que la mise à l’échelle jusqu’à zéro soit désactivée. La limite de temps d’inactivité prévue par la politique ne s’applique pas à ces groupes. Les limites de capacité restent en vigueur.
- Modifier les valeurs par défaut de calcul d’un projet Lakebase a un impact sur les nouvelles ressources de calcul. Mettez à jour séparément les points de terminaison de calcul existants pour modifier leur capacité ou leur délai d’inactivité.
Compatibilité de l’API des instances de base de données
Database Instances API reste disponible pour l’automatisation existante. Il utilise les noms d’instance et les niveaux de capacité provisionné, et crée des projets Lakebase sur la plateforme Autoscaling. Utilisez l’API Postgres pour les nouvelles intégrations. Les projets Lakebase créés via l’API Postgres ou l’interface Lakebase ne peuvent pas être gérés via l’API des instances de base de données. Consultez les API.
L’API des instances de base de données utilise la politique Lakebase par défaut. La création d’un projet Lakebase via cette API nécessite CAN_USE ou CAN_MANAGE sur cette politique. Omettez-le compute_policy_id ou laissez-le vide. Une valeur non vide est rejetée à la fois lors des requêtes de création et de mise à jour. Pour sélectionner une politique personnalisée, utilisez l’API Postgres.
L’API de compatibilité utilise les champs suivants :
| Purpose | Champ API des instances de base de données |
|---|---|
| Vérifier la stratégie appliquée |
effective_compute_policy_id dans la réponse d’instance. |
| Configurer la capacité |
capacity, en utilisant un niveau provisionné tel que CU_1. Voir le mappage des niveaux. |
| Sélectionnez une stratégie d’utilisation serverless | De premier niveau usage_policy_id. Les tags des deux politiques s’appliquent. |
Les utilisateurs sans accès à la politique par défaut doivent utiliser l’API Postgres avec une politique personnalisée qu’ils peuvent utiliser pour créer un projet Lakebase.