Metodtips för programvaruutveckling för notebook-filer

Den här artikeln innehåller en praktisk genomgång som visar hur du tillämpar metodtips för programvaruutveckling på dina Azure Databricks-notebook-filer, inklusive versionskontroll, koddelning, testning och valfritt kontinuerlig integrering och kontinuerlig leverans eller distribution (CI/CD).

I den här genomgången kommer du att:

• Lägg till notebook-filer i Azure Databricks Git-mappar för versionskontroll.
• Extrahera delar av kod från en av notebook-filerna till en delbar modul.
• Testa den delade koden.
• Kör notebook-filerna från ett Azure Databricks-jobb.
• Du kan också använda CI/CD på den delade koden.

Krav

För att slutföra den här genomgången måste du ange följande resurser:

• En fjärrlagringsplats med en Git-provider som Databricks stöder. I den här artikelns genomgång används GitHub. Den här genomgången förutsätter att du har en GitHub-lagringsplats med namnet best-notebooks tillgänglig. (Du kan ge lagringsplatsen ett annat namn. Om du gör det ersätter best-notebooks du med lagringsplatsens namn under den här genomgången.) Skapa en GitHub-lagringsplats om du inte redan har en.

  Kommentar

  Om du skapar en ny lagringsplats måste du initiera lagringsplatsen med minst en fil, till exempel en README fil.

• En Azure Databricks-arbetsyta. Skapa en arbetsyta om du inte redan har en.

• Ett Azure Databricks-kluster för alla syften på arbetsytan. Om du vill köra notebook-filer under designfasen kopplar du anteckningsböckerna till ett kluster med alla syften som körs. Senare använder den här genomgången ett Azure Databricks-jobb för att automatisera körningen av notebook-filer i det här klustret. (Du kan också köra jobb på jobbkluster som bara finns för jobbens livslängd.) Skapa ett all-purpose-kluster om du inte redan har ett.

Steg 1: Konfigurera Databricks Git-mappar

I det här steget ansluter du din befintliga GitHub-lagringsplats till Azure Databricks Git-mappar i din befintliga Azure Databricks-arbetsyta.

Om du vill aktivera din arbetsyta för att ansluta till din GitHub-lagringsplats måste du först ange din arbetsyta med dina GitHub-autentiseringsuppgifter, om du inte redan har gjort det.

Steg 1.1: Ange dina GitHub-autentiseringsuppgifter

1. Klicka på ditt användarnamn längst upp till höger på arbetsytan och klicka sedan på Inställningar i listrutan.
2. I sidofältet Inställningar under Användare klickar du på Länkade konton.
3. Under Git-integreringväljer du GitHubför Git-provider.
4. Klicka på Personlig åtkomsttoken.
5. Ange ditt GitHub-användarnamn för Git-providerns användarnamn eller e-postadress.
6. För Token anger du din personliga Åtkomsttoken för GitHub (klassisk). Den här personliga åtkomsttoken (klassisk) måste ha lagringsplatsen och arbetsflödesbehörigheterna.
7. Klicka på Spara.

Steg 1.2: Anslut till din GitHub-lagringsplats

1. I sidofältet för arbetsytan klickar du på Arbetsyta.
2. I webbläsaren Arbetsyta expanderar du Arbetsyteanvändare>.
3. Högerklicka på din användarnamnsmapp och klicka sedan på Skapa > Git-mapp.
4. I dialogrutan Skapa Git-mapp:
   1. För Git-lagringsplats-URL anger du GitHub Clone med HTTPS-URL för din GitHub-lagringsplats. Den här artikeln förutsätter att url:en slutar med best-notebooks.git, till exempel https://github.com/<your-GitHub-username>/best-notebooks.git.
   2. För Git-providerväljer du GitHub.
   3. Låt Git-mappnamn vara inställt på namnet för ditt repo, till exempel best-notebooks.
   4. Klicka på Skapa Git-mapp.

Steg 2: Importera och kör notebook-filen

I det här steget importerar du en befintlig extern notebook-fil till lagringsplatsen. Du kan skapa egna notebook-filer för den här genomgången, men för att påskynda saker och ting tillhandahåller vi dem här.

Steg 2.1: Skapa en arbetsgren på lagringsplatsen

I det här understeget skapar du en gren med namnet eda på lagringsplatsen. Med den här grenen kan du arbeta med filer och kod oberoende av lagringsplatsens main gren, vilket är bästa praxis för programvaruutveckling. (Du kan ge din gren ett annat namn.)

1. Git-mappen från steg 1.2 bör vara öppen. Om inte, expanderar i >, expanderar sedan din användarnamnsmapp och klickar på din Git-mapp.

2. Klicka på git-grenens huvudknapp bredvid mappnamnet under arbetsytans navigeringsbredd.

3. I dialogrutan bästa notebook-filer klickar du på knappen Skapa gren.

   Kommentar

   Om lagringsplatsen har ett annat namn än best-notebookskommer den här dialogrutans rubrik att vara annorlunda, här och under den här genomgången.

4. Ange edaoch klicka på Skapa.

5. Stäng den här dialogrutan.

Steg 2.2: Importera anteckningsboken till lagringsplatsen

I det här understeget importerar du en befintlig notebook-fil från en annan lagringsplats till lagringsplatsen. Den här notebook-filen gör följande:

• Kopierar en CSV-fil från GitHub-lagringsplatsen owid/covid-19-data till ett kluster på din arbetsyta. Den här CSV-filen innehåller offentliga data om COVID-19-sjukhusinläggningar och intensivvårdsmått från hela världen.
• Läser csv-filens innehåll i en PandasDataFrame.
• Filtrerar data så att de endast innehåller mått från USA.
• Visar ett diagram över data.
• Sparar Pandas DataFrame som ett Pandas-API på SparkDataFrame.
• Utför datarensning i Pandas-API:et på Spark DataFrame.
• Skriver Pandas API på Spark DataFrame som en Delta-tabell på din arbetsyta.
• Visar deltatabellens innehåll.

Du kan skapa en egen notebook-fil på lagringsplatsen här, men om du importerar en befintlig notebook-fil kan du i stället påskynda den här genomgången. Information om hur du skapar en notebook-fil i den här grenen eller flyttar en befintlig notebook-fil till den här grenen i stället för att importera en notebook-fil finns i Grundläggande användning av arbetsytefiler.

1. Från git-mappen best-notebooks klickar du på Skapa > mapp.
2. I dialogrutan Ny mapp anger du notebooksoch klickar sedan på Skapa.
3. Från mappen notebooks klickar du på kebaben och sedan på Importera.
4. I dialogrutan Importera:

   1. För Importera frånväljer du URL.

   2. Ange URL:en till det råa innehållet covid_eda_raw i notebook-filen på databricks/notebook-best-practices lagringsplatsen i GitHub. Så här hämtar du den här URL:en: i. Gå till https://github.com/databricks/notebook-best-practices. ii. Klicka på notebooks mappen. iii. Klicka på covid_eda_raw.py filen. iv. Klicka på Rå. v. Kopiera den fullständiga URL:en från webbläsarens adressfält till dialogrutan Importera .

      Kommentar

      Dialogrutan Importera fungerar endast med Git-URL:er för offentliga lagringsplatser.

   3. Klicka på Importera.

Steg 2.3: Kör anteckningsboken

1. Om anteckningsboken inte redan visas öppnar du mappen Notebooks och klickar sedan på den covid_eda_raw notebook-filen i mappen.
2. Välj det kluster som denna notebook ska kopplas till. Anvisningar om hur du skapar ett kluster finns i Skapa ett kluster.
3. Klicka på Kör alla.
4. Vänta medan notebook-filen körs.

När anteckningsboken har körts klart bör du se ett diagram över datan samt över 600 rader med rådata i Delta-tabellen. Om klustret inte redan kördes när du började köra den här notebook-filen kan det ta flera minuter för klustret att starta innan resultatet visas.

Steg 2.4: Checka in och sammanfoga anteckningsboken

I det här understeget sparar du ditt arbete hittills på din GitHub-lagringsplats. Sedan sammanfogar du anteckningsboken från din arbetsgren till lagringsplatsens main gren.

1. Bredvid anteckningsbokens namn klickar du på eda Git-grenknappen.
2. I dialogrutan bästa anteckningsböcker på fliken Ändringar kontrollerar du att filen notebooks/covid_eda_raw.py är markerad.
3. För Incheckningsmeddelande (krävs)anger du Added raw notebook.
4. För Beskrivning (valfritt)anger du This is the first version of the notebook.
5. Klicka på Checka in och skicka.
6. Klicka på länken för pull-begäran i Skapa en pull-begäran på git-providern i banderollen.
7. I GitHub skapar du pull-begäran och sammanfogar sedan pull-begäran till grenen main .
8. Gå tillbaka till Azure Databricks-arbetsytan och stäng dialogrutan bästa notebook-filer om den fortfarande visas.

Steg 3: Flytta kod till en delad modul

I det här steget flyttar du en del av koden i anteckningsboken till en uppsättning delade funktioner utanför anteckningsboken. På så sätt kan du använda dessa funktioner med andra liknande notebook-filer, vilket kan påskynda framtida kodning och säkerställa mer förutsägbara och konsekventa notebook-resultat. Genom att dela den här koden kan du också enklare testa dessa funktioner, vilket som en metod för programvaruutveckling kan höja kodens övergripande kvalitet allt eftersom.

Steg 3.1: Skapa en annan arbetsgren på lagringsplatsen

1. Bredvid anteckningsbokens namn klickar du på eda Git-grenknappen.
2. I dialogrutan bästa anteckningsböcker klickar du på listrutepilen bredvid grenen eda och väljer huvud.
3. Klicka på knappen Dra . Om du uppmanas att fortsätta med att hämta klickar du på Bekräfta.
4. Klicka på knappen Skapa gren .
5. Ange first_modulesoch klicka sedan på Skapa. (Du kan ge din gren ett annat namn.)
6. Stäng den här dialogrutan.

Steg 3.2: Importera anteckningsboken till lagringsplatsen

För att påskynda den här genomgången importerar du en annan befintlig notebook-fil till lagringsplatsen i det här understeget. Den här notebook-filen gör samma saker som den tidigare notebook-filen, förutom att den här notebook-filen anropar delade kodfunktioner som lagras utanför notebook-filen. Återigen kan du skapa en egen notebook-fil på lagringsplatsen här och göra den faktiska koddelningen själv.

1. Högerklicka på mappen Notebooks i webbläsaren Arbetsyta och klicka sedan på Importera.
2. I dialogrutan Importera:

   1. För Importera frånväljer du URL.

   2. Ange URL:en till det råa innehållet covid_eda_modular i notebook-filen på databricks/notebook-best-practices lagringsplatsen i GitHub. Så här hämtar du den här URL:en: i. Gå till https://github.com/databricks/notebook-best-practices. ii. Klicka på notebooks mappen. iii. Klicka på covid_eda_modular.py filen. iv. Klicka på Rå. v. Kopiera den fullständiga URL:en från webbläsarens adressfält till dialogrutan Importera anteckningsböcker .

      Kommentar

      Dialogrutan Importera anteckningsböcker fungerar endast med Git-URL:er för offentliga lagringsplatser.

   3. Klicka på Importera.

Steg 3.3: Lägg till notebook-filens stödfunktioner för delad kod

1. I webbläsaren Arbetsyta högerklickar du på Git-mappen best-notebooks och klickar sedan på Skapa > mapp.

2. I dialogrutan Ny mapp anger du covid_analysisoch klickar sedan på Skapa.

3. Klicka på Skapa fil i mappen covid_analysis.>

4. I dialogrutan Nytt filnamn anger du transforms.pyoch klickar sedan på Skapa fil.

5. I fönstret transforms.py redigerare anger du följande kod:

   import pandas as pd
   
   # Filter by country code.
   def filter_country(pdf, country="USA"):
     pdf = pdf[pdf.iso_code == country]
     return pdf
   
   # Pivot by indicator, and fill missing values.
   def pivot_and_clean(pdf, fillna):
     pdf["value"] = pd.to_numeric(pdf["value"])
     pdf = pdf.fillna(fillna).pivot_table(
       values="value", columns="indicator", index="date"
     )
     return pdf
   
   # Create column names that are compatible with Delta tables.
   def clean_spark_cols(pdf):
     pdf.columns = pdf.columns.str.replace(" ", "_")
     return pdf
   
   # Convert index to column (works with pandas API on Spark, too).
   def index_to_col(df, colname):
     df[colname] = df.index
     return df
   

Steg 3.4: Lägg till den delade kodens beroenden

Föregående kod har flera Python-paketberoenden för att koden ska kunna köras korrekt. I det här understeget deklarerar du dessa paketberoenden. Att deklarera beroenden förbättrar reproducerbarheten med hjälp av exakt definierade versioner av bibliotek.

1. I webbläsaren Arbetsyta högerklickar du på git-mappen best-notebooks och klickar sedan på Skapa > fil.

   Kommentar

   Du vill att filen som visar paketberoenden ska gå till Git-mappens rot, inte i notebook-filerna eller covid_analysis mapparna.

2. I dialogrutan Nytt filnamn anger du requirements.txtoch klickar sedan på Skapa fil.

3. I fönstret requirements.txt redigerare anger du följande kod:

   Kommentar

   Om requirements.txt filen inte visas kan du behöva uppdatera webbläsaren.

   -i https://pypi.org/simple
   attrs==21.4.0
   cycler==0.11.0
   fonttools==4.33.3
   iniconfig==1.1.1
   kiwisolver==1.4.2
   matplotlib==3.5.1
   numpy==1.22.3
   packaging==21.3
   pandas==1.4.2
   pillow==9.1.0
   pluggy==1.0.0
   py==1.11.0
   py4j==0.10.9.3
   pyarrow==7.0.0
   pyparsing==3.0.8
   pyspark==3.2.1
   pytest==7.1.2
   python-dateutil==2.8.2
   pytz==2022.1
   six==1.16.0
   tomli==2.0.1
   wget==3.2
   

   Kommentar

   Föregående fil visar en lista över specifika paketversioner. För bättre kompatibilitet kan du korsreferensera dessa versioner med de som är installerade i ditt all-purpose-kluster. Se avsnittet "Systemmiljö" för ditt klusters Databricks Runtime-version i Databricks Runtime versionsanteckningar och kompatibilitet.

Lagringsplatsens struktur bör nu se ut så här:

|-- covid_analysis
│  └── transforms.py
├── notebooks
│  ├── covid_eda_modular
│  └── covid_eda_raw (optional)
└── requirements.txt

Steg 3.5: Kör den omstrukturerade notebook-filen

I det här understeget covid_eda_modular kör du notebook-filen, som anropar den delade koden i covid_analysis/transforms.py.

1. I webbläsaren Arbetsyta klickar du på den covid_eda_modular notebook-filen i mappen Notebooks.
2. Välj det kluster som denna notebook ska kopplas till.
3. Klicka på Kör alla.
4. Vänta medan notebook-filen körs.

När notebook-filen har körts bör du i notebook se liknande resultat som i covid_eda_raw-filen: ett diagram över data samt mer än 600 rader rådata i Delta-tabellen. Den största skillnaden med den här notebook-filen är att ett annat filter används (ett iso_code i DZA stället för USA). Om klustret inte redan kördes när du började köra den här notebook-filen kan det ta flera minuter för klustret att starta innan resultatet visas.

Steg 3.6: Checka in anteckningsboken och dess relaterade kod

1. Klicka på first_modules Git-grenen bredvid anteckningsbokens namn.
2. I dialogrutan bästa anteckningsböcker på fliken Ändringar kontrollerar du att följande är markerade:
   • requirements.txt
   • covid_analysis/transforms.py
   • notebook-filer/covid_eda_modular.py
3. För Incheckningsmeddelande (krävs)anger du Added refactored notebook.
4. För Beskrivning (valfritt)anger du This is the second version of the notebook.
5. Klicka på Checka in och skicka.
6. Klicka på länken för pull-begäran i Skapa en pull-begäran på git-providern i banderollen.
7. I GitHub skapar du pull-begäran och sammanfogar sedan pull-begäran till grenen main .
8. Gå tillbaka till Azure Databricks-arbetsytan och stäng dialogrutan bästa notebook-filer om den fortfarande visas.

Steg 4: Testa den delade koden

I det här steget testar du den delade koden från det senaste steget. Du vill dock testa den här koden utan att köra själva notebook-filen covid_eda_modular . Det beror på att om den delade koden inte kan köras skulle notebook-filen förmodligen också misslyckas. Du vill fånga fel i den delade koden först innan huvudanteckningsboken misslyckas senare. Den här testtekniken är en metod för programvaruutveckling.

Steg 4.1: Skapa en annan arbetsgren på lagringsplatsen

1. Klicka på first_modules Git-grenen bredvid anteckningsbokens namn.
2. I dialogrutan bästa notebook-filer klickar du på listrutepilen bredvid grenen first_modules och väljer main.
3. Klicka på knappen Dra . Om du uppmanas att fortsätta med att hämta klickar du på Bekräfta.
4. Klicka på Skapa gren.
5. Ange first_testsoch klicka sedan på Skapa. (Du kan ge din gren ett annat namn.)
6. Stäng den här dialogrutan.

Steg 4.2: Lägg till testerna

I det här understeget använder du pytest-ramverket för att testa din delade kod. I de här testerna kontrollerar du om vissa testresultat uppnås. Om ett test ger ett oväntat resultat misslyckas det specifika testet med försäkran och därför misslyckas själva testet.

1. Högerklicka på din Git-mapp i webbläsaren Arbetsyta och klicka sedan på Skapa > mapp.

2. I dialogrutan Ny mapp anger du testsoch klickar sedan på Skapa.

3. I testmappen klickar du på Skapa > fil.

4. I dialogrutan Nytt filnamn anger du testdata.csvoch klickar sedan på Skapa fil.

5. I testdata.csv redigeringsfönster anger du följande testdata:

   entity,iso_code,date,indicator,value
   United States,USA,2022-04-17,Daily ICU occupancy,
   United States,USA,2022-04-17,Daily ICU occupancy per million,4.1
   United States,USA,2022-04-17,Daily hospital occupancy,10000
   United States,USA,2022-04-17,Daily hospital occupancy per million,30.3
   United States,USA,2022-04-17,Weekly new hospital admissions,11000
   United States,USA,2022-04-17,Weekly new hospital admissions per million,32.8
   Algeria,DZA,2022-04-18,Daily ICU occupancy,1010
   Algeria,DZA,2022-04-18,Daily ICU occupancy per million,4.5
   Algeria,DZA,2022-04-18,Daily hospital occupancy,11000
   Algeria,DZA,2022-04-18,Daily hospital occupancy per million,30.9
   Algeria,DZA,2022-04-18,Weekly new hospital admissions,10000
   Algeria,DZA,2022-04-18,Weekly new hospital admissions per million,32.1
   

6. I testmappen klickar du på Skapa > fil.

7. I dialogrutan Nytt filnamn anger du transforms_test.pyoch klickar sedan på Skapa fil.

8. I transforms_test.py redigeringsfönster anger du följande testkod. Dessa tester använder standardarmaturer pytest samt en hånad minnesintern Pandas DataFrame:

   # Test each of the transform functions.
   import pytest
   from textwrap import fill
   import os
   import pandas as pd
   import numpy as np
   from covid_analysis.transforms import *
   from pyspark.sql import SparkSession
   
   @pytest.fixture
   def raw_input_df() -> pd.DataFrame:
     """
     Create a basic version of the input dataset for testing, including NaNs.
     """
     return pd.read_csv('tests/testdata.csv')
   
   @pytest.fixture
   def colnames_df() -> pd.DataFrame:
     df = pd.DataFrame(
       data=[[0,1,2,3,4,5]],
       columns=[
         "Daily ICU occupancy",
         "Daily ICU occupancy per million",
         "Daily hospital occupancy",
         "Daily hospital occupancy per million",
         "Weekly new hospital admissions",
         "Weekly new hospital admissions per million"
       ]
     )
     return df
   
   # Make sure the filter works as expected.
   def test_filter(raw_input_df):
     filtered = filter_country(raw_input_df)
     assert filtered.iso_code.drop_duplicates()[0] == "USA"
   
   # The test data has NaNs for Daily ICU occupancy; this should get filled to 0.
   def test_pivot(raw_input_df):
     pivoted = pivot_and_clean(raw_input_df, 0)
     assert pivoted["Daily ICU occupancy"][0] == 0
   
   # Test column cleaning.
   def test_clean_cols(colnames_df):
     cleaned = clean_spark_cols(colnames_df)
     cols_w_spaces = cleaned.filter(regex=(" "))
     assert cols_w_spaces.empty == True
   
   # Test column creation from index.
   def test_index_to_col(raw_input_df):
     raw_input_df["col_from_index"] = raw_input_df.index
     assert (raw_input_df.index == raw_input_df.col_from_index).all()
   

Lagringsplatsens struktur bör nu se ut så här:

├── covid_analysis
│  └── transforms.py
├── notebooks
│  ├── covid_eda_modular
│  └── covid_eda_raw (optional)
├── requirements.txt
└── tests
    ├── testdata.csv
    └── transforms_test.py

Steg 4.3: Kör testerna

För att påskynda den här genomgången använder du i det här understeget en importerad notebook-fil för att köra föregående tester. Den här notebook-filen laddar ned och installerar testernas beroende Python-paket till din arbetsyta, kör testerna och rapporterar testresultaten. Även om du kan köra pytest från klustrets webbterminal kan det vara enklare att köra pytest från en notebook-fil.

1. Högerklicka på mappen Notebooks i webbläsaren Arbetsyta och klicka sedan på Importera.
2. I dialogrutan Importera anteckningsböcker:

   1. För Importera frånväljer du URL.

   2. Ange URL:en till det råa innehållet run_unit_tests i notebook-filen på databricks/notebook-best-practices lagringsplatsen i GitHub. Så här hämtar du den här URL:en: i. Gå till https://github.com/databricks/notebook-best-practices. ii. Klicka på notebooks mappen. iii. Klicka på run_unit_tests.py filen. iv. Klicka på Rå. v. Kopiera den fullständiga URL:en från webbläsarens adressfält till dialogrutan Importera anteckningsböcker .

      Kommentar

      Dialogrutan Importera anteckningsböcker fungerar endast med Git-URL:er för offentliga lagringsplatser.

   3. Klicka på Importera.

3. Välj det kluster som denna notebook ska kopplas till.
4. Klicka på Kör alla.
5. Vänta medan notebook-filen körs.

När notebook-filen har körts bör du i anteckningsboken se information om antalet tester som har godkänts och misslyckats, tillsammans med annan relaterad information. Om klustret inte redan kördes när du började köra den här notebook-filen kan det ta flera minuter för klustret att starta innan resultatet visas.

Lagringsplatsens struktur bör nu se ut så här:

├── covid_analysis
│  └── transforms.py
├── notebooks
│  ├── covid_eda_modular
│  ├── covid_eda_raw (optional)
│  └── run_unit_tests
├── requirements.txt
└── tests
    ├── testdata.csv
    └── transforms_test.py

Steg 4.4: Checka in notebook-filen och relaterade tester

1. Klicka på first_tests Git-grenen bredvid anteckningsbokens namn.
2. I dialogrutan bästa anteckningsböcker på fliken Ändringar kontrollerar du att följande är markerade:
   • tester/transforms_test.py
   • notebook-filer/run_unit_tests.py
   • tester/testdata.csv
3. För Incheckningsmeddelande (krävs)anger du Added tests.
4. För Beskrivning (valfritt)anger du These are the unit tests for the shared code..
5. Klicka på Checka in och skicka.
6. Klicka på länken för pull-begäran i Skapa en pull-begäran på git-providern i banderollen.
7. I GitHub skapar du pull-begäran och sammanfogar sedan pull-begäran till grenen main .
8. Gå tillbaka till Azure Databricks-arbetsytan och stäng dialogrutan bästa notebook-filer om den fortfarande visas.

Steg 5: Skapa ett jobb för att köra notebook-filerna

I föregående steg testade du den delade koden manuellt och körde dina notebook-filer manuellt. I det här steget använder du ett Azure Databricks-jobb för att testa din delade kod och köra dina notebook-filer automatiskt, antingen på begäran eller enligt ett regelbundet schema.

Steg 5.1: Skapa en jobbaktivitet för att köra testanteckningsboken

1. Klicka på Arbetsflöden i arbetsytans sidofält.
2. På fliken Jobb klickar du på Skapa jobb.
3. Redigera namnet på jobbet så att det blir covid_report.
4. Som Uppgiftsnamn anger du run_notebook_tests.
5. För Typväljer du Notebook.
6. För Sourceväljer du Git-provider.
7. Klicka på Lägg till en git-referens.
8. I dialogrutan Git-information:
   1. För Git-lagringsplats-URL anger du GitHub Clone med HTTPS-URL för din GitHub-lagringsplats. Den här artikeln förutsätter att url:en slutar med best-notebooks.git, till exempel https://github.com/<your-GitHub-username>/best-notebooks.git.
   2. För Git-providerväljer du GitHub.
   3. För Git-referens (gren/tagg/incheckning)anger du main.
   4. Bredvid Git-referens (gren/tagg/commit), välj gren.
   5. Klicka på Bekräfta.
9. För Sökväg anger du notebooks/run_unit_tests. Lägg inte till filtillägget .py .
10. För Klusterväljer du klustret i föregående steg.
11. Klicka på Skapa uppgift.

Steg 5.2: Skapa en jobbaktivitet för att köra huvudanteckningsboken

1. Klicka på ikonen + Lägg till aktivitet.
2. En popup-meny visas. Välj Notebook.
3. Som Uppgiftsnamn anger du run_main_notebook.
4. För Typväljer du Notebook.
5. För Sökväg anger du notebooks/covid_eda_modular. Lägg inte till filtillägget .py .
6. För Klusterväljer du klustret i föregående steg.
7. Kontrollera att Beror på värdet är run_notebook-tests.
8. Klicka på Skapa uppgift.

Steg 5.3 Kör jobbet

1. Klicka på Kör nu.

2. I popup-fönstret klickar du på Visa körning.

   Kommentar

   Om popup-fönstret försvinner för snabbt gör du följande:

   1. Klicka på Arbetsflöden i sidofältet i ai-miljön Datavetenskap & Engineering eller Databricks Mosaic.
   2. På fliken Jobb körs klickar du på värdet Starttid för det senaste jobbet med covid_report i kolumnen Jobb.

3. Om du vill se jobbresultatet klickar du på panelen run_notebook_tests , panelen run_main_notebook eller båda. Resultatet på varje panel är detsamma som om du körde anteckningsböckerna själv, en i taget.

(Valfritt) Steg 6: Konfigurera lagringsplatsen för att testa koden och köra notebook-filen automatiskt när koden ändras

I föregående steg använde du ett jobb för att automatiskt testa din delade kod och köra dina notebook-filer vid en tidpunkt eller regelbundet. Du kanske dock föredrar att utlösa tester automatiskt när ändringar sammanfogas till din GitHub-lagringsplats med hjälp av ett CI/CD-verktyg som GitHub Actions.

Steg 6.1: Konfigurera GitHub-åtkomst till din arbetsyta

I det här understeget konfigurerar du ett GitHub Actions-arbetsflöde som kör jobb i miljön när ändringar slås samman till ditt repository. Det gör du genom att ge GitHub en unik Azure Databricks-token för åtkomst.

Av säkerhetsskäl avråder Databricks dig från att ge din Azure Databricks-arbetsyteanvändares personliga åtkomsttoken till GitHub. I stället rekommenderar Databricks att du ger GitHub en Microsoft Entra-ID-token som är associerad med tjänstens huvudnamn för Microsoft Entra-ID. Anvisningar finns i Avsnittet Azure på GitHub-åtgärdssidan för Run Databricks Notebook på GitHub Actions Marketplace.

Steg 6.2: Lägg till GitHub Actions-arbetsflödet

I det här understeget lägger du till ett GitHub Actions-arbetsflöde för att köra run_unit_tests notebook-filen när det finns en pull-begäran till lagringsplatsen.

Det här understeget lagrar GitHub Actions-arbetsflödet i en fil som lagras på flera mappnivåer på din GitHub-lagringsplats. GitHub Actions kräver att en specifik kapslad mapphierarki finns på lagringsplatsen för att fungera korrekt. För att slutföra det här steget måste du använda webbplatsen för din GitHub-lagringsplats, eftersom användargränssnittet för Azure Databricks Git-mappen inte har stöd för att skapa kapslade mapphierarkier.

1. På webbplatsen för din GitHub-lagringsplats klickar du på fliken Kod .

2. Klicka på pilen bredvid huvud för att expandera listrutan Växla grenar eller taggar.

3. I rutan Hitta eller skapa en gren anger du adding_github_actions.

4. Klicka på Skapa gren: adding_github_actions från "main".

5. Klicka på Lägg till fil > Skapa ny fil.

6. För Namnge filen anger du .github/workflows/databricks_pull_request_tests.yml.

7. I redigeringsfönstret anger du följande kod. Den här koden använder pull_request-kroken från GitHub-åtgärden Kör Databricks Notebook för att köra notebook-filen run_unit_tests .

   I följande kod ersätter du:

   • <your-workspace-instance-URL>med ditt Azure Databricks-instansnamn.
   • <your-access-token> med den token som du genererade tidigare.
   • <your-cluster-id>med ditt målkluster-ID.

   name: Run pre-merge Databricks tests
   
   on:
     pull_request:
   
   env:
     # Replace this value with your workspace instance name.
     DATABRICKS_HOST: https://<your-workspace-instance-name>
   
   jobs:
     unit-test-notebook:
       runs-on: ubuntu-latest
       timeout-minutes: 15
   
       steps:
         - name: Checkout repo
           uses: actions/checkout@v2
         - name: Run test notebook
           uses: databricks/run-notebook@main
           with:
             databricks-token: <your-access-token>
   
             local-notebook-path: notebooks/run_unit_tests.py
   
             existing-cluster-id: <your-cluster-id>
   
             git-commit: "${{ github.event.pull_request.head.sha }}"
   
             # Grant all users view permission on the notebook's results, so that they can
             # see the result of the notebook, if they have related access permissions.
             access-control-list-json: >
               [
                 {
                   "group_name": "users",
                   "permission_level": "CAN_VIEW"
                 }
               ]
             run-name: "EDA transforms helper module unit tests"
   

8. Klicka på Genomför ändringar.

9. I dialogrutan Checka in ändringar anger du Create databricks_pull_request_tests.yml i Incheckningsmeddelande

10. Välj Kommittera direkt till adding_github_actions-grenen och klicka på Kommittera ändringar.

11. På fliken Kod klickar du på Jämför och pull-begäran och skapar sedan pull-begäran.

12. På sidan pull-begäran väntar du på att ikonen bredvid Kör försammanfogning av Databricks-tester/unit-test-notebook (pull_request) ska visa en grön bockmarkering. (Det kan ta en stund innan ikonen visas.) Om det finns ett rött X i stället för en grön bockmarkering klickar du på Information för att ta reda på varför. Om ikonen eller Informationen inte längre visas klickar du på Visa alla kontroller.

13. Om den gröna bockmarkeringen visas sammanfogar du pull-begäran till grenen main .

(Valfritt) Steg 7: Uppdatera den delade koden i GitHub för att utlösa tester

I det här steget gör du en ändring i den delade koden och push-överför sedan ändringen till din GitHub-lagringsplats, som omedelbart utlöser testerna automatiskt, baserat på GitHub-åtgärden från föregående steg.

Steg 7.1: Skapa en annan arbetsgren på lagringsplatsen

1. Öppna Git-mappen best-notebooks i webbläsaren Arbetsyta.
2. Klicka på first_tests Git-grenen bredvid mappens namn.
3. I dialogrutan bästa notebookar klickar du på listrutepilen bredvid grenen first_tests och väljer huvud.
4. Klicka på knappen Dra . Om du uppmanas att fortsätta med att hämta klickar du på Bekräfta.
5. + Klicka på knappen (Skapa gren).
6. Ange trigger_testsoch klicka sedan på Skapa. (Du kan ge din gren ett annat namn.)
7. Stäng den här dialogrutan.

Steg 7.2: Ändra den delade koden

1. Klicka på filen covid_analysis/transforms.py i git-mappen best-notebooks i webbläsaren Arbetsyta.

2. Ändra den tredje raden i den här filen:

   # Filter by country code.
   

   Så här gör du:

   # Filter by country code. If not specified, use "USA."
   

Steg 7.3: Kontrollera ändringen för att utlösa testerna

1. Klicka på trigger_tests Git-grenen bredvid filens namn.
2. Kontrollera att covid_analysis/transforms.py är markerad på fliken Ändringar i dialogrutan bästa anteckningsböcker.
3. För Incheckningsmeddelande (krävs)anger du Updated comment.
4. För Beskrivning (valfritt)anger du This updates the comment for filter_country.
5. Klicka på Checka in och skicka.
6. Klicka på länken för pull-begäran i Skapa en pull-begäran på git-providern i banderollen och skapa sedan pull-begäran i GitHub.
7. På sidan pull-begäran väntar du på att ikonen bredvid Kör försammanfogning av Databricks-tester/unit-test-notebook (pull_request) ska visa en grön bockmarkering. (Det kan ta en stund innan ikonen visas.) Om det finns ett rött X i stället för en grön bockmarkering klickar du på Information för att ta reda på varför. Om ikonen eller Informationen inte längre visas klickar du på Visa alla kontroller.
8. Om den gröna bockmarkeringen visas sammanfogar du pull-begäran till grenen main .