Aller au contenu principal
Dernière mise à jour le

Bonnes pratiques : politiques de compute

attention

Cet article a été archivé et peut ne plus refléter l'état actuel du produit. Pour des informations sur les politiques de compute, voir Créer et gérer des politiques de compute.

Les stratégies de compute Databricks offrent aux administrateurs un contrôle sur la création de ressources de compute dans un workspace Databricks. L'utilisation efficace des stratégies de compute permet aux administrateurs de :

  • Appliquer des configurations compute standardisées.
  • Prévenez l'utilisation excessive des Ressources et maîtrisez les dépenses.
  • Assurez une refacturation précise en étiquetant correctement les ressources de compute.
  • Faciliter l'analyse et le traitement en fournissant aux utilisateurs des configurations compute préconfigurées ciblées sur des workloads spécifiques.

Combinées à des processus d'intégration, d'approbation et de refacturation efficaces, les politiques de compute peuvent constituer un composant fondamental de la gouvernance de la plateforme Databricks. Ce guide présente des recommandations et des bonnes pratiques pour vous aider à créer un plan réussi d'intégration des politiques de compute dans votre cadre de gouvernance.

Étant donné que la gouvernance est unique aux exigences de chaque organisation et à l'infrastructure de gouvernance existante, cet article commence par aborder les recommandations qui s'appliquent couramment aux politiques de compute. La dernière section de cet article aborde des stratégies spécifiques pour relever les défis que vous pourriez rencontrer dans votre environnement.

Cet article aborde les bonnes pratiques et recommandations suivantes pour assurer un déploiement réussi de la gouvernance du compute :

  • Créez un plan pour introduire les politiques de compute par phases afin d'aider les utilisateurs à passer à un environnement gouverné.
  • Créez un plan pour communiquer les changements pour chaque phase du déploiement des politiques de compute.
  • Identifier les défis de la gouvernance de compute et mettre en œuvre des stratégies pour les relever.

Déploiement des politiques de compute​

La mise en œuvre de politiques de compute peut entraîner un changement significatif pour l'expérience utilisateur. Databricks recommande une approche progressive pour guider les utilisateurs tout au long de la transition :

  • Communiquez les changements à venir et offrez aux utilisateurs la possibilité de tester les configurations de compute.
  • Effectuez un déploiement en douceur.
  • Introduire par incréments d'autres modifications de politique.
  • Procéder à une migration complète vers un environnement entièrement régi.

Un déploiement par phases permet aux utilisateurs de se familiariser avec les nouvelles politiques et de prévenir la disruption des workloads existants. Le diagramme suivant est un exemple de ce processus recommandé :

Plan de déploiement des politiques de compute

Les sections suivantes fournissent des informations plus détaillées sur ces étapes :

Communiquez et testez les politiques de compute​

Commencez le processus en communiquant les changements à venir aux utilisateurs. Le plan de communication devrait inclure :

  • Détails sur les changements à venir.
  • Pourquoi ces changements se produisent-ils.
  • Ce que les utilisateurs devront faire pour assurer une transition réussie des charges de travail.
  • Comment fournir un retour d'expérience concernant les modifications.
  • Un calendrier pour chaque étape du déploiement.
  • Au start de chaque étape du déploiement progressif, communiquez des détails supplémentaires pertinents pour cette étape.

Le diagramme suivant fournit un exemple de plan de communication pour un déploiement échelonné :

Plan de communication des politiques de compute

Votre plan peut avoir différentes étapes en fonction de votre environnement et de la stratégie des politiques de compute. Cet exemple comprend quatre étapes :

  • La phase 1 comprend la communication du plan aux utilisateurs et le début des tests. Les utilisateurs doivent avoir la possibilité de tester leurs charges de travail actuelles et anticipées sur un compute conforme aux nouvelles stratégies. Vous souhaitez identifier les problèmes liés aux charges de travail existantes et prévues dès le début du processus.
  • L'étape 2 poursuit les tests ainsi que le déploiement d'une politique relative aux tags compute.
  • L'étape 3 introduit les types de compute, dans ce cas, en spécifiant le compute à l'aide de tailles de T-shirts, par exemple, les types de compute petit, grand ou très grand.
  • L'étape 4 est le déploiement final des stratégies de compute ainsi qu'une documentation utilisateur complète.

Les utilisateurs devraient également avoir l'opportunité de tester leurs workloads avec les configurations de compute prévues au stade initial. Ces tests peuvent aider à identifier les charges de travail existantes qui rencontrent des problèmes d'exécution avec les politiques proposées.

Considérations relatives à l'introduction des politiques de compute​

Tenez compte de vos politiques de gestion actuelles lors de la planification du déploiement initial des politiques de compute. En particulier, déterminez si vous passez d'un environnement où les utilisateurs ne sont pas autorisés à créer des ressources de compute ou d'un environnement plus ouvert.

Environnement restrictif​

Dans le cas d'un environnement où les utilisateurs n'avaient pas les autorisations nécessaires pour créer du compute, commencez par déployer des stratégies restrictives ainsi qu'un plan d'activation pour les utilisateurs. Un plan d'activation peut être une formation informatique, des ateliers ou de la documentation. Fournir aux utilisateurs des conseils sur les meilleures pratiques de configuration du compute améliorera leur capacité à tirer pleinement parti de la plateforme. Les politiques peuvent être assouplies à mesure que les utilisateurs démontrent leur conformité et leur maîtrise de la plateforme.

Environnement non restreint​

L'application des politiques peut s'avérer plus difficile dans un environnement non restreint. Certains cas d'utilisation existants et compute dépasseront presque toujours les contraintes de la nouvelle politique, il est donc crucial de les identifier lors d'une phase de test ou de déploiement progressif.

Les utilisateurs disposant d’autorisations de création de compute ou ayant accès à la politique sans restriction conserveront leur accès à cette politique tout au long du déploiement progressif afin de garantir le bon fonctionnement de toutes les charges de travail. Les utilisateurs doivent utiliser le déploiement progressif pour tester toutes leurs charges de travail avec les nouvelles politiques qui leur seront mises à disposition.

Veillez à fournir aux utilisateurs un endroit où soumettre des commentaires sur les politiques. Collaborez avec les utilisateurs pour affiner les politiques ou définir de nouvelles politiques lorsque des problèmes surviennent.

Déploiement final​

Supprimez l'accès aux politiques non restreintes pour les utilisateurs restreints lorsque la date limite est atteinte. Le déploiement des politiques de compute devrait maintenant être terminé.

Défis et stratégies spécifiques​

Voici des exemples d'application de politiques de compute pour relever des défis spécifiques. Beaucoup de ces stratégies peuvent être utilisées simultanément, mais nécessiteront l’application de chaque stratégie pour toutes les politiques. Par exemple, si vous utilisez la stratégie d'application des balises avec la stratégie de taille de T-shirt, chaque politique de T-shirt aura également besoin d'une politique custom_tag.*.

Application de l'étiquetage​

Défi​

Les utilisateurs peuvent créer du compute librement, et il n'y a aucun mécanisme pour faire en sorte qu'ils appliquent les tags requis.

Solutions​

  1. Révoquez l'autorisation de création de compute des utilisateurs.

  2. Ajoutez une règle de tag de compute à toutes les politiques de compute applicables. Pour ajouter la règle de tag de compute à une politique, utilisez l’attribut custom_tags.<tag-name>. La valeur peut être n’importe quoi sous une politique illimitée, ou elle peut être limitée par des politiques fixes, de liste d’autorisation, de liste de blocage, d’expressions régulières ou de plage. Par exemple, pour assurer une rétrofacturation et une attribution des coûts correctes, appliquez un tag COST_CENTER à chaque politique limitée à une liste de valeurs de centres de coûts autorisés :

    JSON
    { "custom_tags.COST_CENTER": { "type": "allowlist", "values": ["9999", "9921", "9531"] } }

    Tout utilisateur appliquant cette politique devra remplir une balise COST_CENTER avec 9999, 9921 ou 9531 pour que le compute démarre.

  3. Attribuez la politique aux utilisateurs qui devraient pouvoir imputer des frais à ces trois centres de coûts. Les politiques peuvent être attribuées au niveau de l'utilisateur ou du groupe via l'interface utilisateur de la politique de compute ou l'API des politiques. Le corps de la requête d'exemple suivant attribue une politique au service Ventes :

    JSON
    {
      "access_control_list": [
        {
          "user_name": "user@mydomain.com",
          "all_permissions": [
            {
              "permission_level": "CAN_USE"
            }
          ]
        },
        {
          "group_name": "sales",
          "all_permissions": [
            {
              "permission_level": "CAN_USE"
            }
          ]
        }
      ]
    }

Utilisateurs inexpérimentés​

Défi​

Les utilisateurs sont peu familiers avec le compute ou le provisionnement de l’infrastructure cloud, ou sont dépassés par les options de création de compute.

Solutions​

Utilisez des politiques de compute pour définir des configurations de compute de tailles « T-shirt », par exemple, des compute de petite, moyenne ou grande taille.

  1. Créez une politique pour chaque taille de T-Shirt. Les politiques de taille de T-shirt indiquent une taille de compute relative aux utilisateurs et peuvent être des Templates flexibles ou des configurations sans option. Les stratégies sans option ou avec peu d'options auront souvent des règles de stratégie fixes et masquées. L'exemple suivant définit une politique avec une valeur fixe de Databricks Runtime 7.3 pour le spark_version. Le fait de définir l'indicateur hidden sur vrai garantira que cette option n'est pas visible pour les utilisateurs.

    JSON
    { "spark_version": { "type": "fixed", "value": "auto:latest-ml", "hidden": true } }

    Lors de la définition de flexibles Template, vous pouvez utiliser des politiques de plage, de liste de blocage, de regex et de politique illimitée pour définir des limites supérieures, des champs non facultatifs et des éléments de politique semi-restreints. L’exemple suivant définit une politique qui permet aux nœuds de dimensionnement automatique d'atteindre un maximum de 25. Vous pouvez utiliser cette définition pour fixer des limites supérieures à chaque taille de T-shirt tout en offrant une certaine flexibilité. Pour plus de détails sur une approche de Template de compute, consultez Utilisation excessive des Ressources.

    JSON
    { "autoscale.max_workers": { "type": "range", "maxValue": "25", "defaultValue": 5 } }

  2. Attribuez la politique aux utilisateurs qui devraient être autorisés à créer des ressources de compute de taille T-shirt. Les politiques peuvent être attribuées au niveau de l'utilisateur ou du groupe via l'interface utilisateur de politique ou l'API de permissions de politique. Par exemple, pour attribuer cette politique à tous les utilisateurs via l'interface utilisateur :

    1. Accédez à la politique et sélectionnez Modifier .

    2. Sélectionnez l'onglet Autorisations .

    3. Sélectionnez l'option **tous les utilisateurs** sous **Groupes** dans le menu déroulant.

      Attribuer une politique à tous les utilisateurs

  3. Révoquer l'accès à la politique non restreinte des groupes qui ne doivent utiliser que ces nouvelles politiques. Une fois que les politiques de compute sont en vigueur, avoir accès à l'autorisation de « création de compute » donne aux utilisateurs l'accès à la politique non restreinte. Il est important de révoquer cette permission pour les utilisateurs qui ne devraient pas l'avoir.

    Pour révoquer les autorisations de création de compute, consultez Configurer l'autorisation de création de compute.

Stratégies spécifiques aux cas d’utilisation​

Défi​

Certains workloads ou analyses sont incompatibles avec les politiques existantes, ou les utilisateurs ne connaissent pas la configuration de compute correcte pour certains types de workloads.

Solutions​

Si vous trouvez des charges de travail qui ne fonctionnent pas bien avec les politiques existantes, il est souvent préférable de créer de nouvelles politiques spécifiquement ciblées sur ces charges de travail au lieu d'étendre les politiques existantes.

Pour aider les utilisateurs à créer des compute à l'aide de ces politiques, il peut être utile de créer des politiques adaptées à des cas d'utilisation spécifiques. Attribuez des noms descriptifs à ces politiques pour aider les utilisateurs à les identifier. Par exemple, si les charges de travail interrogent une source de données qui prend en charge le pushdown de prédicat, une bonne pratique consiste à créer une politique spécifique qui applique la mise à l'échelle automatique avec un minimum de worker faible ou nul. Cette politique garantira que les coûts du fournisseur cloud et de Databricks n'augmentent pas inutilement en attendant que la source de données calcule les composants pushdown de la query.

  1. Créez une politique qui applique les meilleures pratiques spécifiques aux cas d'usage. Cet exemple définit une politique qui a une valeur fixe de 0 pour le nombre minimum de Workers. Cette politique garantit également que le compute se mettra à l'échelle automatiquement, satisfaisant ainsi la meilleure pratique de l'exemple de predicate pushdown.

    JSON
    { "autoscale.min_workers": { "type": "fixed", "value": "0", "hidden": false } }

  2. Attribuez la politique aux utilisateurs qui doivent créer du compute pour ces cas d'utilisation. Vous pouvez attribuer des politiques au niveau de l'utilisateur ou du groupe via l'interface utilisateur de la politique ou l'API des autorisations. Par exemple, pour assigner cette politique à un groupe de data scientists via l'interface utilisateur :

    1. Accédez à la politique et sélectionnez Modifier .

    2. Sélectionnez l'onglet Autorisations .

    3. Pour attribuer une politique à une équipe spécifique, sélectionnez le nom de l’équipe dans la liste déroulante Sélectionner un utilisateur ou un groupe .

      Attribuer une politique à un groupe

Utilisation excessive des ressources​

Défi​

Les utilisateurs créent des compute inutilement grands, consommant des Ressources excessives et coûteuses. Ceci est souvent causé par :

  • Échec de l'activation du dimensionnement automatique.
  • Utilisation incorrecte des fenêtres d’arrêt automatique.
  • Nombre élevé de nœuds Worker minimum.
  • Types d’instances coûteux.

Solutions​

L'association des politiques de compute avec un processus d'approbation interne permettra de contrôler les Ressources tout en donnant accès à de grandes Ressources de compute lorsque nécessaire.

  1. Établir un processus de révision pour l'octroi d'accès à des politiques plus larges ou plus flexibles. Le processus d'examen doit comporter un formulaire de saisie qui recueille des informations justifiant la nécessité de configurations de compute plus grandes ou plus flexibles. L'équipe responsable de la plateforme doit évaluer ces informations pour décider comment prendre en charge les exigences de charge de travail. Le diagramme suivant illustre un exemple de processus d'approbation utilisant la classification par taille de T-shirt :

    Processus de dimensionnement des politiques

  2. Créez des politiques plus flexibles avec moins de contraintes et mettez l’accent sur le contrôle des éléments de gouvernance tels que les tags. Un exemple de politique flexible :

JSON
{
  "autoscale.min_workers": {
    "type": "range",
    "maxValue": 20,
    "defaultValue": 2
  },
  "autoscale.max_workers": {
    "type": "range",
    "maxValue": 100,
    "defaultValue": 8
  },
  "autotermination_minutes": {
    "type": "range",
    "maxValue": 120,
    "defaultValue": 60
  },
  "node_type_id": {
    "type": "blocklist",
    "values": ["z1d.12xlarge", "z1d.6xlarge", "r5d.16xlarge", "r5a.24xlarge", "i4i.32xlarge"],
    "defaultValue": "i3.xlarge"
  },
  "driver_node_type_id": {
    "type": "blocklist",
    "values": ["z1d.12xlarge", "z1d.6xlarge", "r5d.16xlarge", "r5a.24xlarge", "i4i.32xlarge"],
    "defaultValue": "i3.xlarge"
  },
  "spark_version": {
    "type": "fixed",
    "value": "auto:latest-ml",
    "hidden": true
  },
  "enable_elastic_disk": {
    "type": "fixed",
    "value": true,
    "hidden": true
  },
  "custom_tags.team": {
    "type": "fixed",
    "value": "product"
  }
}

  1. Documentez le processus de mise à niveau et d'approbation et partagez-le avec les utilisateurs. Il est également utile de publier des directives sur l'identification des types de charges de travail qui pourraient nécessiter plus de flexibilité ou un compute plus important.

  2. Une fois qu'un utilisateur est approuvé, attribuez-lui la stratégie. Les stratégies peuvent être attribuées au niveau utilisateur ou groupe via l'interface utilisateur de la stratégie ou en soumettant une demande à l'API Autorisations:

    JSON
    {
      "access_control_list": {
        "user_name": "users_email@example.com",
        "permission_level": "CAN_USE"
      }
    }

En savoir plus​

Pour en savoir plus sur les politiques de compute sur Databricks, consultez Créer et gérer les politiques de compute et notre blog sur les politiques de compute : Autoriser la création simple de clusters avec un contrôle administratif total à l'aide de politiques de cluster.

Sur cette page