Udostępnij przez

Dostawca usługi Databricks narzędzia Terraform CDK

Uwaga

W tym artykule opisano zestaw Cloud Development Kit for Terraform (CDKTF), który został opracowany przez inną firmę. Aby skontaktować się z dostawcą, zobacz społeczność programu Terraform.

W tym artykule pokazano, jak używać języka Python wraz z dostawcą usługi Terraform CDK Databricks i zestawem Cloud Development Kit for Terraform (CDKTF). CDKTF to platforma innej firmy, infrastruktura jako kod (IaC), która umożliwia tworzenie, wdrażanie i zarządzanie zasobami usługi Azure Databricks przy użyciu znanych języków programowania, narzędzi i praktyk inżynieryjnych. Chociaż w tym artykule pokazano, jak używać języka Python, cdKTF obsługuje dodatkowe języki, takie jak TypeScript, Java, C# i Go.

Dostawca narzędzia Terraform CDK Databricks jest oparty na dostawcy narzędzia Terraform usługi Databricks. Aby uzyskać więcej informacji, zobacz Terraform Cloud. CdKTF jest oparty na zestawie AWS Cloud Development Kit (AWS CDK).

Wymagania

Musisz mieć obszar roboczy usługi Azure Databricks, ponieważ ten artykuł wdraża zasoby w istniejącym obszarze roboczym.

Na lokalnej maszynie deweloperów musisz mieć zainstalowane następujące elementy:

  • Terraform, wersja 1.1 lub nowsza. Aby sprawdzić, czy masz zainstalowany program Terraform, i sprawdzić zainstalowaną wersję, uruchom polecenie terraform -v z terminalu lub za pomocą programu PowerShell. Zainstaluj program Terraform, jeśli nie został jeszcze zainstalowany.

    terraform -v

  • Node.js, wersja 16.13 lub nowsza i npm. Aby sprawdzić, czy masz Node.js i npm zainstalowano, oraz sprawdzić zainstalowane wersje, uruchom polecenia node -v i npm -v. Najnowsze wersje Node.js już obejmują npm. Zainstaluj Node.js i narzędzie npm przy użyciu programu Node Version Manager (nvm), jeśli nie masz Node.js i npm jest już zainstalowany.

    node -v
npm -v

  • Interfejs wiersza polecenia CDKTF. Aby sprawdzić, czy masz zainstalowany interfejs wiersza polecenia CDKTF i sprawdzić zainstalowaną wersję, uruchom polecenie cdktf --version. Zainstaluj interfejs wiersza polecenia CDKTF przy użyciu narzędzia npm, jeśli jeszcze go nie zainstalowano.

    cdktf --version

    Napiwek

    Interfejs wiersza polecenia CDKTF można również zainstalować w systemie macOS za pomocą oprogramowania Homebrew. Zobacz Instalowanie narzędzia CDKTF.

  • Środowisko Python w wersji 3.7 lub nowszej i potokowej w wersji 2021.5.29 lub nowszej. Aby sprawdzić, czy masz język Python i pipenv zainstalowano program oraz sprawdzić zainstalowane wersje, uruchom polecenia python --version i pipenv --version. Zainstaluj język Python i zainstaluj oprogramowanie pipenv, jeśli nie zostały jeszcze zainstalowane.

    python --version
pipenv --version

  • Uwierzytelnianie usługi Azure Databricks skonfigurowane dla obsługiwanego typu uwierzytelniania, którego chcesz użyć. Zobacz Uwierzytelnianie w dokumentacji dostawcy narzędzia Terraform usługi Databricks.

Krok 1. Tworzenie projektu CDKTF

W tym kroku na lokalnej maszynie programistycznej skonfigurujesz niezbędną strukturę katalogów dla projektu CDKTF. Następnie utworzysz projekt CDKTF w tej strukturze katalogów.

  1. Utwórz pusty katalog dla projektu CDKTF, a następnie przejdź do niego. Uruchom następujące polecenia w terminalu lub za pomocą programu PowerShell:

    Unix, Linux i macOS

    mkdir cdktf-demo
cd cdktf-demo

    Windows

    md cdktf-demo
cd cdktf-demo

  2. Utwórz projekt CDKTF, uruchamiając następujące polecenie:

    cdktf init --template=python --local

  3. Po wyświetleniu monitu o nazwę projektu zaakceptuj domyślną nazwę cdktf-demo projektu, naciskając Enter.

  4. Po wyświetleniu monitu o opis projektu zaakceptuj domyślny opis projektu, naciskając Enter.

  5. Jeśli zostanie wyświetlony monit Czy chcesz rozpocząć od istniejącego projektu programu Terraform, wprowadź N i naciśnij Enter.

  6. Jeśli zostanie wyświetlony monit Czy chcesz wysłać raporty o awarii do zespołu CDKTF, wprowadź i naciśnij nEnter.

CdKTF tworzy następujące pliki i podkatalogi w katalogu cdktf-demo :

  • .gitignore, która jest listą plików i katalogów, które usługa Git ignoruje, jeśli chcesz wypchnąć ten projekt do zdalnego repozytorium Git.
  • cdktf.json, który zawiera ustawienia konfiguracji projektu CDKTF. Aby uzyskać więcej informacji na temat ustawień konfiguracji, zobacz Plik konfiguracji.
  • help, który zawiera informacje o kolejnych krokach, które można wykonać, aby pracować z projektem CDKTF.
  • main-test.py, który zawiera pomocnicze testy jednostkowe, które można napisać dla projektu CDKTF. Aby uzyskać więcej informacji na temat testowania jednostkowego, zobacz Testy jednostkowe.
  • main.py, który zawiera kod języka Python pisany dla projektu CDKTF.
  • Pipfile i Pipfile.lock, które zarządzają zależnościami kodu dla projektu CDKTF.

Krok 2. Definiowanie zasobów

W tym kroku użyjesz dostawcy narzędzia Terraform CDK Databricks do zdefiniowania notesu i zadania do uruchomienia tego notesu.

  1. Zainstaluj zależności projektu: użyj polecenia pipenv, zainstaluj w projekcie CDKTF dostawcę usługi Terraform CDK Databricks w celu wygenerowania zasobów usługi Azure Databricks. W tym celu uruchom następujące polecenie:

    pipenv install cdktf-cdktf-provider-databricks

  2. Zastąp zawartość main.py pliku następującym kodem. Ten kod uwierzytelnia narzędzie CDKTF w obszarze roboczym usługi Azure Databricks, a następnie generuje notes wraz z zadaniem do uruchomienia notesu. Aby wyświetlić dokumentację składni dla tego kodu, zobacz dokumentację konstrukcji dostawcy usługi Databricks narzędzia Terraform CDK dla języka Python.

    #!/usr/bin/env python
from constructs import Construct
from cdktf import (
  App, TerraformStack, TerraformOutput
)
from cdktf_cdktf_provider_databricks import (
  data_databricks_current_user,
  job, notebook, provider
)
import vars
from base64 import b64encode

class MyStack(TerraformStack):
  def __init__(self, scope: Construct, ns: str):
    super().__init__(scope, ns)

    provider.DatabricksProvider(
      scope = self,
      id    = "databricksAuth"
    )

    current_user = data_databricks_current_user.DataDatabricksCurrentUser(
      scope     = self,
      id_       = "currentUser"
    )

    # Define the notebook.
    my_notebook = notebook.Notebook(
      scope          = self,
      id_            = "notebook",
      path           = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py",
      language       = "PYTHON",
      content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
    )

    # Define the job to run the notebook.
    my_job = job.Job(
      scope = self,
      id_ = "job",
      name = f"{vars.resource_prefix}-job",
      task = [ 
        job.JobTask(
          task_key = f"{vars.resource_prefix}-task",
          new_cluster = job.JobTaskNewCluster(
            num_workers   = vars.num_workers,
            spark_version = vars.spark_version,
            node_type_id  = vars.node_type_id
          ),
          notebook_task = job.JobTaskNotebookTask(
            notebook_path = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py"
          ),
          email_notifications = job.JobTaskEmailNotifications(
            on_success = [ current_user.user_name ],
            on_failure = [ current_user.user_name ]
          )
        )
      ]
    )

    # Output the notebook and job URLs.
    TerraformOutput(
      scope = self,
      id    = "Notebook URL",
      value = my_notebook.url
    )

    TerraformOutput(
      scope = self,
      id    = "Job URL",
      value = my_job.url
    )

app = App()
MyStack(app, "cdktf-demo")
app.synth()

  3. Utwórz plik o nazwie vars.py w tym samym katalogu co main.py. Zastąp następujące wartości własnymi wartościami, aby określić prefiks zasobu i ustawienia klastra, takie jak liczba procesów roboczych, ciąg wersji środowiska uruchomieniowego platformy Spark i typ węzła.

    #!/usr/bin/env python
resource_prefix = "cdktf-demo"
num_workers     = 1
spark_version   = "14.3.x-scala2.12"
node_type_id    = "Standard_D3_v2"

Krok 3. Wdrażanie zasobów

W tym kroku użyjesz interfejsu wiersza polecenia CDKTF do wdrożenia w istniejącym obszarze roboczym usługi Azure Databricks, zdefiniowanym notesie i zadaniu, aby uruchomić ten notes.

  1. Wygeneruj odpowiednik kodu narzędzia Terraform dla projektu CDKTF. W tym celu uruchom polecenie cdktf synth.

    cdktf synth

  2. Przed wprowadzeniem zmian możesz przejrzeć oczekujące zmiany zasobów. Uruchom następujące polecenie:

    cdktf diff

  3. Wdróż notes i zadanie, uruchamiając cdktf deploy polecenie .

    cdktf deploy

  4. Po wyświetleniu monitu o zatwierdzenie naciśnij Enter. Narzędzie Terraform tworzy i wdraża notes i zadanie w obszarze roboczym.

Krok 4. Interakcja z zasobami

W tym kroku uruchomisz zadanie w obszarze roboczym usługi Azure Databricks, który uruchamia określony notes.

  1. Aby wyświetlić notes, w którym zadanie zostanie uruchomione w obszarze roboczym, skopiuj link Adres URL notesu wyświetlany w wynikach polecenia cdk deploy i wklej go w pasku adresowym przeglądarki.
  2. Aby wyświetlić zadanie uruchamiające notes w obszarze roboczym, skopiuj link Adres URL zadania wyświetlany w danych wyjściowych cdk deploy polecenia i wklej go na pasku adresu przeglądarki internetowej.
  3. Aby uruchomić zadanie, kliknij przycisk Uruchom teraz na stronie zadania.

(Opcjonalnie) Krok 5. Wprowadzanie zmian w zasobie

W tym opcjonalnym kroku zmienisz kod notesu, ponownie wdrożysz zmieniony notes, a następnie użyjesz zadania, aby ponownie uruchomić zmieniony notes.

Jeśli nie chcesz wprowadzać żadnych zmian w notesie, przejdź do kroku 6: Czyszczenie.

  1. main.py W pliku zmień deklarację zmiennej notebook z następujących elementów:

    my_notebook = notebook.Notebook(
  scope          = self,
  id_            = "notebook",
  path           = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py",
  language       = "PYTHON",
  content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
)

    Na następujący:

    my_notebook = notebook.Notebook(
  scope          = self,
  id_            = "notebook",
  path           = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py",
  language       = "PYTHON",
  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")
)

    Uwaga

    Upewnij się, że wiersze kodu między potrójnymi cudzysłowami (''') są wyrównane do krawędzi edytora kodu, jak pokazano poniżej. W przeciwnym razie program Terraform wstawi dodatkowe białe znaki do notesu, co może spowodować niepowodzenie uruchomienia nowego kodu języka Python.

  2. Wygeneruj ponownie kod Narzędzia Terraform odpowiadający projektowi CDKTF. W tym celu uruchom następujące polecenie:

    cdktf synth

  3. Przed wprowadzeniem zmian możesz przejrzeć oczekujące zmiany zasobów. Uruchom następujące polecenie:

    cdktf diff

  4. Wdróż zmiany notesu cdktf deploy , uruchamiając polecenie .

    cdktf deploy

  5. Po wyświetleniu monitu o zatwierdzenie naciśnij Enter. Narzędzie Terraform zmienia zawartość notesu.

  6. Aby wyświetlić zmieniony notes, który zostanie uruchomiony przez zadanie w obszarze roboczym, odśwież wcześniej otwarty notes lub skopiuj link adres URL notebooka, który pojawia się w danych wyjściowych cdk deploy polecenia i wklej go w polu adresu przeglądarki.

  7. Aby wyświetlić zadanie uruchamiające zmieniony notes w obszarze roboczym, odśwież otwarte wcześniej zadanie lub skopiuj link Adres URL zadania wyświetlany w danych wyjściowych cdk deploy polecenia i wklej go na pasku adresu przeglądarki internetowej.

  8. Aby uruchomić zadanie, kliknij przycisk Uruchom teraz na stronie zadania.

Krok 6. Czyszczenie

W tym kroku użyjesz interfejsu wiersza polecenia CDKTF, aby usunąć notes i zadanie z obszaru roboczego usługi Azure Databricks.

  1. Usuń zasoby z obszaru roboczego, uruchamiając cdktf destroy polecenie:

    cdktf destroy

  2. Po wyświetleniu monitu o zatwierdzenie naciśnij Enter. Narzędzie Terraform usuwa zasoby z obszaru roboczego.

Testowanie

Projekt CDKTF można przetestować przed jego wdrożeniem. Zobacz Testy jednostkowe w dokumentacji cdKTF.

W przypadku projektów CDKTF opartych na języku Python można pisać i uruchamiać testy przy użyciu struktury testowej języka Python pytest wraz z cdktf klasą pakietu Testing . Poniższy przykładowy plik o nazwie test_main.py testuje kod CDKTF w poprzednim main.py pliku tego artykułu. Pierwszy test sprawdza, czy notes projektu będzie zawierać oczekiwaną reprezentację zawartości notesu zakodowaną w formacie Base64. Drugi test sprawdza, czy zadanie projektu będzie zawierać oczekiwaną nazwę zadania. Aby uruchomić te testy, uruchom pytest polecenie z katalogu głównego projektu.

from cdktf import App, Testing
from cdktf_cdktf_provider_databricks import job, notebook
from main import MyStack

class TestMain:
  app = App()
  stack = MyStack(app, "cdktf-demo")
  synthesized = Testing.synth(stack)

  def test_notebook_should_have_expected_base64_content(self):
    assert Testing.to_have_resource_with_properties(
      received = self.synthesized,
      resource_type = notebook.Notebook.TF_RESOURCE_TYPE,
      properties = {
        "content_base64": "ZGlzcGxheShzcGFyay5yYW5nZSgxMCkp"
      }
    )

  def test_job_should_have_expected_job_name(self):
    assert Testing.to_have_resource_with_properties(
      received = self.synthesized,
      resource_type = job.Job.TF_RESOURCE_TYPE,
      properties = {
        "name": "cdktf-demo-job"
      }
    )

Więcej zasobów

  • Last updated on