Exemples d'APIAPI examples

Cet article contient des exemples qui montrent comment utiliser l’API REST Azure Databricks 2,0.This article contains examples that demonstrate how to use the Azure Databricks REST API 2.0.

Dans les exemples suivants, remplacez <databricks-instance> par l’URL d’espace de travail de votre déploiement Azure Databricks.In the following examples, replace <databricks-instance> with the workspace URL of your Azure Databricks deployment. <databricks-instance> doit commencer par adb-.<databricks-instance> should start with adb-. N’utilisez pas l’URL régionale dépréciée qui commence par <azure-region-name>.Do not use the deprecated regional URL starting with <azure-region-name>. Elle peut ne pas fonctionner pour les nouveaux espaces de travail, sera moins fiable et montrera des performances inférieures à celles des URL par espace de travail.It may not work for new workspaces, will be less reliable, and will exhibit lower performance than per-workspace URLs.

AuthentificationAuthentication

Pour savoir comment s’authentifier auprès de l’API REST, consultez authentification à l’aide de Azure Databricks des jetons d’accès personnels et authentifiez-vous à l’aide de Azure Active Directory jetons.To learn how to authenticate to the REST API, review Authentication using Azure Databricks personal access tokens and Authenticate using Azure Active Directory tokens.

Les exemples de cet article supposent que vous utilisez Azure Databricks des jetons d’accès personnels.The examples in this article assume you are using Azure Databricks personal access tokens. Dans les exemples suivants, remplacez <your-token> par votre jeton d’accès personnel.In the following examples, replace <your-token> with your personal access token. Les curl exemples supposent que vous stockez Azure Databricks informations d’identification de l’API sous . netrc.The curl examples assume that you store Azure Databricks API credentials under .netrc. Les exemples python utilisent l’authentification du porteur .The Python examples use Bearer authentication. Bien que les exemples montrent comment stocker le jeton dans le code, pour tirer parti des informations d’identification en toute sécurité dans Azure Databricks, nous vous recommandons de suivre le Guide de l’utilisateur de la gestion des secrets .Although the examples show storing the token in the code, for leveraging credentials safely in Azure Databricks, we recommend that you follow the Secret management user guide.

Pour obtenir des exemples d’utilisation de l’authentification à l’aide de Azure Active Directory jetons, consultez les Articles de cette section.For examples that use Authenticate using Azure Active Directory tokens, see the articles in that section.

Obtenir une liste gzippé de clusters Get a gzipped list of clusters

curl -n -H "Accept-Encoding: gzip" https://<databricks-instance>/api/2.0/clusters/list > clusters.gz

Charger un fichier volumineux dans dBFS Upload a big file into DBFS

La quantité de données chargées par un appel d’API unique ne peut pas dépasser 1 Mo.The amount of data uploaded by single API call cannot exceed 1MB. Pour télécharger un fichier dont la taille est supérieure à 1 Mo à DBFS, utilisez l’API de streaming, qui est une combinaison de create , addBlock et close .To upload a file that is larger than 1MB to DBFS, use the streaming API, which is a combination of create, addBlock, and close.

Voici un exemple d’exécution de cette action à l’aide de Python.Here is an example of how to perform this action using Python.

import json
import requests
import base64

DOMAIN = '<databricks-instance>'
TOKEN = '<your-token>'
BASE_URL = 'https://%s/api/2.0/dbfs/' % (DOMAIN)

def dbfs_rpc(action, body):
  """ A helper function to make the DBFS API request, request/response is encoded/decoded as JSON """
  response = requests.post(
    BASE_URL + action,
    headers={'Authorization': 'Bearer %s' % TOKEN },
    json=body
  )
  return response.json()

# Create a handle that will be used to add blocks
handle = dbfs_rpc("create", {"path": "/temp/upload_large_file", "overwrite": "true"})['handle']
with open('/a/local/file') as f:
  while True:
    # A block can be at most 1MB
    block = f.read(1 << 20)
    if not block:
        break
    data = base64.standard_b64encode(block)
    dbfs_rpc("add-block", {"handle": handle, "data": data})
# close the handle to finish uploading
dbfs_rpc("close", {"handle": handle})

Créer un cluster python 3 (Databricks Runtime 5,5 LTS) Create a Python 3 cluster (Databricks Runtime 5.5 LTS)

Notes

Python 3 est la version par défaut de Python dans Databricks Runtime 6,0 et versions ultérieures.Python 3 is the default version of Python in Databricks Runtime 6.0 and above.

L’exemple suivant montre comment lancer un cluster python 3 à l’aide de l’API REST Databricks et de la bibliothèque http python requêtes :The following example shows how to launch a Python 3 cluster using the Databricks REST API and the requests Python HTTP library:

import requests

DOMAIN = '<databricks-instance>'
TOKEN = '<your-token>'

response = requests.post(
  'https://%s/api/2.0/clusters/create' % (DOMAIN),
  headers={'Authorization': 'Bearer %s' % TOKEN},
  json={
    "cluster_name": "my-cluster",
    "spark_version": "5.5.x-scala2.11",
    "node_type_id": "Standard_D3_v2",
    "spark_env_vars": {
      "PYSPARK_PYTHON": "/databricks/python3/bin/python3",
    }
  }
)

if response.status_code == 200:
  print(response.json()['cluster_id'])
else:
  print("Error launching cluster: %s: %s" % (response.json()["error_code"], response.json()["message"]))

Créer un cluster à concurrence élevée Create a High Concurrency cluster

L’exemple suivant montre comment lancer un cluster en mode d' accès concurrentiel élevé à l’aide de l’API REST Databricks :The following example shows how to launch a High Concurrency mode cluster using the Databricks REST API:

curl -n -X POST -H 'Content-Type: application/json' -d '{
  "cluster_name": "high-concurrency-cluster",
  "spark_version": "7.3.x-scala2.12",
  "node_type_id": "Standard_D3_v2",
  "spark_conf":{
        "spark.databricks.cluster.profile":"serverless",
        "spark.databricks.repl.allowedLanguages":"sql,python,r"
     },
   "custom_tags":{
        "ResourceClass":"Serverless"
     },
       "autoscale":{
        "min_workers":1,
        "max_workers":2
     },
  "autotermination_minutes":10
}' https://<databricks-instance>/api/2.0/clusters/create

Exemples d’API Jobs Jobs API examples

Cette section montre comment créer des travaux Python, Spark Submit et JAR, et comment exécuter le travail JAR et afficher sa sortie.This section shows how to create Python, spark submit, and JAR jobs and run the JAR job and view its output.

Créer un travail pythonCreate a Python job

Cet exemple montre comment créer un travail Python.This example shows how to create a Python job. Elle utilise l’estimation Apache Spark python Spark pi.It uses the Apache Spark Python Spark Pi estimation.

  1. Téléchargez le fichier python contenant l’exemple et chargez-le dans le système de fichiers Databricks (dBFS) à l’aide de l' interface CLI Databricks.Download the Python file containing the example and upload it to Databricks File System (DBFS) using the Databricks CLI.

    dbfs cp pi.py dbfs:/docs/pi.py
    
  2. Créer le travail.Create the job. Les exemples suivants montrent comment créer un travail à l’aide de Databricks Runtime et Databricks Light.The following examples demonstrate how to create a job using Databricks Runtime and Databricks Light.

    Databricks RuntimeDatabricks Runtime

    curl -n -X POST -H 'Content-Type: application/json' -d \
    '{
      "name": "SparkPi Python job",
      "new_cluster": {
        "spark_version": "7.3.x-scala2.12",
        "node_type_id": "Standard_D3_v2",
        "num_workers": 2
      },
      "spark_python_task": {
        "python_file": "dbfs:/pi.py",
        "parameters": [
          "10"
        ]
      }
    }' https://<databricks-instance>/api/2.0/jobs/create
    

    Databricks LightDatabricks Light

    curl -n -X POST -H 'Content-Type: application/json' -d
    '{
        "name": "SparkPi Python job",
        "new_cluster": {
         "spark_version": "apache-spark-2.4.x-scala2.11",
         "node_type_id": "Standard_D3_v2",
         "num_workers": 2
        },
        "spark_python_task": {
         "python_file": "dbfs:/pi.py",
         "parameters": [
           "10"
         ]
      }
    }' https://<databricks-instance>/api/2.0/jobs/create
    

Créer un travail Spark -Submit Create a spark-submit job

Cet exemple montre comment créer un travail d’envoi Spark.This example shows how to create a spark-submit job. Elle utilise l' exemple Apache Spark SparkPi.It uses the Apache Spark SparkPi example.

  1. Téléchargez le fichier jar contenant l’exemple et chargez le fichier jar dans le système de fichiers Databricks (dBFS) à l’aide de l' interface CLI Databricks.Download the JAR containing the example and upload the JAR to Databricks File System (DBFS) using the Databricks CLI.

    dbfs cp SparkPi-assembly-0.1.jar dbfs:/docs/sparkpi.jar
    
  2. Créer le travail.Create the job.

    curl -n \
    -X POST -H 'Content-Type: application/json' \
    -d '{
         "name": "SparkPi spark-submit job",
         "new_cluster": {
           "spark_version": "7.3.x-scala2.12",
           "node_type_id": "Standard_DS3_v2",
           "num_workers": 2
           },
        "spark_submit_task": {
           "parameters": [
             "--class",
             "org.apache.spark.examples.SparkPi",
             "dbfs:/docs/sparkpi.jar",
             "10"
          ]
        }
    }' https://<databricks-instance>/api/2.0/jobs/create
    

Créer et exécuter une tâche Spark-submit pour les scripts R Create and run a spark-submit job for R scripts

Cet exemple montre comment créer une tâche Spark-submit pour exécuter des scripts R.This example shows how to create a spark-submit job to run R scripts.

  1. Chargez le fichier R dans le système de fichiers Databricks (dBFS) à l’aide de l' interface CLI Databricks.Upload the R file to Databricks File System (DBFS) using the Databricks CLI.

    dbfs cp your_code.R dbfs:/path/to/your_code.R
    

    Si le code utilise Sparkr, il doit d’abord installer le package.If the code uses SparkR, it must first install the package. Databricks Runtime contient le code source Sparkr.Databricks Runtime contains the SparkR source code. Installez le package Sparkr à partir de son répertoire local, comme indiqué dans l’exemple suivant :Install the SparkR package from its local directory as shown in the following example:

    install.packages("/databricks/spark/R/pkg", repos = NULL)
    library(SparkR)
    
    sparkR.session()
    n <- nrow(createDataFrame(iris))
    write.csv(n, "/dbfs/path/to/num_rows.csv")
    

    Databricks Runtime installe la dernière version de sparklyr à partir de CRAN.Databricks Runtime installs the latest version of sparklyr from CRAN. Si le code utilise sparklyr, vous devez spécifier l’URL du maître Spark dans spark_connect .If the code uses sparklyr, You must specify the Spark master URL in spark_connect. Pour former l’URL du maître Spark, utilisez la SPARK_LOCAL_IP variable d’environnement pour accéder à l’adresse IP et utilisez le port par défaut 7077.To form the Spark master URL, use the SPARK_LOCAL_IP environment variable to get the IP, and use the default port 7077. Par exemple :For example:

    library(sparklyr)
    
    master <- paste("spark://", Sys.getenv("SPARK_LOCAL_IP"), ":7077", sep="")
    sc <- spark_connect(master)
    iris_tbl <- copy_to(sc, iris)
    write.csv(iris_tbl, "/dbfs/path/to/sparklyr_iris.csv")
    
  2. Créer le travail.Create the job.

    curl -n \
    -X POST -H 'Content-Type: application/json' \
    -d '{
         "name": "R script spark-submit job",
         "new_cluster": {
           "spark_version": "7.3.x-scala2.12",
           "node_type_id": "Standard_DS3_v2",
           "num_workers": 2
           },
        "spark_submit_task": {
           "parameters": [ "dbfs:/path/to/your_code.R" ]
           }
    }' https://<databricks-instance>/api/2.0/jobs/create
    

    Cela retourne un job-id que vous pouvez ensuite utiliser pour exécuter le travail.This returns a job-id that you can then use to run the job.

  3. Exécutez la tâche à l’aide de l' job-id .Run the job using the job-id.

    curl -n \
    -X POST -H 'Content-Type: application/json' \
    -d '{ "job_id": <job-id> }' https://<databricks-instance>/api/2.0/jobs/run-now
    

Créer et exécuter un travail jar Create and run a JAR job

Cet exemple montre comment créer et exécuter un travail JAR.This example shows how to create and run a JAR job. Elle utilise l' exemple Apache Spark SparkPi.It uses the Apache Spark SparkPi example.

  1. Téléchargez le fichier jar contenant l’exemple.Download the JAR containing the example.

  2. Téléchargez le fichier JAR sur votre instance de Azure Databricks à l’aide de l’API :Upload the JAR to your Azure Databricks instance using the API:

    curl -n \
    -F filedata=@"SparkPi-assembly-0.1.jar" \
    -F path="/docs/sparkpi.jar" \
    -F overwrite=true \
    https://<databricks-instance>/api/2.0/dbfs/put
    

    Un appel réussi retourne {} .A successful call returns {}. Dans le cas contraire, un message d’erreur s’affiche.Otherwise you will see an error message.

  3. Obtenir la liste de toutes les versions Spark avant de créer votre travail.Get a list of all Spark versions prior to creating your job.

    curl -n https://<databricks-instance>/api/2.0/clusters/spark-versions
    

    Cet exemple utilise 7.3.x-scala2.12.This example uses 7.3.x-scala2.12. Pour plus d’informations sur les versions de cluster Spark, consultez chaînes de version du runtime .See Runtime version strings for more information about Spark cluster versions.

  4. Créer le travail.Create the job. Le fichier JAR est spécifié en tant que bibliothèque et le nom de la classe principale est référencé dans la tâche JAR Spark.The JAR is specified as a library and the main class name is referenced in the Spark JAR task.

    curl -n -X POST -H 'Content-Type: application/json' \
    -d '{
          "name": "SparkPi JAR job",
          "new_cluster": {
            "spark_version": "7.3.x-scala2.12",
            "node_type_id": "Standard_DS3_v2",
            "num_workers": 2
            },
         "libraries": [{"jar": "dbfs:/docs/sparkpi.jar"}],
         "spark_jar_task": {
            "main_class_name":"org.apache.spark.examples.SparkPi",
            "parameters": "10"
            }
    }' https://<databricks-instance>/api/2.0/jobs/create
    

    Cela retourne un job-id que vous pouvez ensuite utiliser pour exécuter le travail.This returns a job-id that you can then use to run the job.

  5. Exécutez la tâche à l’aide de run now :Run the job using run now:

    curl -n \
    -X POST -H 'Content-Type: application/json' \
    -d '{ "job_id": <job-id> }' https://<databricks-instance>/api/2.0/jobs/run-now
    
  6. Accédez à https://<databricks-instance>/#job/<job-id> et vous serez en mesure de voir votre travail en cours d’exécution.Navigate to https://<databricks-instance>/#job/<job-id> and you’ll be able to see your job running.

  7. Vous pouvez également vérifier à partir de l’API à l’aide des informations retournées par la requête précédente.You can also check on it from the API using the information returned from the previous request.

    curl -n https://<databricks-instance>/api/2.0/jobs/runs/get?run_id=<run-id> | jq
    

    Qui doit retourner un résultat similaire à ce qui suit :Which should return something like:

    {
      "job_id": 35,
      "run_id": 30,
      "number_in_job": 1,
      "original_attempt_run_id": 30,
      "state": {
        "life_cycle_state": "TERMINATED",
        "result_state": "SUCCESS",
        "state_message": ""
      },
      "task": {
        "spark_jar_task": {
          "jar_uri": "",
          "main_class_name": "org.apache.spark.examples.SparkPi",
          "parameters": [
            "10"
          ],
          "run_as_repl": true
        }
      },
      "cluster_spec": {
        "new_cluster": {
          "spark_version": "7.3.x-scala2.12",
          "node_type_id": "<node-type>",
          "enable_elastic_disk": false,
          "num_workers": 1
        },
        "libraries": [
          {
            "jar": "dbfs:/docs/sparkpi.jar"
          }
        ]
      },
      "cluster_instance": {
        "cluster_id": "0412-165350-type465",
        "spark_context_id": "5998195893958609953"
      },
      "start_time": 1523552029282,
      "setup_duration": 211000,
      "execution_duration": 33000,
      "cleanup_duration": 2000,
      "trigger": "ONE_TIME",
      "creator_user_name": "...",
      "run_name": "SparkPi JAR job",
      "run_page_url": "<databricks-instance>/?o=3901135158661429#job/35/run/1",
      "run_type": "JOB_RUN"
    }
    
  8. Pour afficher la sortie du travail, accédez à la page Détailsde l’exécution du travail.To view the job output, visit the job run details page.

    Executing command, time = 1523552263909.
    Pi is roughly 3.13973913973914
    

Exemple de création de cluster activé pour le contrôle d’accès aux tables Create cluster enabled for table access control example

Pour créer un cluster activé pour le contrôle d’accès à la table, spécifiez la spark_conf propriété suivante dans le corps de votre requête :To create a cluster enabled for table access control, specify the following spark_conf property in your request body:

curl -X POST https://<databricks-instance>/api/2.0/clusters/create -d'
{
  "cluster_name": "my-cluster",
  "spark_version": "7.3.x-scala2.12",
  "node_type_id": "Standard_DS3_v2",
  "spark_conf": {
    "spark.databricks.acl.dfAclsEnabled":true,
    "spark.databricks.repl.allowedLanguages": "python,sql"
  },
  "num_workers": 1,
  "custom_tags":{
     "costcenter":"Tags",
     "applicationname":"Tags1"
  }
}'

Exemples de remise de journal de cluster Cluster log delivery examples

Bien que vous puissiez afficher les journaux du pilote Spark et de l’exécuteur dans l’interface utilisateur Spark, Azure Databricks pouvez également remettre les journaux à des destinations DBFS.While you can view the Spark driver and executor logs in the Spark UI, Azure Databricks can also deliver the logs to DBFS destinations. Consultez les exemples suivants.See the following examples.

Créer un cluster avec des journaux remis à un emplacement DBFSCreate a cluster with logs delivered to a DBFS location

La commande bouclé suivante crée un cluster nommé cluster_log_dbfs et demande Azure Databricks d’envoyer ses journaux à dbfs:/logs avec l’ID de cluster en tant que préfixe de chemin d’accès.The following cURL command creates a cluster named cluster_log_dbfs and requests Azure Databricks to sends its logs to dbfs:/logs with the cluster ID as the path prefix.

curl -n -X POST -H 'Content-Type: application/json' -d \
'{
  "cluster_name": "cluster_log_dbfs",
  "spark_version": "7.3.x-scala2.12",
  "node_type_id": "Standard_D3_v2",
  "num_workers": 1,
  "cluster_log_conf": {
    "dbfs": {
      "destination": "dbfs:/logs"
    }
  }
}' https://<databricks-instance>/api/2.0/clusters/create

La réponse doit contenir l’ID de cluster :The response should contain the cluster ID:

{"cluster_id":"1111-223344-abc55"}

Après la création du cluster, Azure Databricks synchronise les fichiers journaux à la destination toutes les 5 minutes.After cluster creation, Azure Databricks syncs log files to the destination every 5 minutes. Il télécharge les journaux des pilotes vers dbfs:/logs/1111-223344-abc55/driver et les journaux de l’exécuteur dbfs:/logs/1111-223344-abc55/executor .It uploads driver logs to dbfs:/logs/1111-223344-abc55/driver and executor logs to dbfs:/logs/1111-223344-abc55/executor.

Vérifier l’état de remise du journalCheck log delivery status

Vous pouvez récupérer des informations de cluster avec l’état de remise des journaux via l’API :You can retrieve cluster information with log delivery status via API:

curl -n -H 'Content-Type: application/json' -d \
'{
  "cluster_id": "1111-223344-abc55"
}' https://<databricks-instance>/api/2.0/clusters/get

Si le dernier lot de chargement du journal a réussi, la réponse doit contenir uniquement l’horodateur de la dernière tentative :If the latest batch of log upload was successful, the response should contain only the timestamp of the last attempt:

{
  "cluster_log_status": {
    "last_attempted": 1479338561
  }
}

En cas d’erreur, le message d’erreur s’affiche dans la réponse :In case of errors, the error message would appear in the response:

{
  "cluster_log_status": {
    "last_attempted": 1479338561,
    "last_exception": "Exception: Access Denied ..."
  }
}

Exemples d’espaces de travail Workspace examples

Voici quelques exemples d’utilisation de l’API de l’espace de travail pour répertorier, obtenir des informations sur, créer, supprimer, exporter et importer des objets d’espace de travail.Here are some examples for using the Workspace API to list, get info about, create, delete, export, and import workspace objects.

Répertorier un bloc-notes ou un dossierList a notebook or a folder

La commande bouclé suivante répertorie un chemin d’accès dans l’espace de travail.The following cURL command lists a path in the workspace.

curl -n -X GET -H 'Content-Type: application/json' -d \
'{
  "path": "/Users/user@example.com/"
}' https://<databricks-instance>/api/2.0/workspace/list

La réponse doit contenir une liste d’États :The response should contain a list of statuses:

{
  "objects": [
    {
     "object_type": "DIRECTORY",
     "path": "/Users/user@example.com/folder"
    },
    {
     "object_type": "NOTEBOOK",
     "language": "PYTHON",
     "path": "/Users/user@example.com/notebook1"
    },
    {
     "object_type": "NOTEBOOK",
     "language": "SCALA",
     "path": "/Users/user@example.com/notebook2"
    }
  ]
}

Si le chemin d’accès est un bloc-notes, la réponse contient un tableau contenant l’état du bloc-notes d’entrée.If the path is a notebook, the response contains an array containing the status of the input notebook.

Obtenir des informations sur un bloc-notes ou un dossierGet information about a notebook or a folder

La commande bouclé suivante obtient l’état d’un chemin d’accès dans l’espace de travail.The following cURL command gets the status of a path in the workspace.

curl -n  -X GET -H 'Content-Type: application/json' -d \
'{
  "path": "/Users/user@example.com/"
}' https://<databricks-instance>/api/2.0/workspace/get-status

La réponse doit contenir l’état du chemin d’accès d’entrée :The response should contain the status of the input path:

{
  "object_type": "DIRECTORY",
  "path": "/Users/user@example.com"
}

Créer un dossierCreate a folder

La commande bouclé suivante crée un dossier.The following cURL command creates a folder. Il crée le dossier de manière récursive mkdir -p .It creates the folder recursively like mkdir -p. Si le dossier existe déjà, il ne fait rien.If the folder already exists, it will do nothing and succeed.

curl -n -X POST -H 'Content-Type: application/json' -d \
'{
  "path": "/Users/user@example.com/new/folder"
}' https://<databricks-instance>/api/2.0/workspace/mkdirs

Si la demande est réussie, une chaîne JSON vide est retournée.If the request succeeds, an empty JSON string will be returned.

Supprimer un bloc-notes ou un dossierDelete a notebook or folder

La commande bouclé suivante supprime un bloc-notes ou un dossier.The following cURL command deletes a notebook or folder. Vous pouvez activer recursive pour supprimer de manière récursive un dossier non vide.You can enable recursive to recursively delete a non-empty folder.

curl -n -X POST -H 'Content-Type: application/json' -d \
'{
  "path": "/Users/user@example.com/new/folder",
  "recursive": "false"
}' https://<databricks-instance>/api/2.0/workspace/delete

Si la demande est réussie, une chaîne JSON vide est retournée.If the request succeeds, an empty JSON string is returned.

Exporter un bloc-notes ou un dossier Export a notebook or folder

La commande de boucle suivante exporte un bloc-notes.The following cURL command exports a notebook. Les blocs-notes peuvent être exportés dans les formats suivants : SOURCE , HTML , JUPYTER , DBC .Notebooks can be exported in the following formats: SOURCE, HTML, JUPYTER, DBC. Un dossier ne peut être exporté qu’en tant que DBC .A folder can be exported only as DBC.

curl -n  -X GET -H 'Content-Type: application/json' \
'{
  "path": "/Users/user@example.com/notebook",
  "format": "SOURCE"
}' https://<databricks-instance>/api/2.0/workspace/export

La réponse contient le contenu du bloc-notes encodé en base64.The response contains base64 encoded notebook content.

{
  "content": "Ly8gRGF0YWJyaWNrcyBub3RlYm9vayBzb3VyY2UKcHJpbnQoImhlbGxvLCB3b3JsZCIpCgovLyBDT01NQU5EIC0tLS0tLS0tLS0KCg=="
}

Vous pouvez également télécharger le bloc-notes exporté directement.Alternatively, you can download the exported notebook directly.

curl -n -X GET "https://<databricks-instance>/api/2.0/workspace/export?format=SOURCE&direct_download=true&path=/Users/user@example.com/notebook"

La réponse sera le contenu du bloc-notes exporté.The response will be the exported notebook content.

Importer un bloc-notes ou un répertoire Import a notebook or directory

La commande bouclé suivante importe un bloc-notes dans l’espace de travail.The following cURL command imports a notebook in the workspace. Les formats multiples ( SOURCE , HTML , JUPYTER , DBC ) sont pris en charge.Multiple formats (SOURCE, HTML, JUPYTER, DBC) are supported. Si format est SOURCE , vous devez spécifier language .If the format is SOURCE, you must specify language. Le content paramètre contient du contenu de bloc-notes encodé en base64.The content parameter contains base64 encoded notebook content. Vous pouvez activer overwrite le remplacement du bloc-notes existant.You can enable overwrite to overwrite the existing notebook.

curl -n -X POST -H 'Content-Type: application/json' -d \
'{
  "path": "/Users/user@example.com/new-notebook",
  "format": "SOURCE",
  "language": "SCALA",
  "content": "Ly8gRGF0YWJyaWNrcyBub3RlYm9vayBzb3VyY2UKcHJpbnQoImhlbGxvLCB3b3JsZCIpCgovLyBDT01NQU5EIC0tLS0tLS0tLS0KCg==",
  "overwrite": "false"
}' https://<databricks-instance>/api/2.0/workspace/import

Si la demande est réussie, une chaîne JSON vide est retournée.If the request succeeds, an empty JSON string is returned.

Vous pouvez également importer un bloc-notes par le biais d’une publication de formulaire en plusieurs parties.Alternatively, you can import a notebook via multipart form post.

curl -n -X POST https://<databricks-instance>/api/2.0/workspace/import \
       -F path="/Users/user@example.com/new-notebook" -F format=SOURCE -F language=SCALA -F overwrite=true -F content=@notebook.scala