Verwenden von dbx mit Visual Studio Code

Artikel
10/09/2024

Wichtig

Diese Dokumentation wurde eingestellt und wird unter Umständen nicht aktualisiert.

Databricks empfiehlt, Databricks-Ressourcenbündel anstelle von dbx von Databricks Labs zu verwenden. Lesen Sie Was sind Databricks-Ressourcenbündel? und Migrieren von dbx zu Bündeln.

Informationen zur Verwendung von Azure Databricks mit Visual Studio Code finden Sie im Artikel Databricks-Erweiterung für Visual Studio Code.

In diesem Artikel wird ein Python-basiertes Codebeispiel beschrieben, mit dem Sie in jeder mit Python kompatiblen IDE arbeiten können. In diesem Artikel wird beschrieben, wie Sie mit diesem Codebeispiel in Visual Studio Code arbeiten können, das die folgenden Produktivitätsfeatures für Entwickler*innen enthält:

Codevervollständigung
Linting
Testen
Debuggen von Codeobjekten, die keine Echtzeitverbindung zu Azure Databricks-Remoteressourcen erfordern

In diesem Artikel wird dbx von Databricks Labs zusammen mit Visual Studio Code verwendet, um das Codebeispiel an einen Azure Databricks-Remotearbeitsbereich zu übermitteln. dbx weist Azure Databricks an, Workflows zu planen und zu orchestrieren, um den übermittelten Code in einem Azure Databricks-Auftragscluster in diesem Arbeitsbereich auszuführen.

Sie können beliebte Git-Anbieter von Drittanbietern zur Versionskontrolle und CI/CD-Bereitstellung (Continuous Integration und Continuous Delivery) Ihres Codes verwenden. Zur Versionskontrolle enthalten diese Git-Anbieter die folgenden Tools:

GitHub
Bitbucket
GitLab
Azure DevOps (nicht in den Azure China-Regionen verfügbar)
AWS CodeCommit
GitHub AE

Für CI/CD unterstützt dbx die folgenden CI/CD-Plattformen:

In diesem Artikel wird beschrieben, wie Sie Visual Studio Code, dbx und dieses Codebeispiel zusammen mit GitHub und GitHub Actions verwenden können, um zu veranschaulichen, wie die Versionskontrolle und CI/CD funktionieren.

Anforderungen für das Codebeispiel

Um dieses Codebeispiel zu verwenden, müssen Sie über Folgendes verfügen:

Einen Azure Databricks-Arbeitsbereich in Ihrem Azure Databricks-Konto
Ein GitHub-Konto. Erstellen Sie ein GitHub-Konto, wenn Sie noch keines haben.

Darüber hinaus müssen Sie auf Ihrem lokalen Entwicklungscomputer über Folgendes verfügen:

Python (Version 3.8 oder höher)

Sie sollten eine Python-Version verwenden, die mit der übereinstimmt, die auf Ihren Zielclustern installiert ist. Um die Version von Python zu erhalten, die auf einem bestehenden Cluster installiert ist, können Sie das Webterminal des Clusters verwenden, um den Befehl python --version auszuführen. Weitere Informationen zur Databricks Runtime-Version für Ihre Zielcluster finden Sie im Abschnitt „Systemumgebung“ unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität. Die Version von Python muss in jedem Fall 3.8 oder höher sein.

Führen Sie python --version aus Ihrem lokalen Terminal aus, um die Version von Python abzurufen, auf die derzeit auf Ihrem lokalen Computer verwiesen wird. (Je nachdem, wie Sie Python auf Ihrem lokalen Computer eingerichtet haben, müssen Sie im Rahmen dieses Artikels möglicherweise python3 statt python ausführen.) Weitere Informationen finden Sie unter Auswählen eines Python-Interpreters.
pip. pip wird automatisch mit neueren Versionen von Python installiert. Führen Sie pip --version aus Ihrem lokalen Terminal aus, um zu überprüfen, ob pip bereits installiert ist. (Je nachdem, wie Sie Python oder pip auf Ihrem lokalen Computer eingerichtet haben, müssen Sie im Rahmen dieses Artikels möglicherweise pip3 statt pip ausführen.)
dbx Version 0.8.0 oder höher. Sie können das dbx Paket aus dem Python Package Index (PyPI) installieren, indem Sie pip install dbx.

Hinweis

Sie müssen dbx nicht jetzt installieren. Sie können es später im Abschnitt Setup des Codebeispiels installieren.
Eine Methode zum Erstellen virtueller Python-Umgebungen, mit der sichergestellt werden kann, dass Sie die richtigen Python-Versionen und Paketabhängigkeiten in Ihren dbx-Projekten verwenden Dieser Artikel behandelt pipenv.
Version 0.18 oder niedriger der Databricks-Befehlszeilenschnittstelle mit eingerichteter Authentifizierung.

Hinweis

Sie müssen die Legacyversion der Databricks CLI (Databricks CLI-Version 0.17) jetzt nicht installieren. Sie können es später im Abschnitt Setup des Codebeispiels installieren. Wenn Sie sie später installieren möchten, müssen Sie daran denken, die Authentifizierung stattdessen zu diesem Zeitpunkt einzurichten.
Visual Studio Code.
Python-Erweiterung für Visual Studio Code
Die Erweiterung GitHub Pull Requests and Issues für Visual Studio Code
Git.

Informationen zum Codebeispiel

Das Python-Codebeispiel in diesem Artikel, das im Repository databricks/ide-best-practices auf GitHub verfügbar ist, führt Folgendes aus:

Es ruft Daten aus dem Repository owid/covid-19-data auf GitHub ab.
Es filtert die Daten nach einem bestimmten ISO-Ländercode.
Es erstellt eine Pivottabelle aus den Daten.
Es bereinigt die Daten.
Es modularisiert die Codelogik in wiederverwendbare Funktionen.
Es führt Komponententests der Funktionen durch.
Es bietet dbx-Projektkonfigurationen und -einstellungen, damit der Code die Daten in eine Delta-Tabelle in einem Azure Databricks-Remotearbeitsbereich schreiben kann.

Einrichten des Codebeispiels

Sobald die Anforderungen für dieses Codebeispiel erfüllt sind, führen Sie die folgenden Schritte durch, um damit zu arbeiten.

Hinweis

In diesen Schritten wird nicht auf die Einrichtung dieses Codebeispiels für CI/CD eingegangen. Sie müssen CI/CD nicht einrichten, um dieses Codebeispiel auszuführen. Wenn Sie CI/CD später einrichten möchten, lesen Sie Ausführen mit GitHub Actions.

Schritt 1: Erstellen einer virtuellen Python-Umgebung

Erstellen Sie aus Ihrem Terminal einen leeren Ordner, in dem die virtuelle Umgebung dieses Codebeispiels enthalten sein wird. Bei diesen Anweisungen wird ein übergeordneter Ordner namens ide-demo verwendet. Sie können diesem Ordner einen beliebigen Namen geben. Wenn Sie einen anderen Namen verwenden, ersetzen Sie den im Rahmen dieses Artikels verwendeten Namen. Nachdem Sie den Ordner erstellt haben, wechseln Sie zu diesem Ordner, und starten Sie dann Visual Studio Code aus diesem Ordner. Denken Sie daran, nach dem code-Befehl den Punkt (.) einzufügen.

Für Linux und macOS:
```
mkdir ide-demo
cd ide-demo
code .
```
Tipp

Wenn der Fehler command not found: code angezeigt wird, lesen Sie Ausführen über die Befehlszeile auf der Microsoft-Website.

Windows:
```
md ide-demo
cd ide-demo
code .
```
Klicken Sie in Visual Studio Code auf der Menüleiste auf Ansicht > Terminal.
Führen Sie im Stammverzeichnis des Ordners ide-demo den pipenv-Befehl mit der folgenden Option aus, wobei <version> die Zielversion von Python ist, die Sie bereits lokal installiert haben (und idealerweise eine Version, die mit der Python-Version Ihres Zielclusters übereinstimmt), z. B. 3.8.14.
```
pipenv --python <version>
```
Notieren Sie sich den Virtualenv location-Wert in der Ausgabe des pipenv-Befehls, da Sie ihn im nächsten Schritt benötigen.
Wählen Sie den Python-Zielinterpreter aus, und aktivieren Sie dann die virtuelle Python-Umgebung:
1. Klicken Sie in der Menüleiste auf Ansicht > Befehlspalette, geben Sie Python: Select ein, und klicken Sie dann auf Python: Interpreter auswählen.
2. Wählen Sie den Python-Interpreter innerhalb des Pfads zur virtuellen Python-Umgebung aus, die Sie gerade erstellt haben. (Dieser Pfad wird als Virtualenv location-Wert in der Ausgabe des pipenv-Befehls aufgeführt.)
3. Klicken Sie auf der Menüleiste auf Ansicht > Befehlspalette, geben Sie Terminal: Create ein, und klicken Sie dann auf Terminal: Neues Terminal erstellen.
4. Stellen Sie sicher, dass die Eingabeaufforderung angibt, dass Sie sich in der pipenv-Shell befinden. Etwas wie (<your-username>) sollte zur Bestätigung vor der Eingabeaufforderung angezeigt werden. Wenn dies nicht angezeigt wird, führen Sie den folgenden Befehl aus:
```
pipenv shell
```
  Führen Sie den Befehl exit aus, um die pipenv-Shell zu beenden, und die Klammern werden ausgeblendet.
Weitere Informationen finden Sie unter Verwenden von Python-Umgebungen in VS Code in der Visual Studio Code-Dokumentation.

Schritt 2: Klonen des Codebeispiels aus GitHub

Öffnen Sie in Visual Studio Code den Ordner ide-demo (Ordner > Ordner öffnen), wenn er noch nicht geöffnet ist.
Klicken Sie auf Ansicht > Befehlspalette, geben Sie Git: Clone ein, und klicken Sie dann auf Git: Klonen.
Geben Sie für Provide repository URL or pick a repository source (Repository-URL angeben oder Repositoryquelle auswählen) https://github.com/databricks/ide-best-practices ein.
Navigieren Sie zum Ordner ide-demo, und klicken Sie auf Select Repository Location (Repositoryspeicherort auswählen).

Schritt 3: Installieren der Abhängigkeiten des Codebeispiels

Installieren Sie eine Version von dbx und Version 0.18 oder niedriger der Databricks-Befehlszeilenschnittstelle, die mit Ihrer Version von Python kompatibel ist. Führen Sie dazu in Visual Studio Code aus Ihrem Terminal den folgenden Befehl aus dem Ordner ide-demo mit einer aktivierten pipenv-Shell (pipenv shell) aus:
```
pip install dbx
```
Vergewissern Sie sich, dass dbx installiert ist. Führen Sie zu diesem Zweck den folgenden Befehl aus:
```
dbx --version
```
Wenn die Versionsnummer zurückgegeben wird, ist dbx installiert.

Wenn die Versionsnummer unter 0.8.0 liegt, führen Sie ein Upgrade von dbx durch, indem Sie den folgenden Befehl ausführen, und überprüfen Sie dann die Versionsnummer erneut:
```
pip install dbx --upgrade
dbx --version

# Or ...
python -m pip install dbx --upgrade
dbx --version
```
Wenn Sie dbx installieren, wird die Legacyversion der Databricks CLI (Databricks CLI-Versionen 0.17) automatisch installiert. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Legacyversion der Databricks CLI (Databricks CLI-Version 0.17) installiert ist:
```
databricks --version
```
Wenn Databricks CLI-Version 0.17 zurückgegeben wird, wird die Legacyversion der Databricks CLI installiert.
Wenn Sie die Legacyversion der Databricks CLI (Databricks CLI-Version 0.17) noch nicht mit der Authentifizierung eingerichtet haben, müssen Sie dies jetzt tun. Wenn Sie bestätigen möchten, dass die Authentifizierung eingerichtet ist, führen Sie den folgenden einfachen Befehl aus, um Zusammenfassungsinformationen zu Ihrem Azure Databricks-Arbeitsbereich abzurufen. Achten Sie darauf, den Schrägstrich (/) nach dem Unterbefehl ls einzuschließen:
```
databricks workspace ls /
```
Wenn eine Liste der Ordnernamen auf Stammebene für Ihren Arbeitsbereich zurückgegeben wird, ist die Authentifizierung eingerichtet.
Installieren Sie die Python-Pakete, von denen dieses Codebeispiel abhängig ist. Führen Sie den folgenden Befehl aus dem Ordner ide-demo/ide-best-practices aus, um dies zu tun:
```
pip install -r unit-requirements.txt
```
Überprüfen Sie, ob die abhängigen Pakete des Codebeispiels installiert sind. Führen Sie zu diesem Zweck den folgenden Befehl aus:
```
pip list
```
Wenn die Pakete, die in den Dateien requirements.txt und unit-requirements.txt aufgeführt sind, sich in dieser Liste befinden, sind die abhängigen Pakete installiert.

Hinweis

Die in requirements.txt aufgeführten Dateien betreffen bestimmte Paketversionen. Um eine bessere Kompatibilität zu erzielen, können Sie mit dem Clusterknotentyp auf diese Versionen verweisen, der später in Ihrem Azure Databricks-Arbeitsbereich zum Ausführen von Bereitstellungen verwendet werden soll. Weitere Informationen zur Databricks Runtime-Version Ihres Clusters finden Sie im Abschnitt „Systemumgebung“ unter Versionshinweise zu Databricks Runtime-Versionen und -Kompatibilität.

Schritt 4: Anpassen des Codebeispiels für Ihren Azure Databricks-Arbeitsbereich

Passen Sie die dbx-Projekteinstellungen des Repositorys an. Ändern Sie dazu in der Datei .dbx/project.json den Wert des Objekts profile von DEFAULT in den Namen des Profils, das mit dem übereinstimmt, das Sie für die Authentifizierung mit der Legacyversion der Databricks CLI (Databricks CLI-Version 0.17) eingerichtet haben. Wenn Sie kein anderes Profil eingerichtet haben, ändern Sie DEFAULT nicht. Beispiele:
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/covid_analysis",
        "artifact_location": "dbfs:/Shared/dbx/projects/covid_analysis"
      }
    }
  },
  "inplace_jinja_support": false
}
```

Passen Sie die dbx-Bereitstellungseinstellungen des Projekts an. Ändern Sie dazu in der Datei conf/deployment.yml den Wert der spark_version- und node_type_id-Objekte aus 10.4.x-scala2.12 und m6gd.large in die Azure Databricks-Versionszeichenfolge der Runtime und den Clusterknotentyp, der in Ihrem Azure Databricks-Arbeitsbereich zum Ausführen von Bereitstellungen verwendet werden soll.

So können Sie beispielsweise Databricks Runtime 10.4 LTS und einen Standard_DS3_v2-Knotentypen angeben:

environments:
  default:
    workflows:
      - name: "covid_analysis_etl_integ"
        new_cluster:
          spark_version: "10.4.x-scala2.12"
          num_workers: 1
        node_type_id: "Standard_DS3_v2"
        spark_python_task:
          python_file: "file://jobs/covid_trends_job.py"
      - name: "covid_analysis_etl_prod"
        new_cluster:
          spark_version: "10.4.x-scala2.12"
          num_workers: 1
          node_type_id: "Standard_DS3_v2"
          spark_python_task:
            python_file: "file://jobs/covid_trends_job.py"
          parameters: ["--prod"]
      - name: "covid_analysis_etl_raw"
        new_cluster:
          spark_version: "10.4.x-scala2.12"
          num_workers: 1
          node_type_id: "Standard_DS3_v2"
          spark_python_task:
            python_file: "file://jobs/covid_trends_job_raw.py"

Tipp

In diesem Beispiel weist jede der drei Auftragsdefinitionen denselben spark_version- und node_type_id-Wert auf. Sie können verschiedene Werte für unterschiedliche Auftragsdefinitionen verwenden. Sie können auch freigegebene Werte erstellen und in verschiedenen Auftragsdefinitionen wiederverwenden, um Tippfehler zu vermeiden und die Codewartung zu vereinfachen. Weitere Informationen finden Sie im YAML-Beispiel in der dbx-Dokumentation.

Erkunden des Codebeispiels

Lesen Sie die folgenden Informationen, nachdem Sie das Codebeispiel eingerichtet haben, um zu erfahren, wie die verschiedenen Dateien im Ordner ide-demo/ide-best-practices funktionieren.

Codemodularisierung

Nicht modularisierter Code

Die Datei jobs/covid_trends_job_raw.py ist eine nicht modularisierte Version der Codelogik. Sie können diese Datei allein ausführen.

Modularisierter Code

Die Datei jobs/covid_trends_job.py ist eine modularisierte Version der Codelogik. Diese Datei basiert auf dem freigegebenen Code in der Datei covid_analysis/transforms.py. Die Datei covid_analysis/__init__.py behandelt den Ordner covide_analysis als enthaltenes Paket.

Testen

Komponententests

Die Datei tests/testdata.csv enthält zu Testzwecken einen kleinen Teil der Daten in der Datei covid-hospitalizations.csv. Die Datei tests/transforms_test.py enthält die Komponententests für die covid_analysis/transforms.py-Datei.

Runner für Komponententests

Die Datei pytest.ini enthält Konfigurationsoptionen zum Ausführen von Tests mit pytest. Weitere Informationen dazu finden Sie unter pytest.ini und Konfigurationsoptionen in der pytest-Dokumentation.

Die Datei .coveragerc enthält Konfigurationsoptionen für Messungen der Python-Code Coverage mit coverage.py. Weitere Informationen hierzu finden Sie unter Konfigurationsreferenz in der coverage.py-Dokumentation.

Die requirements.txt-Datei, die eine Teilmenge der unit-requirements.txt-Datei darstellt, die Sie zuvor mit pip ausgeführt haben, enthält eine Liste der Pakete, von denen die Komponententests ebenfalls abhängen.

Verpackung

Die Datei setup.py enthält Befehle (Konsolenskripts), die auf der Konsole ausgeführt werden sollen, wie z. B. den Befehl pip, der zum Packen von Python-Projekten mit setuptools verwendet wird. Weitere Informationen finden Sie unter Einstiegspunkte in der setuptools-Dokumentation.

Andere Dateien

Es gibt weitere Dateien in diesem Codebeispiel, die bisher nicht beschrieben wurden:

Der Ordner .github/workflows enthält drei Dateien (databricks_pull_request_tests.yml, onpush.yml und onrelease.yaml), die GitHub Actions darstellen, die später im Abschnitt GitHub Actions behandelt werden.
Die Datei .gitignore enthält eine Liste der lokalen Ordner und Dateien, die Git für Ihr Repository ignoriert.

Ausführen des Codebeispiels

Sie können dbx auf Ihrem lokalen Computer verwenden, um Azure Databricks anzuweisen, das Codebeispiel bei Bedarf (wie im nächsten Unterabschnitt beschrieben) in Ihrem Remotearbeitsbereich auszuführen. Alternativ können Sie GitHub Actions verwenden, um das Codebeispiel jedes Mal mit GitHub auszuführen, wenn Sie Codeänderungen an Ihr GitHub-Repository pushen.

Ausführen mit dbx

Installieren Sie die Inhalte des Ordners covid_analysis als Paket im -setuptoolsEntwicklungsmodus von Python, indem Sie den folgenden Befehl aus dem Stamm Ihres dbx-Projekts (z. B. dem Ordner ide-demo/ide-best-practices) ausführen. Achten Sie darauf, den Punkt (.) am Ende dieses Befehls einzufügen:
```
pip install -e .
```
Durch diesen Befehl wird ein covid_analysis.egg-info-Ordner erstellt, der Informationen zur kompilierten Version der covid_analysis/__init__.py- und covid_analysis/transforms.py-Dateien enthält.
Führen Sie die Tests aus, indem Sie den folgenden Befehl ausführen:
```
pytest tests/
```
Die Ergebnisse der Tests werden im Terminal angezeigt. Alle vier Tests sollten als „Erfolgreich“ angezeigt werden.

Tipp

Weitere Ansätze zum Testen, einschließlich Tests für R- und Scala-Notebooks, finden Sie unter Komponententests für Notebooks.
Rufen Sie optional die Testabdeckungsmetriken für Ihre Tests ab, indem Sie den folgenden Befehl ausführen:
```
coverage run -m pytest tests/
```
Hinweis

Wenn eine Nachricht angezeigt wird, die besagt, dass coverage nicht gefunden werden kann, führen Sie pip install coverage aus, und versuchen Sie es erneut.

Führen Sie den folgenden Befehl aus, um die Testabdeckungsergebnisse anzuzeigen:
```
coverage report -m
```
Wenn alle vier Tests erfolgreich waren, senden Sie die Inhalte des dbx-Projekts an Ihren Azure Databricks-Arbeitsbereich, indem Sie den folgenden Befehl ausführen:
```
dbx deploy --environment=default
```
Informationen zum Projekt und seinen Ausführungen werden an den Speicherort gesendet, der im Objekt workspace_directory der Datei .dbx/project.json angegeben wird.

Die Inhalte des Projekts werden an den Speicherort gesendet, der im Objekt artifact_location der Datei .dbx/project.json angegeben wird.
Führen Sie die Vorproduktionsversion des Codes in Ihrem Arbeitsbereich aus, indem Sie den folgenden Befehl ausführen:
```
dbx launch covid_analysis_etl_integ
```
Ein Link zu den Ergebnissen der Ausführungen wird im Terminal angezeigt. Das sollte in etwa so aussehen:
```
https://<your-workspace-instance-id>/?o=1234567890123456#job/123456789012345/run/12345
```
Folgen Sie diesem Link in Ihrem Webbrowser, um die Ergebnisse der Ausführungen in Ihrem Arbeitsbereich anzuzeigen.
Führen Sie die Produktionsversion des Codes in Ihrem Arbeitsbereich aus, indem Sie den folgenden Befehl ausführen:
```
dbx launch covid_analysis_etl_prod
```
Ein Link zu den Ergebnissen der Ausführungen wird im Terminal angezeigt. Das sollte in etwa so aussehen:
```
https://<your-workspace-instance-id>/?o=1234567890123456#job/123456789012345/run/23456
```
Folgen Sie diesem Link in Ihrem Webbrowser, um die Ergebnisse der Ausführungen in Ihrem Arbeitsbereich anzuzeigen.

Ausführen mit GitHub Actions

Im Ordner .github/workflows des Projekts führen die GitHub Actions-Dateien onpush.yml und onrelease.yml Folgendes aus:

Bei jedem Push an ein Tag, das mit v beginnt, verwenden sie dbx zum Bereitstellen des covid_analysis_etl_prod-Auftrags.
Bei jedem Push, der nicht an ein Tag geht, das mit v beginnt, gilt Folgendes:
1. pytest wird zum Ausführen der Komponententests verwendet.
2. dbx wird zum Bereitstellen der Datei im Remotearbeitsbereich verwendet, die im covid_analysis_etl_integ-Auftrag angegeben wurde.
3. dbx wird zum Starten der bereits bereitgestellten Datei im Remotearbeitsbereich verwendet, die im covid_analysis_etl_integ-Auftrag angegeben ist. Diese wird nachverfolgt, bis die Ausführung abgeschlossen ist.

Hinweis

Eine zusätzliche GitHub Actions-Datei (databricks_pull_request_tests.yml) wird als Vorlage zum Experimentieren bereitgestellt, ohne sich auf die GitHub Actions-Dateien onpush.yml und onrelease.yml auszuwirken. Sie können dieses Codebeispiel ohne die GitHub Actions-Datei databricks_pull_request_tests.yml ausführen. Ihre Verwendung wird in diesem Artikel nicht behandelt.

In den folgenden Unterabschnitten wird beschrieben, wie Sie die GitHub Actions-Dateien onpush.yml und onrelease.yml einrichten und ausführen können.

Einrichten der Verwendung von GitHub Actions

Richten Sie Ihren Azure Databricks-Arbeitsbereich ein, indem Sie die Anweisungen unter Dienstprinzipale für CI/CD befolgen. Der Vorgang umfasst folgende Aktionen:

Erstellen eines Dienstprinzipals
Erstellen Sie ein Microsoft Entra ID-Token für den Dienstprinzipal.

Als bewährte Methode im Bereich Sicherheit wird von Databricks empfohlen, ein Microsoft Entra ID-Token für einen Dienstprinzipal zu verwenden, anstatt das persönliche Databricks-Zugriffstoken für Ihre Arbeitsbereichsbenutzer*innen zu nutzen, damit sich GitHub bei Ihrem Azure Databricks-Arbeitsbereich authentifizieren kann.

Nachdem Sie den Dienstprinzipal und das zugehörige Microsoft Entra ID-Token erstellt haben, sollten Sie sich den Wert des Microsoft Entra ID-Tokens notieren, da Sie diesen im nächsten Abschnitt verwenden werden.

Ausführen von GitHub Actions

Schritt 1: Veröffentlichen Ihres geklonten Repositorys

Klicken Sie in Visual Studio Code auf der Randleiste auf das GitHub-Symbol. Wenn das Symbol nicht sichtbar ist, aktivieren Sie zuerst die Erweiterung GitHub Pull Requests and Issues über die Ansicht Erweiterungen (Ansicht > Erweiterungen).
Wenn die Schaltfläche Anmelden angezeigt wird, klicken Sie darauf, und befolgen Sie die Anweisungen auf dem Bildschirm, um sich bei Ihrem GitHub-Konto anzumelden.
Klicken Sie auf der Menüleiste auf Ansicht > Befehlspalette, geben Sie Publish to GitHub ein, und klicken Sie dann auf In GitHub veröffentlichen.
Wählen Sie eine Option aus, um Ihr geklontes Repository in Ihrem GitHub-Konto zu veröffentlichen.

Schritt 2: Hinzufügen verschlüsselter Geheimnisse zu Ihrem Repository

Befolgen Sie auf der GitHub-Website für Ihr veröffentlichtes Repository die Anweisungen unter Erstellen verschlüsselter Geheimnisse für ein Repository für die folgenden verschlüsselten Geheimnisse:

Erstellen Sie ein verschlüsseltes Geheimnis namens DATABRICKS_HOST, und legen Sie den Wert Ihrer URL pro Arbeitsbereich fest (z. B. https://adb-1234567890123456.7.azuredatabricks.net).
Erstellen Sie ein verschlüsseltes Geheimnis namens DATABRICKS_TOKEN, und legen Sie den Wert des Microsoft Entra ID-Tokens für den Dienstprinzipal fest.

Schritt 3: Erstellen und Veröffentlichen eines Branchs in Ihrem Repository

Klicken Sie in Visual Studio Code in der Ansicht Quellcodeverwaltung (Ansicht >Quellcodeverwaltung) auf das Symbol ... (Views and More Actions [Ansichten und weitere Aktionen]).
Klicken Sie auf Branch > Create Branch From (Branch erstellen aus).
Geben Sie einen Namen wie my-branch für den Branch ein.
Wählen Sie den Branch aus, aus dem der Branch erstellt werden soll (z. B. main).
Nehmen Sie eine geringfügige Änderung an einer der Dateien in Ihrem lokalen Repository vor, und speichern Sie dann die Datei. Nehmen Sie beispielsweise eine geringfügige Änderung an einem Codekommentar in der Datei tests/transforms_test.py vor.
Klicken Sie in der Ansicht Quellcodeverwaltung erneut auf das Symbol ... (Views and More Actions).
Klickens Sie auf Änderungen > Alle Änderungen bereitstellen.
Klicken Sie erneut auf das Symbol ... (Views and More Actions).
Klicken Sie auf Commit > Gestaffelter Commit.
Geben Sie eine Nachricht für den Commit ein.
Klicken Sie erneut auf das Symbol ... (Views and More Actions).
Klicken Sie auf Branch > Branch veröffentlichen.

Schritt 4: Erstellen eines Pull Requests und eines Merges

Wechseln Sie zur GitHub-Website für Ihr veröffentlichtes Repository, https://github/<your-GitHub-username>/ide-best-practices.
Klicken Sie auf der Registerkarte Pull Requests neben my-branch had recent pushes auf Vergleichen und Pull Request.
Klicken Sie auf Pull Request erstellen.
Warten Sie auf der Pull Request-Seite darauf, dass das Symbol neben CI pipleline / ci-pipeline (push) ein grünes Häkchen anzeigt. (Es kann einige Minuten dauern, bis das Symbol angezeigt wird.) Wird anstelle eines grünen Häkchens ein rotes X angezeigt, klicken Sie auf Details, um den Grund dafür zu ermitteln. Wenn das Symbol nicht mehr angezeigt wird bzw. die Details nicht mehr angezeigt werden, klicken Sie auf Alle Prüfungen anzeigen.
Wenn das grüne Häkchen angezeigt wird, führen Sie den Pull Request mit dem main-Branch zusammen, indem Sie auf Merge Pull Request (Pull Request zusammenführen) klicken.

Freigeben über