Maîtriser l'API Databricks : Travailler avec des pipelines de données à grande échelle

Les API Databricks permettent une interaction programmatique avec Databricks, permettant aux utilisateurs d'automatiser les flux de travail, de gérer les clusters, d'exécuter des tâches et d'accéder aux données. Ces API prennent en charge l'authentification via des jetons d'accès personnels, OAuth ou Azure Active Directory.

Dans cet article, je vais vous guider à travers un voyage approfondi et pratique à travers l'API REST de Databricks. Que vous soyez novice en matière de Databricks ou que vous cherchiez à optimiser vos flux de travail existants, ce guide vous aidera à maîtriser les opérations clés, notamment l'authentification, la gestion des tâches et l'intégration avec des systèmes externes. 

À la fin de cet article, vous disposerez d'un plan clair pour.. :

• Mise en place d'une authentification API sécurisée à l'aide de jetons d'accès personnels.  
• Utilisation des points de terminaison de l'API pour créer, mettre à jour et exécuter des tâches. 
• Appliquer les meilleures pratiques pour améliorer les performances, optimiser les coûts et gérer les erreurs. 
• Intégration de Databricks avec d'autres plateformes et outils d'orchestration.

Si vous êtes totalement novice en matière de Databricks et que vous souhaitez l'assimiler rapidement, lisez notre article de blog, How to Learn Databricks : A Beginner's Guide to the Unified Data Platform, qui vous aidera à comprendre les principales fonctionnalités et applications de Databricks, et vous fournira également un parcours structuré pour commencer votre apprentissage.

Pourquoi utiliser l'API Databricks ?

L'API REST de Databricks offre de puissantes possibilités aux développeurs et aux ingénieurs de données, leur permettant de gérer les ressources de manière programmatique et de rationaliser les flux de travail. Voici comment l'API Databricks peut faire une grande différence :

Réduction de la charge manuelle dans la planification des tâches et la gestion des clusters

L'API Databricks permet aux utilisateurs d'automatiser des tâches telles que la planification des travaux et la gestion des clusters. Cela permet de réduire les efforts manuels nécessaires à la gestion de ces processus et de libérer du temps pour des activités plus stratégiques. En automatisant les tâches répétitives, les organisations peuvent améliorer leur efficacité et réduire le risque d'erreur humaine, qui peut entraîner des erreurs coûteuses ou des temps d'arrêt.

Intégration transparente avec des systèmes externes

L'API Databricks est conçue pour la flexibilité, permettant l'intégration avec des plateformes externes telles que des outils d'orchestration comme Apache Airflow ou Azure Data Factory.

Vous pouvez également utiliser l'API Databricks pour des systèmes de surveillance et d'alerte tels que Prometheus ou Datadog. L'API Databricks est également utilisée dans les pipelines d'ingestion de données à partir d'outils tels que Kafka ou les services de données RESTful. Ces intégrations permettent de mettre en place des flux de travail de bout en bout qui font le lien entre l'ingénierie des données et l'analyse à travers plusieurs systèmes.

Évolutivité pour des milliers de pipelines automatisés

L'API Databricks prend en charge la création et la gestion de milliers de pipelines automatisés. Il s'adapte sans effort à la gestion de milliers de tâches exécutées en parallèle et à la mise à l'échelle dynamique des clusters en fonction de la charge de travail. Cette évolutivité garantit que votre infrastructure s'adapte de manière transparente aux besoins de l'entreprise, même à l'échelle de l'entreprise.

Opérations et exemples d'API de base

L'API REST de Databricks offre un large éventail d'opérations pour gérer les travaux, les clusters, les fichiers et les autorisations d'accès. Ci-dessous, je vais explorer les opérations clés de l'API avec des exemples pratiques pour vous aider à construire et à automatiser des flux de travail robustes.

Emplois

Les emplois sont l'épine dorsale des flux de travail automatisés dans Databricks. L'API vous permet de créer, de gérer et de contrôler les travaux de manière transparente.

Créer un emploi

Utilisez le point de terminaison POST /API/2.1/jobs/create pour définir un nouveau travail. Par exemple, la charge utile JSON suivante crée un nouveau job Databricks nommé My Job et exécute un notebook situé à l'adresse /path/to/notebook. La charge utile utilise alors un cluster existant avec l'ID cluster-id, ce qui évite de devoir en créer un nouveau. Si le travail échoue, la charge utile envoie une notification par courrier électronique à user@example.com.

{
  "name": "My Job",
  "existing_cluster_id": "cluster-id",
  "notebook_task": {
    "notebook_path": "/path/to/notebook"
  },
  "email_notifications": {
    "on_failure": ["user@example.com"]
  }
}

Lister et obtenir les détails d'un emploi

Vous pouvez utiliser le point de terminaison GET /api/2.1/jobs/list pour récupérer une liste de tous les travaux dans votre espace de travail. Par exemple, l'exemple de commande suivant permet de dresser la liste de tous les travaux :

curl -n -X GET \
https://<databricks-instance>.cloud.databricks.com/api/2.1/jobs/list

Déclenchement des courses

Utilisez le point de terminaison POST /api/2.1/jobs/run-now pour déclencher l'exécution immédiate d'un travail.

curl -n -X POST \
https://<databricks-instance>.cloud.databricks.com/api/2.1/jobs/run-now?job_id=123456789

Suppression de travaux et d'exécutions

Bien que la dernière version de l'API ne dispose pas d'un point d'accès direct pour la suppression des travaux, vous pouvez gérer les travaux et leur cycle de vie à l'aide d'autres points d'accès. Utilisez le point de terminaison Supprimer un travail : POST /api/2.1/jobs/delete pour supprimer un travail et POST /api/2.1/jobs/runs/cancel pour annuler une exécution.

Suivi des exécutions, traitement des erreurs et journaux

Utilisez GET /api/2.1/jobs/runs/get pour contrôler l'état d'un travail. Récupérez les journaux ou traitez les erreurs à l'aide du champ run_state.

Groupes d'entreprises

Les grappes fournissent les ressources informatiques nécessaires à l'exécution des tâches. L'API simplifie la gestion du cycle de vie des clusters.

Créer et modifier des clusters

Créez un cluster avec POST /api/2.1/clusters/create. Par exemple, vous pouvez avoir ce qui suit dans le corps de la demande.

{
  "cluster_name": "Example Cluster",
  "spark_version": "12.2.x-scala2.12",
  "node_type_id": "i3.xlarge",
  "num_workers": 4
}

Ensuite, exécutez l'exemple de commande ci-dessous pour créer ce cluster.

curl -n -X POST \
-H 'Content-Type: application/json' \
-d '{"cluster_name": "My Cluster", "spark_version": "7.3.x-scala2.12", "node_type_id": "i3.xlarge", "num_workers": 2}' \
https://<databricks-instance>.cloud.databricks.com/api/2.1/clusters/create

Démarrage, redémarrage, redimensionnement et arrêt des clusters

Utilisez les API suivantes pour :

• Démarrage de la grappe: POST /api/2.1/clusters/start

• Redémarrez le cluster : POST /api/2.1/clusters/restart

• Redimensionner le cluster : PATCH /api/2.1/clusters/edit

• Mettez fin à la grappe : POST /api/2.1/clusters/delete

Meilleures pratiques pour les clusters éphémères ou polyvalents

Considérez les meilleures pratiques suivantes pour :

• Clusters éphémères : À utiliser pour les travaux qui nécessitent une allocation dynamique des ressources et qui peuvent être interrompus une fois le travail terminé.
• Des grappes à tout faire : Convient aux charges de travail continues où les clusters sont réutilisés pour plusieurs tâches.

DBFS (Databricks File System)

DBFS permet le stockage et la récupération de fichiers dans les Databricks.

Chargement et téléchargement de fichiers

Vous pouvez utiliser l'API POST /api/2.1/dbfs/upload pour télécharger des fichiers vers DBFS par morceaux (multipart) ou lorsque vous traitez des fichiers volumineux (>1MB). L'API GET /api/2.1/dbfs/read est utilisée pour télécharger des fichiers.

Lister les répertoires et gérer les opérations sur les fichiers volumineux

Utilisez GET /api/2.1/dbfs/list pour explorer les répertoires et gérer les fichiers de manière programmatique. Pour les téléchargements de fichiers volumineux, utilisez les téléchargements par morceaux avec POST /api/2.1/dbfs/put et le paramètre overwrite.

Secrets et authentification

L'API Secrets garantit un stockage et une récupération sécurisés des informations sensibles.

Stocker les informations d'identification en toute sécurité avec l'API Secrets

Utilisez le point de terminaison POST /api/2.1/secrets/create pour créer un nouveau secret afin de stocker des informations sensibles.

Par exemple, vous pouvez créer le corps de la demande en JSON comme suit :

{
  "scope": "my-scope",
  "key": "my-key",
  "string_value": "my-secret-value"
}

Créez ensuite le secret à l'aide de la commande suivante :

curl -n -X POST \
-H 'Content-Type: application/json' \
-d '{"scope": "my-scope", "key": "my-key", "string_value": "my-secret-value"}' \
https://<databricks-instance>.cloud.databricks.com/api/2.1/secrets/create

Récupération des secrets pour l'intégration

Utilisez le point de terminaison GET /API/2.1/secrets/get pour récupérer des secrets pour des intégrations externes.

Permissions et contrôles d'accès

La plateforme Databricks permet un contrôle granulaire de l'accès aux travaux et aux ressources.

Définition et mise à jour des autorisations

Utilisez le point de terminaison POST /api/2.1/permissions/jobs/update pour attribuer des rôles tels que propriétaires ou spectateurs. Par exemple, la charge utile suivante est utilisée pour mettre à jour les autorisations :

{
  "access_control_list": [
    {
      "user_name": "user@example.com",
      "permission_level": "CAN_MANAGE"
    }
  ]
}

Contrôle d'accès basé sur les rôles (RBAC)

Utilisez le contrôle d'accès basé sur les rôles (RBAC) intégré à Databricks pour gérer les autorisations entre les différents rôles au sein de votre organisation.

Databricks API Rate Limits, Error Handling, and Troubleshooting (Limites de taux de l'API Databricks, gestion des erreurs et dépannage)

Lorsque vous travaillez avec l'API REST de Databricks, il est important de prendre en compte les limites de débit, de gérer les erreurs avec élégance et de relever les défis courants pour garantir des performances fiables et des opérations fluides. Dans cette section, j'aborderai les stratégies permettant d'optimiser l'utilisation de l'API et de résoudre les problèmes de manière efficace.

Limites de taux

L'API Databricks applique des limites de taux pour garantir une utilisation équitable et maintenir la fiabilité du service. 

• Lignes directrices officielles concernant la fréquence des demandes: Cette limite restreint le nombre d'appels à l'API qu'un utilisateur peut effectuer en une minute. Le dépassement de cette limite peut entraîner des erreurs HTTP 429. Le nombre de requêtes par jour (RPD) plafonne le nombre total de requêtes qu'un utilisateur peut effectuer en 24 heures.
• Stratégies de traitement des 429 erreurs et approches de repli: Mettez en œuvre un mécanisme de réessai avec des délais exponentiels entre les réessais. Cela permet d'éviter de surcharger le serveur et de réduire la probabilité d'atteindre à nouveau la limite de débit immédiatement. Surveillez également les schémas de demande afin de regrouper les appels fréquents lorsque cela est possible et de réduire le nombre total de demandes.

Problèmes courants et solutions

Vous trouverez ci-dessous les problèmes courants que vous pouvez rencontrer avec les API de Databricks et la manière de les résoudre.

• Les pièges de l'authentification: Cette erreur est souvent due à des jetons non valides ou expirés. Pour résoudre ce problème, assurez-vous toujours que les jetons sont valides et correctement configurés. Vérifiez la validité du jeton et régénérez-le si nécessaire. Assurez-vous que les principaux services sont correctement configurés et que les rôles appropriés leur sont attribués dans Azure Databricks.
• Erreurs de format de données ou de JSON: Validez toujours les données JSON avant de les envoyer dans les demandes d'API. Utilisez des blocs try-catch pour gérer les erreurs d'analyse de manière élégante. L'utilisation d'outils tels que les validateurs JSON pour vérifier le format des données avant d'envoyer des requêtes vous aidera également à résoudre l'erreur.
• Débogage des échecs des travaux: Utilisez l'API Databricks pour récupérer les journaux de travail à des fins de débogage. Mettez en œuvre une journalisation et une surveillance robustes pour identifier rapidement les échecs des travaux et y remédier.

Goulets d'étranglement des performances

Si vous rencontrez des goulets d'étranglement au niveau des performances, vous devriez envisager les solutions suivantes :

• Minimiser l'overhead dans les appels répétés: Mettez en cache les données fréquemment consultées afin de réduire le nombre d'appels à l'API. Utilisez également les opérations par lots pour minimiser les frais généraux en combinant plusieurs demandes en un seul appel.
• Utilisation de la mise en cache ou des opérations par lots: Stockez les données fréquemment consultées dans une couche de cache afin de réduire les appels répétés à l'API. Vous pouvez également combiner plusieurs demandes en un seul appel d'API afin de réduire les frais généraux et d'améliorer les performances.

Flux de travail avancés et traitement parallèle

L'API REST de Databricks est très polyvalente et prend en charge aussi bien les flux de travail simples, à un seul thread, que les traitements parallèles complexes. En exploitant des flux de travail avancés, vous pouvez optimiser l'efficacité et vous intégrer de manière transparente à des systèmes externes. Voyons comment mettre en œuvre ces fonctionnalités.

Notez que vous devez toujours configurer vos variables d'environnement à l'aide de :

• DATABRICKS_HOST: Cette variable stocke l'URL de votre instance Databricks, qui est nécessaire pour construire les requêtes API.

• DATABRICKS_TOKEN: Cette variable contient votre jeton d'accès, ce qui simplifie le processus d'inclusion dans les appels à l'API.

Cas d'utilisation 1 : Ingestion d'API en mode monotâche

L'appel séquentiel d'un seul point de terminaison de l'API est efficace pour les petites tâches ou l'automatisation simple. Vous trouverez ci-dessous un exemple pratique utilisant la bibliothèque des requêtes en Python.

import requests
import os

# Set up environment variables
DATABRICKS_HOST = os.getenv("DATABRICKS_HOST")
DATABRICKS_TOKEN = os.getenv("DATABRICKS_TOKEN")

# API request to list jobs
url = f"{DATABRICKS_HOST}/api/2.1/jobs/list"
headers = {"Authorization": f"Bearer {DATABRICKS_TOKEN}"}

response = requests.get(url, headers=headers)
if response.status_code == 200:
    jobs = response.json().get("jobs", [])
    for job in jobs:
        print(f"Job ID: {job['job_id']}, Name: {job['settings']['name']}")
else:
    print(f"Error: {response.status_code} - {response.text}")

Cas d'utilisation 2 : Appels d'API parallèles ou distribués

Le traitement en parallèle peut améliorer considérablement l'efficacité de l'ingestion de données à grande échelle ou de la gestion de points d'extrémité multiples. L'exemple ci-dessous montre comment utiliser Apache Spark pour distribuer des appels d'API de manière simultanée.

from pyspark.sql import SparkSession
from pyspark.sql.functions import udf
import requests

# Initialize Spark session
spark = SparkSession.builder.appName("ParallelAPI").getOrCreate()

# Sample data for parallel calls
data = [{"job_id": 123}, {"job_id": 456}, {"job_id": 789}]
df = spark.createDataFrame(data)

# Define API call function
def fetch_job_details(job_id):
    url = f"{DATABRICKS_HOST}/api/2.1/jobs/get"
    headers = {"Authorization": f"Bearer {DATABRICKS_TOKEN}"}
    response = requests.get(url, headers=headers, params={"job_id": job_id})
    if response.status_code == 200:
        return response.json().get("settings", {}).get("name", "Unknown")
    return f"Error: {response.status_code}"

# Register UDF
fetch_job_details_udf = udf(fetch_job_details)

# Apply UDF to DataFrame
results_df = df.withColumn("job_name", fetch_job_details_udf("job_id"))
results_df.show()

Tenez compte des conseils suivants pour trouver des compromis en matière d'évolutivité et de coûts.

• Évolutivité: Spark vous permet d'évoluer horizontalement en ajoutant des nœuds supplémentaires à votre cluster. Cette fonction est particulièrement utile pour traiter de gros volumes de demandes d'API.
• Compromis de coûts: Si le traitement parallèle réduit le temps d'exécution, il augmente l'utilisation des ressources et les coûts. Veillez à ce que la configuration de votre grappe permette de concilier les besoins de performance et les contraintes de coût.
• Conseils pour la configuration des clusters: Choisissez des nœuds qui équilibrent l'unité centrale et la mémoire en fonction de votre charge de travail. Vous devez également veiller à ce qu'il y ait suffisamment de travailleurs pour traiter le volume de demandes sans submerger le cluster. Optimisez les paramètres de Spark, tels que spark.executor.memory et spark.driver.memory, pour éviter les problèmes de mémoire.

Orchestration et intégration

L'intégration de Databricks avec des orchestrateurs externes comme Airflow ou Dagster vous permet de gérer des flux de travail complexes et d'automatiser l'exécution des tâches sur différents systèmes. L'exemple ci-dessous montre comment utiliser Airflow pour déclencher un travail Databricks.

from airflow import DAG
from airflow.providers.databricks.operators.databricks import DatabricksRunNowOperator
from datetime import datetime

# Define default arguments for the DAG
default_args = {
    "owner": "airflow",  # Owner of the DAG
    "depends_on_past": False,  # Do not depend on past DAG runs
    "retries": 1,  # Number of retry attempts in case of failure
}

# Define the DAG
with DAG(
    dag_id="databricks_job_trigger",  # Unique DAG ID
    default_args=default_args,  # Apply default arguments
    schedule_interval=None,  # Manually triggered DAG (no schedule)
    start_date=datetime(2023, 1, 1),  # DAG start date
) as dag:

    # Task to trigger a Databricks job
    run_job = DatabricksRunNowOperator(
        task_id="run_databricks_job",  # Unique task ID
        databricks_conn_id="databricks_default",  # Connection ID for Databricks
        job_id=12345,  # Replace with the actual Databricks job ID
    )

    # Set task dependencies (if needed)
    run_job

Pour les pipelines CI/CD, des outils comme l'intégration de Git avec Databricks peuvent automatiser le déploiement du code et des ressources dans différents environnements. Cela permet de s'assurer que les changements sont testés et validés avant d'être déployés en production.

# Example of using Databricks REST API in a CI/CD pipeline
import requests

def deploy_to_production():
    # Assuming you have a personal access token
    token = "your_token_here"
    headers = {"Authorization": f"Bearer {token}"}
    
    # Update job or cluster configurations as needed
    url = "https://your-databricks-instance.cloud.databricks.com/api/2.1/jobs/update"
    payload = {"job_id": "123456789", "new_settings": {"key": "value"}}
    
    response = requests.post(url, headers=headers, json=payload)
    if response.status_code == 200:
        print("Deployment successful.")
    else:
        print(f"Deployment failed. Status code: {response.status_code}")

Exemple pratique : Création d'un pipeline en plusieurs étapes

Maintenant que nous avons vu les différentes applications de l'API Databricks, permettez-moi de vous présenter un exemple de pipeline automatisé. Ce pipeline va ingérer des données à partir d'une API externe, transformer les données dans Databricks, puis écrire les résultats dans un tableau Databricks. Ce scénario est un flux de travail de bout en bout typique des tâches modernes d'ingénierie des données. Si vous avez besoin de rafraîchir vos connaissances sur les principales fonctionnalités de Databricks, y compris l'ingestion de données, je vous recommande de consulter notre tutoriel sur les 7 concepts incontournables pour tout spécialiste des données.

Authentification via un jeton d'accès personnel

Pour interagir avec l'API REST de Databricks, vous devez vous authentifier à l'aide d'un jeton d'accès personnel (PAT). Suivez les étapes suivantes pour générer le PAT. 

• Connectez-vous à votre espace de travail Databricks.

Espace de travail Databricks. Image par l'auteur.

• Allez dans Réglages > Réglages utilisateur > Jetons d' accès.

Générer un jeton d'accès dans Databricks. Image par l'auteur.

• Générez un nouveau jeton et sauvegardez-le en toute sécurité.

Si vous avez besoin de rafraîchir vos connaissances sur Databricks SQL, je vous recommande de lire notre tutoriel Databricks SQL pour apprendre à configurer SQL Warehouse à partir de l'interface web de Databricks.

Configurez les variables d'environnement en utilisant l'une des méthodes suivantes :

Utilisation du terminal

export DATABRICKS_HOST=https://<your-databricks-instance>
export DATABRICKS_TOKEN=<your-access-token>

Utilisation de la bibliothèque de requêtes de Python pour les appels d'API

import os
import requests

DATABRICKS_HOST = os.getenv("DATABRICKS_HOST")
DATABRICKS_TOKEN = os.getenv("DATABRICKS_TOKEN")

headers = {"Authorization": f"Bearer {DATABRICKS_TOKEN}"}

Configurer un job Databricks avec plusieurs tâches

Un travail Databricks peut consister en plusieurs tâches, chacune effectuant une étape du pipeline. Pour cet exemple, considérez ce qui suit :

• Tâche 1 : Récupérer des données à partir d'une API externe et les écrire dans DBFS.
• Tâche 2 : Transformez les données dans un carnet Databricks.
• Tâche 3 : Inscrivez les données transformées dans un tableau Delta.

L'exemple suivant utilise le point de terminaison POST /api/2.1/jobs/create pour créer le travail.

{
  "name": "Multi-Step Pipeline",
  "tasks": [
    {
      "task_key": "fetch_data",
      "existing_cluster_id": "your-cluster-id",
      "notebook_task": {
        "notebook_path": "/Users/example_user/fetch_data"
      }
    },
    {
      "task_key": "transform_data",
      "depends_on": [{"task_key": "fetch_data"}],
      "existing_cluster_id": "your-cluster-id",
      "notebook_task": {
        "notebook_path": "/Users/example_user/transform_data"
      }
    },
    {
      "task_key": "write_results",
      "depends_on": [{"task_key": "transform_data"}],
      "existing_cluster_id": "your-cluster-id",
      "notebook_task": {
        "notebook_path": "/Users/example_user/write_results"
      }
    }
  ]
}

Déclenchement du flux de travail et récupération des résultats du travail/des sorties

Déclenchez le travail en utilisant POST /api/2.1/jobs/run-now

curl -n -X POST \
https://$DATABRICKS_HOST/api/2.1/jobs/run-now?job_id=your_job_id

Surveillez l'état d'avancement des travaux à l'aide du site GET /api/2.1/jobs/runs/get et du site run_id.

response = requests.get(f"{DATABRICKS_HOST}/api/2.1/jobs/runs/get", headers=headers, params={"run_id": run_id})
print(response.json())

Accédez aux journaux de sortie ou aux résultats des tâches en utilisant GET /api/2.1/jobs/runs/get-output.

Journalisation et gestion des erreurs

Pour la journalisation, configurez les journaux de travail pour qu'ils soient écrits dans DBFS ou dans un outil de surveillance tel que Datadog ou Splunk. Incluez également un enregistrement détaillé dans le carnet de notes de chaque tâche pour une meilleure traçabilité.

De même, mettez en place des blocs "try-except" dans les carnets de notes afin d'attraper et d'enregistrer les exceptions. Utilisez l'API Databricks Jobs pour récupérer les journaux des travaux afin de déboguer les échecs. L'exemple ci-dessous illustre la gestion des erreurs dans un bloc-notes.

try:
    # Code to fetch data from API
    response = requests.get(api_url)
    # Process data
except Exception as e:
    print(f"An error occurred: {e}")
    # Log error and exit

Vous pouvez également intégrer des notifications par e-mail ou Slack à l'aide de l'API Databricks Alerts ou d'outils tiers.

Bonnes pratiques et recommandations

La mise en œuvre des meilleures pratiques dans les Databricks permet de renforcer considérablement la sécurité, de réduire les coûts et d'améliorer la fiabilité globale du système. Vous trouverez ci-dessous les stratégies clés que vous devez prendre en compte lors de l'utilisation de l'API Databricks et les domaines critiques.

Sécurité et gouvernance

Évitez de stocker des jetons simples dans des codes ou des carnets. Au lieu de cela, utilisez Databricks Secret pour stocker des informations sensibles telles que des clés API ou des informations d'identification en toute sécurité à l'aide de l'API Databricks Secrets. Cela permet de s'assurer que les données sensibles ne sont pas exposées en texte clair dans le code ou les carnets. Utilisez toujours des variables d'environnement pour transmettre des jetons ou des secrets à des scripts, mais veillez à ce que ces variables soient gérées de manière sécurisée et ne soient pas enregistrées dans le système de contrôle des versions.

Utilisez le contrôle d'accès basé sur les rôles (RBAC) pour définir les autorisations au niveau de l'espace de travail, du cluster et du travail et limiter l'accès aux API sensibles aux seuls utilisateurs ou comptes de service nécessaires.

Gestion des coûts

Pour une gestion efficace des coûts, envisagez d'utiliser des grappes à nœud unique pour les tâches continues et à faible charge. Cependant, ils peuvent être rentables s'ils ne sont pas pleinement utilisés. En outre, des grappes d'emplois éphémères sont automatiquement créées et supprimées pour les emplois, ce qui garantit que les ressources ne sont pas inutilisées.

En raison de la tarification dynamique des ressources du cloud, la programmation en dehors des heures de pointe peut réduire considérablement les coûts. Utilisez l'API "Jobs" pour définir des programmes de travail pendant des fenêtres temporelles rentables.

Enfin, surveillez l'utilisation de la grappe en vérifiant régulièrement son taux d'utilisation afin de vous assurer que les ressources ne sont pas gaspillées. Configurez les clusters pour qu'ils s'arrêtent automatiquement après un temps d'inactivité spécifié afin d'éviter les coûts inutiles.

Essais et contrôle continus

Pour les tests automatisés et les définitions de tâches, utilisez des tests unitaires pour mettre en œuvre des tests unitaires pour la logique des tâches afin de détecter rapidement les erreurs. Surveillez les exécutions de tâches et consignez les mesures de performances pour exploiter l'API des tâches afin de suivre les exécutions de tâches de manière programmatique et d'analyser les données d'exécution historiques :

Conclusion et prochaines étapes

L'utilisation de l'API REST de Databricks permet aux équipes d'automatiser les flux de travail, d'optimiser les coûts et de s'intégrer de manière transparente aux systèmes externes, transformant ainsi la manière dont les pipelines de données et les analyses sont gérés. Je vous encourage à commencer par tester un appel API de base, tel que la création d'un emploi, afin de vous familiariser avec la plateforme. Vous pouvez également explorer d'autres sujets avancés comme Unity Catalog pour une gouvernance fine ou vous plonger dans des cas d'utilisation de streaming en temps réel.

Je vous recommande également de consulter les documents officiels de l'API REST de Databricks pour répondre aux questions en suspens, et d'explorer les dépôts GitHub sur la CLI Databricks et le SDK Databricks pour Python afin d'en savoir plus sur le développement rationalisé.

Si vous souhaitez explorer les concepts fondamentaux de Databricks, je vous recommande vivement de suivre notre cours Introduction à Databricks. Ce cours vous apprend à connaître Databricks en tant que solution d'entreposage de données pour la Business Intelligence. Je vous recommande également de consulter notre article de blog sur les certifications Databricks en 2024 pour savoir comment obtenir les certifications Databricks, explorer les avantages professionnels et choisir la bonne certification en fonction de vos objectifs de carrière.