Pulumi Databricks-Ressourcenanbieter

Artikel
07/09/2024

Hinweis

Dieser Artikel behandelt Pulumi, das von Databricks weder bereitgestellt noch unterstützt wird. Um den Anbieter zu kontaktieren, siehe Pulumi Support.

In diesem Artikel wird veranschaulicht, wie Sie Python und Pulumi verwenden, eine IaC-Plattform (Infrastructure-as-Code) eines Drittanbieters, mit der Sie Azure Databricks-Ressourcen mithilfe von vertrauten Programmiersprachen, Tools und technischen Verfahren erstellen, bereitstellen und verwalten können. Dieser Artikel zeigt Ihnen zwar, wie Sie Python und den Pulumi Databricks-Ressourcenanbieter verwenden, aber Pulumi unterstützt neben Python auch andere Sprachen für Azure Databricks, darunter TypeScript, JavaScript, Go und C#.

Der Pulumi Databricks-Ressourcenanbieter basiert auf dem Databricks Terraform-Anbieter. Weitere Informationen finden Sie unter Terraform Cloud.

Anforderungen

Ein Pulumi-Konto. Registrieren Sie sich für Pulumi, wenn Sie noch kein Pulumi-Konto besitzen. Pulumi ist für Einzelpersonen kostenlos und bietet einen Free-Tarif für Teams.
Python 3.6 oder eine höhere Version. Führen Sie über Ihr Terminal oder über PowerShell den Befehl python --version aus, um zu überprüfen, ob Python installiert ist. Installieren Sie Python, wenn Sie es nicht bereits installiert haben.

Hinweis

Bei einigen Installationen von Python müssen Sie möglicherweise python3 anstelle von python verwenden. Wenn dies der Fall ist, ersetzen Sie python in diesem Artikel durch python3.
Ihre arbeitsbereichsspezifische URL für Azure Databricks, z. B. https://adb-1234567890123456.7.azuredatabricks.net.
Azure Databricks-Zugriffsanmeldeinformationen. Pulumi Databricks-Projekte unterstützen die folgenden Azure Databricks-Authentifizierungstypen:
- Authentifizierung mit persönlichen Azure Databricks-Zugriffstoken (databricks:authType pat)
- Authentifizierung mit von Azure verwalteten Identitäten (databricks:authType azure-msi)
- Microsoft Entra-Dienstprinzipalauthentifizierung (databricks:authType azure-client-secret)
- Azure CLI-Authentifizierung (databricks:authType azure-cli)

Die folgenden Schritte zeigen, wie Sie ein Pulumi Databricks-Projekt mit Python erstellen. Ein Tutorial aus der Perspektive eines reinen Cloudanbieters finden Sie stattdessen unter Get Started with Azure in der Pulumi-Dokumentation. Ein Tutorial aus der Perspektive einer Programmiersprache finden Sie unter Python, Node.js (JavaScript, TypeScript), Go und .NET (C#, VB, F#) in der Pulumi-Dokumentation.

Schritt 1: Erstellen eines Pulumi-Projekts

In diesem Schritt richten Sie auf Ihrem lokalen Computer die erforderliche Verzeichnisstruktur für ein Pulumi-Projekt ein. Innerhalb dieser Verzeichnisstruktur erstellen Sie dann Ihr Pulumi-Projekt.

Erstellen Sie über Ihr Terminal oder mithilfe von PowerShell ein leeres Verzeichnis und wechseln Sie dann dorthin. Beispiel:

Unix, Linux und macOS
```
mkdir pulumi-demo
cd pulumi-demo
```
Windows
```
md pulumi-demo
cd pulumi-demo
```
Installieren Sie Pulumi, indem Sie den folgenden Befehl ausführen, abhängig von Ihrem Betriebssystem:

Unix, Linux

Installieren Sie Pulumi unter Unix oder Linux mithilfe von curl:
```
curl -fsSL https://get.pulumi.com | sh
```
MacOS

Installieren Sie Pulumi unter macOS mithilfe von Homebrew:
```
brew install pulumi/tap/pulumi
```
Windows

Installieren Sie Pulumi unter Windows mithilfe von PowerShell mit erweiterten Berechtigungen über den Chocolatey-Paket-Manager:
```
choco install pulumi
```
Alternative Pulumi-Installationsoptionen finden Sie in der Pulumi-Dokumentation unter Download and Install.
Erstellen Sie ein grundlegendes Python-Pulumi-Projekt, indem Sie den folgenden Befehl ausführen:
```
pulumi new python
```
Tipp

Sie können ein Pulumi-Projekt auch online von Ihrem Pulumi-Konto aus erstellen (Projects > Create project). Es gibt jedoch keine Projektvorlage für Azure Databricks.
Wenn Sie dazu aufgefordert werden, drücken Sie die EINGABETASTE, und verwenden Sie dann Ihren Webbrowser, um sich online bei Ihrem Pulumi-Konto anzumelden, falls Sie noch nicht angemeldet sind. Nachdem Sie sich angemeldet haben, kehren Sie zu Ihrem Terminal oder PowerShell zurück.
Wenn Sie zur Eingabe eines Projektnamens aufgefordert werden, akzeptieren Sie den Standardprojektnamen pulumi-demo, indem Sie die EINGABETASTE drücken.
Wenn Sie zur Eingabe einer Projektbeschreibung aufgefordert werden, geben Sie A demo Python Pulumi Databricks project ein und drücken die EINGABETASTE.
Wenn Sie zur Eingabe eines Stapelnamens aufgefordert werden, akzeptieren Sie den Standardstapelnamen dev, indem Sie die EINGABETASTE drücken. Pulumi erstellt die folgenden Dateien und Unterverzeichnisse in Ihrem pulumi-demo-Verzeichnis:
- Pulumi.yaml, die eine Liste von Einstellungen für Ihr Pulumi-Projekt enthält.
- __main__.py, die den Python-Code enthält, den Sie für Ihr Pulumi-Projekt schreiben.
- requirements.txt, die eine Liste der unterstützenden Python-Codepakete enthält, die Pulumi für Ihr Projekt installiert.
- .gitignore, die eine Liste von Dateien und Verzeichnissen darstellt, die von Git ignoriert werden, wenn Sie dieses Projekt in ein Git-Remoterepository verschieben möchten.
- Das venv-Unterverzeichnis enthält unterstützenden Code für die virtuelle Python-Umgebung, den Pulumi für Ihr Projekt verwendet.
Führen Sie eine erste Bereitstellung des dev-Stapels Ihres Projekts durch, indem Sie den folgenden Befehl ausführen:
```
pulumi up
```
Wenn Sie aufgefordert werden, dieses Update durchzuführen, drücken Sie die NACH-OBEN-TASTE, um zu Ja zu navigieren, und drücken Sie dann die EINGABETASTE.
Kopieren Sie den angezeigten View Live-Link, und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein, der Sie zu Ihrem Pulumi-Onlinekonto führt. Die Aktivitätsdetails des dev-Stapels für Ihr pulumi-demo-Projekt werden angezeigt. Jetzt gibt es noch nicht viel zu sehen, denn es befinden sich noch keine Ressourcen in Ihrem Stapel. Sie erstellen diese Ressourcen im nächsten Schritt.

Schritt 2: Erstellen von Databricks-Ressourcen

In diesem Schritt verwenden Sie den Pulumi Databricks-Ressourcenanbieter, um in Ihrem bestehenden Azure Databricks-Arbeitsbereich ein Notebook und einen Auftrag zum Ausführen dieses Notebooks zu erstellen.

Verwenden Sie in der von Pulumi generierten __main.py__-Datei Ihren bevorzugten Text-Editor oder Ihre integrierte Entwicklungsumgebung (IDE), um den folgenden Code einzugeben. Dieser Code deklariert die Pulumi Databricks-Notebook- und Auftrag-Ressourcen und deren Einstellungen:

"""A Python Pulumi program"""

import pulumi
from pulumi_databricks import *
from base64 import b64encode

# Get the authenticated user's workspace home directory path and email address.
# See https://www.pulumi.com/registry/packages/databricks/api-docs/getcurrentuser
user_home_path     = get_current_user().home
user_email_address = get_current_user().user_name

# Define the name prefix to prepend to the resource names that are created
# for the Notebook and Job resources. To do this, you can use a Pulumi
# configuration value instead of hard-coding the name prefix in this file.
#
# To set a Pulumi configuration value, run the following command, which sets
# a "resource-prefix" configuration value to "pulumi-demo" in the
# associated "Pulumi.<stack-name>.yaml" configuration file:
#
# pulumi config set resource-prefix "pulumi-demo"
#
# For more information about defining and retrieving hard-coded values, see
# https://www.pulumi.com/docs/intro/concepts/config
config = pulumi.config.Config()
resource_prefix = config.require('resource-prefix')

# Define cluster resource settings.
node_type = config.require('node-type')

# Create a Notebook resource.
# See https://www.pulumi.com/registry/packages/databricks/api-docs/notebook
# This example adds a single cell to the notebook, which is constructed from
# a single base64-encoded string. In practice, you would replace this:
#
# language       = "PYTHON",
# content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
#
# With this:
#
# source         = "path/to/local/my-notebook.py"
#
# To provide more notebook content easier and faster. Also, the notebook's language
# is automatically detected. If you specify a notebook path, be sure that it does
# not end in .ipynb, as Pulumi relies on the workspace import API, which doesn't
# rely on any specific extensions such as .ipynb in the notebook path.
notebook = Notebook(
  resource_name  = f"{resource_prefix}-notebook",
  path           = f"{user_home_path}/Pulumi/{resource_prefix}-notebook.py",
  language       = 'PYTHON',
  content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
)

# Export the URL of the Notebook, so that you can easily browse to it later.
# See https://www.pulumi.com/docs/intro/concepts/stack/#outputs
pulumi.export('Notebook URL', notebook.url)

# Create a Job resource.
# See https://www.pulumi.com/registry/packages/databricks/api-docs/job
# This job uses the most recent Databricks Runtime long-term support (LTS)
# runtime programmatic version ID at the time this article was first published,
# which is 14.3.x-scala2.12. You can replace this with a later version.
job = Job(
  resource_name = f"{resource_prefix}-job",
  name = f"{resource_prefix}-job",
  tasks = [
    JobTaskArgs(
      task_key = f"{resource_prefix}-task",
      new_cluster   = JobNewClusterArgs(
        num_workers   = 1,
        spark_version = "14.3.x-scala2.12",
        node_type_id  = node_type
      ),
      notebook_task = JobNotebookTaskArgs(
        notebook_path = f"{user_home_path}/Pulumi/{resource_prefix}-notebook.py"
      )
    )
  ],
  email_notifications = JobEmailNotificationsArgs(
    on_successes = [ user_email_address ],
    on_failures  = [ user_email_address ]
  )
)

# Export the URL of the Job, so that you can easily browse to it later.
# See https://www.pulumi.com/docs/intro/concepts/stack/#outputs
pulumi.export('Job URL', job.url)

Definieren Sie einen Konfigurationswert namens resource-prefix, und legen Sie ihn auf den hartcodierten Wert pulumi-demo fest, indem Sie den folgenden Befehl ausführen. Pulumi verwendet diesen Konfigurationswert, um das Notebook und den Auftrag zu benennen:
```
pulumi config set resource-prefix "pulumi-demo"
```
Pulumi erstellt eine Datei namens Pulumi.dev.yaml im gleichen Verzeichnis wie die __main__.py-Datei und fügt den folgenden Code zu dieser YAML-Datei hinzu:
```
config:
  pulumi-demo:resource_prefix: pulumi-demo
```
Indem Sie Konfigurationswerte verwenden, wird Ihr Code modularer und wiederverwendbar. Jetzt kann jemand anderes Ihre __main__.py-Datei wiederverwenden und einen anderen Wert für die resource_prefix-Variable definieren, ohne den Inhalt der __main__.py-Datei zu ändern.
Definieren Sie einen Konfigurationswert namens node-type, und legen Sie ihn auf den folgenden hartcodierten Wert fest, indem Sie den folgenden Befehl ausführen. Pulumi verwendet diesen Konfigurationswert, um den Typ des Clusters zu bestimmen, für den der Auftrag ausgeführt wird.
```
pulumi config set node-type "Standard_D3_v2"
```
Der Inhalt der Pulumi.dev.yaml-Datei sieht jetzt wie folgt aus:
```
config:
  pulumi-demo:node-type: Standard_D3_v2
  pulumi-demo:resource-prefix: pulumi-demo
```
Um Pulumi die Authentifizierung mit Ihrem Azure Databricks-Arbeitsbereich zu ermöglichen, definieren Sie für Azure Databricks spezifische Konfigurationswerte, indem Sie die zugehörigen Befehle ausführen. Verwenden Sie z. B. für die Authentifizierung mit einem persönlichen Azure Databricks-Zugriffstoken die folgenden Befehle. In diesen Befehlen:
- Ersetzen Sie <workspace-instance-url> durch Ihre arbeitsbereichsspezifische URL, z. B. https://adb-1234567890123456.7.azuredatabricks.net.
- Ersetzen Sie <access-token> durch den Wert Ihres Zugriffstokens. Stellen Sie sicher, dass Sie die Option --secret angeben. Dies weist Pulumi an, Ihr Zugriffstoken als bewährte Sicherheitsmethode zu verschlüsseln.
  
  Hinweis
  
  Standardmäßig verwendet Pulumi einen vom Pulumi-Dienst verwalteten Verschlüsselungsschlüssel pro Stapel und ein Salt pro Wert, um Werte zu verschlüsseln. Informationen zum Verwenden eines alternativen Verschlüsselungsanbieters finden Sie im Abschnitt Configuring Secrets Encryption in der Pulumi-Dokumentation.
```
pulumi config set databricks:host "<workspace-instance-url>"
pulumi config set databricks:token "<access-token>" --secret
```
Der Inhalt der Pulumi.dev.yaml-Datei sieht jetzt wie folgt aus:
```
config:
  databricks:host: <your-workspace-instance-url>
  databricks:token:
    secure: <an-encrypted-version-of-your-access-token>
  pulumi-demo:node-type: Standard_D3_v2
  pulumi-demo:resource_prefix: pulumi-demo
```
Informationen zur Verwendung eines anderen Azure Databricks-Authentifizierungstyps finden Sie in den Anforderungen. Siehe auch Configuration im Pulumi Databricks-Repository auf GitHub.

Schritt 3: Bereitstellen der Ressourcen

In diesem Schritt aktivieren Sie eine virtuelle Python-Umgebung, die Pulumi für Ihr Projekt bereitstellt, wenn Sie die Pulumi Python-Projektvorlage ausführen. Diese virtuelle Umgebung hilft Ihnen sicherzustellen, dass Sie die richtige Version von Python, Pulumi und dem Pulumi Databricks-Anbieter verwenden. Es gibt mehrere Python-Frameworks für virtuelle Umgebungen, z. B. venv, virtualenv und pipenv. Dieser Artikel und die Pulumi Python-Projektvorlage verwenden venv. venv ist bereits in Python enthalten. Weitere Informationen finden Sie unter Erstellen virtueller Umgebungen.

Aktivieren Sie die virtuelle Python-Umgebung, indem Sie den folgenden Befehl von Ihrem pulumi-demo-Verzeichnis aus ausführen, je nach Betriebssystem und Shelltyp:

Plattform	Shell	Befehl zum Aktivieren der virtuellen Umgebung
Unix, Linux, macOS	Bash/zsh	`source venv/bin/activate`
	fish	`source venv/bin/activate.fish`
	csh/tcsh	`source venv/bin/activate.csh`
	PowerShell Core	`venv/bin/Activate.ps1`
Windows	cmd.exe	`venv\Scripts\activate.bat`
	PowerShell	`venv\Scripts\Activate.ps1`

Installieren Sie den Pulumi Databricks-Ressourcenanbieter aus dem Python Package Index (PyPI) in Ihrer virtuellen Umgebung, indem Sie den folgenden Befehl ausführen:
```
pip install pulumi-databricks
```
Hinweis

Bei einigen Installationen von pip müssen Sie möglicherweise pip3 anstelle von pip verwenden. Wenn dies der Fall ist, ersetzen Sie pip in diesem Artikel durch pip3.
Zeigen Sie eine Vorschau der Ressourcen an, die Pulumi erstellen wird, indem Sie den folgenden Befehl ausführen:
```
pulumi preview
```
Wenn Fehler gemeldet werden, beheben Sie diese und führen Sie den Befehl erneut aus.

Um in Ihrem Pulumi-Konto online einen detaillierten Bericht darüber anzuzeigen, wie Pulumi vorgehen wird, kopieren Sie den angezeigten View Live-Link, und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.
Erstellen Sie die Ressourcen, und stellen Sie sie in Ihrem Azure Databricks-Arbeitsbereich bereit, indem Sie den folgenden Befehl ausführen:
```
pulumi up
```
Wenn Sie aufgefordert werden, dieses Update durchzuführen, drücken Sie die NACH-OBEN-TASTE, um zu Ja zu navigieren, und drücken Sie dann die EINGABETASTE. Wenn Fehler gemeldet werden, beheben Sie diese und führen Sie den Befehl erneut aus.
Um in Ihrem Pulumi-Konto online einen detaillierten Bericht darüber anzuzeigen, wie Pulumi vorgegangen ist, kopieren Sie den angezeigten View Live-Link, und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.

Schritt 4: Interagieren mit den Ressourcen

In diesem Schritt führen Sie den Auftrag in Ihrem Azure Databricks-Arbeitsbereich aus, der das angegebene Notebook ausführt.

Um das Notebook anzuzeigen, das der Auftrag in Ihrem Arbeitsbereich ausführen wird, kopieren Sie den angezeigten Notebook URL-Link und fügen ihn in die Adressleiste Ihres Webbrowsers ein.
Um den Auftrag anzuzeigen, der das Notebook in Ihrem Arbeitsbereich ausführt, kopieren Sie den angezeigten Job URL-Link und fügen ihn in die Adressleiste Ihres Webbrowsers ein.
Um den Auftrag auszuführen, klicken Sie auf der Auftragsseite auf die Schaltfläche Run now.
Nachdem der Auftrag ausgeführt wurde, klicken Sie in der Liste Completed runs (past 60 days) auf der Auftragsseite auf den neuesten Zeiteintrag in der Spalte Start time, um die Ergebnisse der Auftragsausführung anzuzeigen. Der Bereich Output zeigt das Ergebnis, wenn Sie den Code des Notebooks ausführen, der die Zahlen 1 bis 10 ausgibt.

(Optional) Schritt 5: Ändern einer Ressource

In diesem optionalen Schritt ändern Sie den Code des Notebooks, stellen das geänderte Notebook erneut bereit und verwenden dann den Auftrag, um das geänderte Notebook erneut auszuführen.

Wenn Sie keine Änderungen am Notebook vornehmen möchten, fahren Sie mit Schritt 6: Bereinigen fort.

Ändern Sie die folgende Codezeile, wenn Sie sich wieder in der __main.py__-Datei befinden:
```
content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
```
Ändern Sie sie in Folgendes, und speichern Sie dann die Datei:
```
  content_base64 = b64encode(b'''
data = [
         { "Category": 'A', "ID": 1, "Value": 121.44 },
         { "Category": 'B', "ID": 2, "Value": 300.01 },
         { "Category": 'C', "ID": 3, "Value": 10.99 },
         { "Category": 'E', "ID": 4, "Value": 33.87}
       ]

df = spark.createDataFrame(data)

display(df)
''').decode("UTF-8")
```
Diese Änderung weist das Notebook an, den Inhalt des angegebenen Datenrahmens anstelle der Zahlen 1 bis 10 auszugeben.

Hinweis

Achten Sie darauf, dass die Codezeilen, die mit data beginnen und mit ''').decode("UTF-8") enden, am Rand Ihres Code-Editors ausgerichtet sind. Andernfalls fügt Pulumi zusätzliche Leerzeichen in das Notebook ein, die dazu führen können, dass der neue Python-Code nicht ausgeführt werden kann.
Optional können Sie eine Vorschau der Ressource anzeigen, die Pulumi ändern wird, indem Sie den folgenden Befehl ausführen:
```
pulumi preview
```
Wenn Fehler gemeldet werden, beheben Sie diese und führen Sie den Befehl erneut aus.

Um in Ihrem Pulumi-Konto online einen detaillierten Bericht darüber anzuzeigen, wie Pulumi vorgehen wird, kopieren Sie den angezeigten View Live-Link, und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.
Stellen Sie die Ressourcenänderung in Ihrem Azure Databricks-Arbeitsbereich bereit, indem Sie den folgenden Befehl ausführen:
```
pulumi up
```
Wenn Sie aufgefordert werden, dieses Update durchzuführen, drücken Sie die NACH-OBEN-TASTE, um zu Ja zu navigieren, und drücken Sie dann die EINGABETASTE. Wenn Fehler gemeldet werden, beheben Sie diese und führen Sie den Befehl erneut aus.
Um in Ihrem Pulumi-Konto online einen detaillierten Bericht darüber anzuzeigen, wie Pulumi vorgegangen ist, kopieren Sie den angezeigten View Live-Link, und fügen Sie ihn in die Adressleiste Ihres Webbrowsers ein.
Um das geänderte Notebook in Ihrem Arbeitsbereich anzuzeigen, kopieren Sie den angezeigten Notebook URL-Link und fügen ihn in die Adressleiste Ihres Webbrowsers ein.
Um den Auftrag mit dem geänderten Notebook erneut auszuführen, kopieren Sie den angezeigten Job URL-Link und fügen ihn in die Adressleiste Ihres Webbrowsers ein. Klicken Sie dann auf die Schaltfläche Run now auf der Auftragsseite.
Nachdem der Auftrag ausgeführt wurde, klicken Sie in der Liste Completed runs (past 60 days) auf der Auftragsseite auf den neuesten Zeiteintrag in der Spalte Start time, um die Ergebnisse der Auftragsausführung anzuzeigen. Der Bereich Output zeigt das Ergebnis der Ausführung des Notebookcodes an, der den Inhalt des angegebenen Datenrahmens ausgibt.

Schritt 6: Bereinigung

In diesem Schritt weisen Sie Pulumi an, das Notebook und den Auftrag aus Ihrem Azure Databricks Arbeitsbereich zu entfernen sowie das pulumi-demo-Projekt und seinen dev-Stapel online aus Ihrem Pulumi-Konto zu entfernen.

Entfernen Sie die Ressourcen aus Ihrem Azure Databricks-Arbeitsbereich, indem Sie den folgenden Befehl ausführen:
```
pulumi destroy
```
Wenn Sie aufgefordert werden, diesen Löschvorgang durchzuführen, drücken Sie die NACH-OBEN-TASTE, um zu Ja zu navigieren, und drücken Sie dann die EINGABETASTE.
Entfernen Sie das Pulumi-pulumi-demo-Projekt und seinen dev-Stapel aus Ihrem Pulumi-Konto online, indem Sie den folgenden Befehl ausführen:
```
pulumi stack rm dev
```
Wenn Sie aufgefordert werden, diese Entfernung durchzuführen, geben Sie dev ein und drücken die EINGABETASTE.
Führen Sie den folgenden Befehl aus, um die virtuelle Python-Umgebung venv zu deaktivieren:
```
deactivate
```

Testen

Sie können Ihr Pulumi-Projekt testen, bevor Sie es bereitstellen. Weitere Informationen finden Sie in der Pulumi-Dokumentation unter Testen von Pulumi-Programmen.

Für Komponententests Python-basierter Pulumi-Projekte können Sie das Python-Testframework unittest zusammen mit dem Namespace pulumi.runtime des Pulumi-Pakets verwenden, um Komponententests zu schreiben und auszuführen. Um Tests für simulierte Ressourcen auszuführen, ersetzen Sie Aufrufe für Pulumi (und Azure Databricks) durch Pseudoelemente. Weitere Informationen finden Sie in der Pulumi-Dokumentation unter Komponententests für Pulumi-Programme.

Die folgende Beispieldatei mit dem Namen infra.py simuliert eine Implementierung des Notebooks und des Auftrags, die in der Datei main.py aus diesem Artikel deklariert sind. Die Komponententests in diesem Beispiel überprüfen, ob für den Base64-codierten Inhalt des Notebooks, den Namen des Auftrags und den E-Mail-Empfänger für erfolgreiche Auftragsausführungen jeweils erwartete Werte zurückgegeben werden. Daher werden hier nur diese verwandten Eigenschaften mit Beispielwerten simuliert. Außerdem müssen erforderliche Ressourceneigenschaftswerte immer bereitgestellt werden, auch wenn Sie nicht vorhaben, diese in Ihren Komponententests zu verwenden. In diesem Beispiel werden diese erforderlichen Werte auf zufällige Werte vom Typ my-mock- festgelegt, und diese Werte werden nicht getestet.

# infra.py

from pulumi_databricks import (
  Notebook,
  Job,
  JobEmailNotificationsArgs
)

notebook = Notebook(
  resource_name  = 'my-mock-notebook-resource-name',
  path           = 'my-mock-notebook-path',
  content_base64 = 'ZGlzcGxheShzcGFyay5yYW5nZSgxMCkp'
)

job = Job(
  resource_name = 'my-mock-job-resource-name',
  name          = 'pulumi-demo-job',
  email_notifications = JobEmailNotificationsArgs(
    on_successes = [ 'someone@example.com' ]
  )
)

Die folgende Beispieldatei test_main.py testet, ob für die zugehörigen Eigenschaften die erwarteten Werte zurückgegeben werden:

# test_main.py

import pulumi
from pulumi_databricks import *
import unittest
import infra

# Set up mocking.
class MyMocks(pulumi.runtime.Mocks):
  def new_resource(self, type_, name, inputs, provider, id_):
    return [name + '_id', inputs]

  def call(self, token, args, provider):
    return {}

pulumi.runtime.set_mocks(MyMocks())

class TestNotebookAndJob(unittest.TestCase):
  @pulumi.runtime.test
  def test_notebook(self):
    def check_notebook_content_base64(args):
      content_base64 = args
      # Does the notebook's Base64-encoded content match the expected value?
      self.assertIn('ZGlzcGxheShzcGFyay5yYW5nZSgxMCkp', content_base64)

    # Pass the mocked notebook's content_base64 property value to the test.
    return pulumi.Output.all(infra.notebook.content_base64).apply(check_notebook_content_base64)

  @pulumi.runtime.test
  def test_job(self):
    def check_job_name_and_email_onsuccesses(args):
      name, email_notifications = args
      # Does the job's name match the expected value?
      self.assertIn('pulumi-demo-job', name)
      # Does the email address for successful job runs match the expected value?
      self.assertIn('someone@example.com', email_notifications['on_successes'])

    # Pass into the test the mocked job's property values for the job's name
    # and the job's email address for successful runs.
    return pulumi.Output.all(
      infra.job.name,
      infra.job.email_notifications
    ).apply(check_job_name_and_email_onsuccesses)

Führen Sie den folgenden Befehl über das Stammverzeichnis des Pulumi-Projekts aus, um diese Tests auszuführen und ihre Testergebnisse anzuzeigen:

python -m unittest

Informationen zu anderen Arten von Tests, die Sie ausführen können, finden Sie in den folgenden Artikeln der Pulumi-Dokumentation:

Freigeben über

Pulumi Databricks-Ressourcenanbieter

Anforderungen

Schritt 1: Erstellen eines Pulumi-Projekts

Unix, Linux und macOS

Windows

Unix, Linux

MacOS