Kontroll och distribution av notebook-källa

Den här artikeln beskriver hur du använder Git-integrerings- och distributionspipelines med notebook-filer i Microsoft Fabric. Du lär dig hur du ansluter en lagringsplats, hanterar källkod för notebook-filer och distribuerar notebook-filer i olika miljöer.

Innan du börjar

• Anslut din arbetsyta till Git innan du slutför källkontrollstegen för notebook-filer. Installationsinstruktioner finns i Komma igång med Git-integrering.
• Skapa distributionsregler för notebook-filer på målsteget (till exempel Test eller Produktion), inte på Utveckling.
• Om du vill skapa distributionsregler måste du vara ägare till objektet.

Anteckningsboksintegrering med Git

Fabric Notebooks stöder Git-integrering med Azure DevOps för källkontroll. Du kan versionera ändringar i anteckningsböcker, samarbeta med hjälp av grenar och hantera livscykeluppdateringar för anteckningsböcker direkt i Fabric.

När du checkar in en notebook-fil tillsammans med dess anslutna beroenden (till exempel miljöer) bevarar synkroniseringen till en annan arbetsyta dessa bindningar. Fabric binder automatiskt notebook-filen till motsvarande resurser på den nya arbetsytan.

För att stödja det här beteendet lagrar Fabric logiska identifierare för anslutna resurser i notebook-metadata. Därför kan Git-diff visa metadatauppdateringar från fysiska ID:er till logiska ID:er.

Konfigurera en anslutning

Från arbetsyteinställningar konfigurerar du en anslutning till lagringsplatsen för att checka in och synkronisera ändringar. Installationsinstruktioner finns i Komma igång med Git-integrering. När du har anslutit, visas dina objekt, inklusive notebooks, i källkontrollpanelen.

När du har checkat in notebook-instansen till Git-förvaret kan du se mappstrukturen för anteckningsböcker där.

Nu kan du utföra Git-åtgärder, till exempel Skapa pull-begäran.

Representation av anteckningar i Git

Följande text visar filstrukturen för ett notebook-objekt på Git-lagringsplatsen:

.
├── Notebook_1.Notebook/
│   ├── Resources/ (Optional)
│   │   └── builtin/
│   │       ├── large_dataset.parquet
│   │       └── model_output.parquet
│   ├── .platform
│   ├── fs-settings.json (Optional)
│   ├── notebook-content.py
│   └── notebook-settings.json (Optional)
└── Readme.md

.
├── Notebook_2.Notebook/
│   ├── Resources/ (Optional)
│   │   └── builtin/
│   │       ├── large_dataset.parquet
│   │       └── model_output.parquet
│   ├── .platform
│   ├── fs-settings.json (Optional)
│   ├── notebook-content.sql
│   └── notebook-settings.json (Optional)
└── Readme.md

När du committerar ett notebook-objekt lagrar Fabric det i form av källfiler i stället för en standardfil .ipynb. Till exempel lagras en PySpark-anteckningsbok som notebook-content.py. Det här formatet är enklare att granska i Git-diff.

Källfilen behåller notebook-metadata (inklusive standard lakehouse och bifogad miljö), markdown-celler och kodceller som separata avsnitt. Fabric använder den här strukturen för att rekonstruera anteckningsboken när du synkroniserar tillbaka till en arbetsyta.

Utdata från notebook-celler ingår inte vid synkronisering till Git.

Följande skärmbild visar källformatet på Git-lagringsplatsen:

Git-inställningar för notebook

På panelen med Git-inställningar kan du styra hur anteckningsböcker interagerar med källkontrollen, inklusive alternativ för Git-bindning och hantering av vilka filer i resursmappen som ingår i commit-förfaranden.

Automatisk bindning i Lakehouse i Git

Med Automatisk bindning i Lakehouse kan Fabric matcha rätt standard lakehouse för varje Git-ansluten arbetsyta. Detta minskar manuella ombindningar när du flyttar notebook-filer mellan arbetsytor för utveckling, testning och produktion.

Aktivera den här funktionen från Notebook-inställningar. När du har aktiverat den skapar Fabric notebook-settings.json i arkivet och hanterar den här filen automatiskt. Redigera inte den här filen manuellt.

Mappstöd för resursmappar för notebooks i Git

Den inbyggda Resurser-mappen kan checkas in i Git så att skript och konfigurationsfiler är versionshanterade med anteckningsboken.

Den här funktionen är valfri och inaktiverad som standard. Aktivera det från Notebook-inställningar i avsnittet Git-inställningar. När du aktiverar den inkluderas filer i mappen Resurser i commits. Eftersom incheckningar har en gräns på 50 MB använder du .gitignore fil- eller Git-regler för att exkludera stora eller tillfälliga filer eller mappar.

När du har konfigurerat Git-regler och genomfört ändringar sparar Fabric reglerna på fs-settings.json lagringsplatsen. Fabric genererar och hanterar den här filen för att hålla konfigurationen av förvaret konsekvent. Vi rekommenderar inte heller att du redigerar den här filen direkt på Git-lagringsplatsen.

Notebook i driftsättningspipelines

Använd distributionspipelines för att främja ändringar i notebook-filer i olika steg, till exempel Utveckling, Test och Produktion. Verifiera uppdateringar i tidigare steg innan du befordrar dem till produktion.

Notebook-distribution har stöd för automatisk bindning för standard lakehouse och ansluten miljö när beroende objekt finns på samma arbetsyta. Under distributionen kan Fabric koppla om dessa beroenden till motsvarande objekt på målarbetsytan. Metadataändringar kan visas i diff-vyn.

Om du behöver en specifik standard lakehouse för målsteg konfigurerar du en distributionsregel för att åsidosätta automatisk bindning.

Det nya användargränssnittet för distributionspipeline används för närvarande i den här artikeln. Du kan växla till det gamla användargränssnittet genom att stänga av Ny distributionspipeline.

Använd följande steg för att distribuera notebook-filer via en distributionspipeline.

1. Skapa en distributionspipeline eller öppna en befintlig. För mer information, se Kom igång med distributionspipelines.

2. Tilldela arbetsytor till olika faser enligt dina distributionsmål.

3. Välj, visa och jämför objekt, inklusive notebook-filer, mellan faser. Det markerade märket visar antalet ändrade objekt mellan föregående fas och den aktuella fasen.

   

4. Välj Distribuera för att distribuera notebooks över utveckling-, test- och produktionsfaserna.

   

5. I fönstret Distribuera till det här steget granskar du de nya och ändrade objekten. Om du vill fortsätta distributionen även om ett eller flera objekt misslyckas väljer du Fortsätt distribution om ett eller flera objekt misslyckas.

   När du har granskat och bekräftat markeringen väljer du Distribuera.

   

6. (Valfritt.) Om du vill skapa distributionsregler väljer du Distributionsregler för målstegsobjektet i pipelinen (till exempel Test eller Produktion).

   Allmänna regler och begränsningar finns i Skapa distributionsregler.

   

7. Konfigurera en standardregel för lakehouse för varje notebook-driftsättning.

   Den här regeln styr vilken lakehouse som anteckningsboken ansluter till i målfasen efter distributionen.

   I fönstret Ange distributionsregler väljer du panelen Standard lakehouse .

   Använd listrutorna Från och Till för att mappa standard-lakehouse i ursprungsstadiet till standard-lakehouse i målstadiet.

   • Samma med source lakehouse: Behåll samma standardinställning för lakehouse som vid källsteget.
   • N/A (inget förvalt lakehouse): Ta bort den förvalda lakehouse-inställningen i målstadiet.
   • Övrigt: Ersätt standard lakehouse för källstadiet med ett annat lakehouse i målsstadiet.

   Om du väljer Annat i listrutan Till anger du information om målsjöhuset:

   • Lakehouse-ID
   • Lakehouse-namn
   • Arbetsyte-ID för Lakehouse

   

   Kommentar

   Lakehouse-ID krävs när du konfigurerar den här regeln. Du kan hämta lakehouse-ID:t från objekt-URL:en. Distributionsregler prioriteras framför automatisk bindning. Om en distributionsregel har konfigurerats åsidosätter den den automatiskt anslutna lakehouse.

8. Övervaka distributionsstatusen från distributionshistoriken.

Relaterat innehåll

• Hantera och köra Fabric-notebook-filer med offentliga API:er
• Introduktion till Git-integrering
• Introduktion till distributionspipelines