Dela via

Terraform CDK Databricks-provider

  • Artikel

Kommentar

Den här artikeln beskriver Cloud Development Kit for Terraform (CDKTF), som varken tillhandahålls eller stöds av Databricks. Information om hur du kontaktar leverantören finns i Terraform Community.

Den här artikeln visar hur du använder Python tillsammans med Terraform CDK Databricks-providernoch Cloud Development Kit for Terraform (CDKTF). CDKTF är en IaC-plattform (infrastruktur som kod) från tredje part som gör att du kan skapa, distribuera och hantera Azure Databricks-resurser med hjälp av välbekanta programmeringsspråk, verktyg och tekniska metoder. Även om den här artikeln visar hur du använder Python har CDKTF stöd för ytterligare språk som TypeScript, Java, C# och Go.

Terraform CDK Databricks-providern baseras på Databricks Terraform-providern. Mer information finns i Terraform Cloud. CDKTF baseras på AWS Cloud Development Kit (AWS CDK).

Krav

Du måste ha en Azure Databricks-arbetsyta eftersom den här artikeln distribuerar resurser till en befintlig arbetsyta.

På den lokala utvecklingsdatorn måste du ha följande installerat:

  • Terraform, version 1.1 eller senare. Kontrollera om Terraform är installerat och kontrollera den installerade versionen genom att köra kommandot terraform -v från terminalen eller med PowerShell. Installera Terraform om du inte redan har installerat det.

    terraform -v

  • Node.js version 16.13 eller senare och npm. Kontrollera om du har Node.js och npm installerat och kontrollera de installerade versionerna genom att köra kommandona node -v och npm -v. De senaste versionerna av Node.js innehåller npmredan . Installera Node.js och npm med hjälp av Node Version Manager (nvm) om du inte har Node.js och npm redan installerat.

    node -v
npm -v

  • CDKTF CLI. Om du vill kontrollera om CDKTF CLI är installerat och kontrollera den installerade versionen kör du kommandot cdktf --version. Installera CDKTF CLI med hjälp av npm, om du inte redan har installerat det.

    cdktf --version

    Dricks

    Du kan också installera CDKTF CLI på macOS med Homebrew. Se Installera CDKTF.

  • Python version 3.7 eller senare och pipenv version 2021.5.29 eller senare. Om du vill kontrollera om du har Python och pipenv installerat och kontrollera de installerade versionerna kör du kommandona python --version och pipenv --version. Installera Python och installera pipenv om de inte redan är installerade.

    python --version
pipenv --version

  • Azure Databricks-autentisering konfigurerad för den autentiseringstyp som stöds som du vill använda. Se Autentisering i dokumentationen för Databricks Terraform-providern.

Steg 1: Skapa ett CDKTF-projekt

I det här steget konfigurerar du den nödvändiga katalogstrukturen för ett CDKTF-projekt på den lokala utvecklingsdatorn. Sedan skapar du ditt CDKTF-projekt i den här katalogstrukturen.

  1. Skapa en tom katalog för ditt CDKTF-projekt och växla sedan till det. Kör följande kommandon i terminalen eller med PowerShell:

    Unix, linux och macos

    mkdir cdktf-demo
cd cdktf-demo

    Windows

    md cdktf-demo
cd cdktf-demo

  2. Skapa ett CDKTF-projekt genom att köra följande kommando:

    cdktf init --template=python --local

  3. När du uppmanas att ange ett projektnamn godkänner du standardprojektets cdktf-demo namn genom att trycka på Retur.

  4. När du uppmanas att ange en projektbeskrivning godkänner du standardprojektbeskrivningen genom att trycka på Retur.

  5. Om du uppmanas att starta från ett befintligt Terraform-projekt anger N du och trycker på Retur.

  6. Om du uppmanas att skicka kraschrapporter till CDKTF-teamet anger n och trycker du på Retur.

CDKTF skapar följande filer och underkataloger i din cdktf-demo katalog:

  • .gitignore, som är en lista över filer och kataloger som Git ignorerar om du vill skicka projektet till en fjärransluten Git-lagringsplats.
  • cdktf.json, som innehåller konfigurationsinställningar för ditt CDKTF-projekt. Mer information om konfigurationsinställningar finns i Konfigurationsfil .
  • help, som innehåller information om några nästa steg som du kan vidta för att arbeta med ditt CDKTF-projekt.
  • main-test.py, som innehåller stödenhetstester som du kan skriva för ditt CDKTF-projekt. Mer information om enhetstester finns i Enhetstester .
  • main.py, som innehåller Python-koden som du skriver för ditt CDKTF-projekt.
  • Pipfile och Pipfile.lock, som hanterar kodberoenden för ditt CDKTF-projekt.

Steg 2: Definiera resurser

I det här steget använder du Terraform CDK Databricks-providern för att definiera en notebook-fil och ett jobb för att köra anteckningsboken.

  1. Installera projektets beroenden: med hjälp av pipenvinstallerar du i ditt CDKTF-projekt Terraform CDK Databricks-providern för att generera Azure Databricks-resurser. Gör detta genom att köra följande:

    pipenv install cdktf-cdktf-provider-databricks

  2. Ersätt innehållet i main.py filen med följande kod. Den här koden autentiserar CDKTF med din Azure Databricks-arbetsyta och genererar sedan en notebook-fil tillsammans med ett jobb för att köra notebook-filen. Information om hur du visar syntaxdokumentation för den här koden finns i konstruktionsreferensen för Terraform CDK Databricks-providern för 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. Skapa en fil med namnet vars.py i samma katalog som main.py. Ersätt följande värden med dina egna värden för att ange ett resursprefix och klusterinställningar, till exempel antalet arbetare, spark-körningsversionssträngen och nodtypen.

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

Steg 3: Distribuera resurserna

I det här steget använder du CDKTF CLI för att distribuera, till din befintliga Azure Databricks-arbetsyta, den definierade notebook-filen och jobbet för att köra anteckningsboken.

  1. Generera Terraform-kodekvivalenten för ditt CDKTF-projekt. Gör detta via kommandot cdktf synth.

    cdktf synth

  2. Innan du gör ändringar kan du granska de väntande resursändringarna. Kör följande:

    cdktf diff

  3. Distribuera anteckningsboken och jobbet genom att cdktf deploy köra kommandot .

    cdktf deploy

  4. Tryck på Retur när du uppmanas att godkänna. Terraform skapar och distribuerar anteckningsboken och jobbet till din arbetsyta.

Steg 4: Interagera med resurserna

I det här steget kör du jobbet på din Azure Databricks-arbetsyta, som kör den angivna notebook-filen.

  1. Om du vill visa anteckningsboken som jobbet ska köras på din arbetsyta kopierar du länken notebook-URL som visas i kommandots utdata cdk deploy och klistrar in den i webbläsarens adressfält.
  2. Om du vill visa jobbet som kör anteckningsboken på din arbetsyta kopierar du länken Jobb-URL som visas i kommandots utdata cdk deploy och klistrar in den i webbläsarens adressfält.
  3. Om du vill köra jobbet klickar du på knappen Kör nu på jobbsidan.

(Valfritt) Steg 5: Gör ändringar i en resurs

I det här valfria steget ändrar du anteckningsbokens kod, distribuerar om den ändrade anteckningsboken och använder sedan jobbet för att köra den ändrade anteckningsboken igen.

Om du inte vill göra några ändringar i anteckningsboken går du vidare till Steg 6: Rensa.

  1. main.py I filen ändrar du variabeldeklarationen notebook från följande:

    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")
)

    Till följande:

    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")
)

    Kommentar

    Kontrollera att kodraderna mellan med tre citattecken (''') är justerade med kanten på kodredigeraren, som du ser. Annars infogar Terraform ytterligare blanksteg i notebook-filen som kan leda till att den nya Python-koden inte kan köras.

  2. Återskapa Terraform-kodekvivalenten för ditt CDKTF-projekt. Gör detta genom att köra följande:

    cdktf synth

  3. Innan du gör ändringar kan du granska de väntande resursändringarna. Kör följande:

    cdktf diff

  4. Distribuera notebook-ändringarna genom att cdktf deploy köra kommandot .

    cdktf deploy

  5. Tryck på Retur när du uppmanas att godkänna. Terraform ändrar anteckningsbokens innehåll.

  6. Om du vill visa den ändrade notebook-filen som jobbet ska köras på din arbetsyta uppdaterar du anteckningsboken som du öppnade tidigare eller kopierar länken notebook-URL som visas i kommandots utdata cdk deploy och klistrar in den i webbläsarens adressfält.

  7. Om du vill visa jobbet som kör den ändrade anteckningsboken på din arbetsyta uppdaterar du jobbet som du öppnade tidigare eller kopierar länken Jobb-URL som visas i kommandots utdata cdk deploy och klistrar in det i webbläsarens adressfält.

  8. Om du vill köra jobbet klickar du på knappen Kör nu på jobbsidan.

Steg 6: Rensa

I det här steget använder du CDKTF CLI för att ta bort notebook-filen och jobbet från din Azure Databricks-arbetsyta.

  1. Ta bort resurserna från arbetsytan genom att cdktf destroy köra kommandot:

    cdktf destroy

  2. Tryck på Retur när du uppmanas att godkänna. Terraform tar bort resurserna från din arbetsyta.

Testning

Du kan testa ditt CDKTF-projekt innan du distribuerar det. Se Enhetstester i CDKTF-dokumentationen.

För Python-baserade CDKTF-projekt kan du skriva och köra tester med python-testramverkets pytest tillsammans med cdktf paketets Testing klass. Följande exempelfil med namnet test_main.py testar CDKTF-koden i den här artikelns föregående main.py fil. Det första testet kontrollerar om projektets notebook-fil innehåller den förväntade Base64-kodade representationen av anteckningsbokens innehåll. Det andra testet kontrollerar om projektets jobb innehåller det förväntade jobbnamnet. Kör kommandot från projektets rotkatalog för att köra de här testerna pytest .

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"
      }
    )

Fler resurser