Köra Git-åtgärder på Databricks Git-mappar (Repos)

Artikeln beskriver hur du utför vanliga Git-åtgärder på din Databricks-arbetsyta med hjälp av Git-mappar, inklusive kloning, förgrening, incheckning och push-överföring.

Klona en lagringsplats som är ansluten till en fjärransluten Git-lagringsplats

1. I sidofältet väljer du Arbetsyta och sedan webbläsaren till mappen där du vill skapa Git-lagringsplatsens klon.

2. Klicka på nedåtpilen till höger om Lägg till uppe till höger på arbetsytan och välj Git-mapp i listrutan.

   

3. I dialogrutan Skapa Git-mapp anger du följande information:

   • URL:en för den Git-lagringsplats som du vill klona i formatet https://example.com/organization/project.git
   • Git-providern för den lagringsplats som du vill klona. Alternativen är GitHub, GitHub Enterprise, GitLab och Azure DevOps (Azure Repos)
   • Namnet på mappen på arbetsytan som ska innehålla innehållet i den klonade lagringsplatsen
   • Om du ska använda gles utcheckning eller inte, där endast underkataloger som anges med hjälp av ett konmönster klonas

   

I det här skedet har du möjlighet att endast klona en delmängd av lagringsplatsens kataloger med hjälp av en gles utcheckning. Det här är användbart om lagringsplatsen är större än databricks-begränsningar som stöds

1. Klicka på Skapa Git-mapp. Innehållet i fjärrlagringsplatsen klonas till Databricks-lagringsplatsen och du kan börja arbeta med dem med git-åtgärder som stöds via din arbetsyta.

Bästa praxis: Samarbeta i Git-mappar

Databricks Git-mappar fungerar effektivt som inbäddade Git-klienter på din arbetsyta så att användarna kan samarbeta med hjälp av Git-baserad källkontroll och versionshantering. Om du vill göra teamsamarbetet mer effektivt använder du en separat Databricks Git-mapp mappad till en fjärransluten Git-lagringsplats för varje användare som arbetar i sin egen utvecklingsgren . Även om flera användare kan bidra med innehåll till en Git-mapp bör endast en utsedd användare utföra Git-åtgärder som pull-, push-, inchecknings- och grenväxling. Om flera användare utför Git-åtgärder på en Git-mapp kan grenhantering bli svår och felbenägen, till exempel när en användare växlar en gren och oavsiktligt växlar den för alla andra användare i den mappen.

Viktigt!

För närvarande kan du inte använda Git CLI för att utföra Git-åtgärder i en Git-mapp. Om du klonar en Git-lagringsplats med hjälp av CLI via ett klusters webbterminal visas inte filerna i Azure Databricks-användargränssnittet.

Öppna Git-dialogrutan

Du kan komma åt Git-dialogrutan från en notebook-fil eller från webbläsaren Databricks Git-mappar.

• Från en notebook-fil klickar du på knappen bredvid namnet på anteckningsboken som identifierar den aktuella Git-grenen.

  

• Från webbläsaren Databricks Git-mappar klickar du på knappen till höger om lagringsplatsens namn. Du kan också högerklicka på lagringsplatsens namn och välja Git... på menyn.

  

Du ser en helskärmsdialogruta där du kan utföra Git-åtgärder.

1. Din aktuella arbetsgren. Du kan välja andra grenar här. Om andra användare har åtkomst till den här Git-mappen ändrar du även grenen för dem om de delar samma arbetsyta. Se en rekommenderad metod för att undvika det här problemet.
2. Knappen för att skapa en ny gren.
3. Listan över filtillgångar och undermappar som är incheckade i din aktuella gren.
4. En knapp som tar dig till git-providern och visar den aktuella grenhistoriken.
5. Knappen för att hämta innehåll från git-fjärrlagringsplatsen.
6. Textruta där du lägger till ett incheckningsmeddelande och en valfri expanderad beskrivning för dina ändringar.
7. Knappen för att checka in ditt arbete till arbetsgrenen och skicka den uppdaterade grenen till git-fjärrlagringsplatsen.

Klicka på kebaben i det övre högra hörnet för att välja mellan ytterligare Git-grenåtgärder, till exempel en hård återställning, en sammanslagning eller en ombasering.

Det här är ditt hem för att utföra Git-åtgärder på din Git-mapp för arbetsytan. Du är begränsad till de Git-åtgärder som visas i användargränssnittet.

Skapa en ny gren

Du kan skapa en ny gren baserat på en befintlig gren från Git-dialogrutan:

Växla till en annan gren

Du kan växla till (checka ut) en annan gren med hjälp av listrutan gren i Git-dialogrutan:

Viktigt!

När du checkar ut en gren i en Git-mapp finns det alltid en chans att grenen tas bort på git-fjärrlagringsplatsen av någon annan. Om en gren tas bort på fjärrplatsen kan den lokala versionen finnas kvar i den associerade Git-mappen i upp till 7 dagar. Det går inte att ta bort lokala grenar i Databricks, så om du måste ta bort dem måste du även ta bort och omgruppera lagringsplatsen.

Checka in och skicka ändringar till git-fjärrlagringsplatsen

När du har lagt till nya anteckningsböcker eller filer, eller gjort ändringar i befintliga anteckningsböcker eller filer, markerar Git-mappens användargränssnitt ändringarna.

Lägg till ett obligatoriskt incheckningsmeddelande för ändringarna och klicka på Checka in och skicka ändringarna till git-fjärrlagringsplatsen.

Om du inte har behörighet att checka in på standardgrenen (till exempel grenen main ) skapar du en ny gren och använder Git-providerns gränssnitt för att skapa en pull-begäran (PR) för att sammanfoga den till standardgrenen.

Kommentar

• Notebook-utdata ingår inte som standard i incheckningar när notebook-filer sparas i källfilformat (.py, .scala, .sql, .r). Information om hur du checkar in notebook-utdata med IPYNB-format finns i Kontrollera ipynb-notebook-utdataartefaktincheckningar

Hämta ändringar från git-fjärrlagringsplatsen

Om du vill hämta ändringar från git-fjärrlagringsplatsen klickar du på Hämta i dialogrutan Git-åtgärder. Notebook-filer och andra filer uppdateras automatiskt till den senaste versionen på din fjärranslutna Git-lagringsplats. Om ändringarna som hämtas från fjärrplatsen står i konflikt med dina lokala ändringar i Databricks måste du lösa sammanslagningskonflikterna.

Viktigt!

Git-åtgärder som hämtar uppströmsändringar rensar notebook-tillståndet. Mer information finns i Inkommande ändringar rensar notebook-tillståndet.

Sammanfoga grenar

Öppna Git Merge-åtgärden genom att välja den från kebaben längst upp till höger i dialogrutan Git-åtgärder.

Sammanslagningsfunktionen i Databricks Git-mappar sammanfogar en gren till en annan med hjälp av git merge. En sammanslagningsåtgärd är ett sätt att kombinera incheckningshistoriken från en gren till en annan gren. den enda skillnaden är den strategi som används för att uppnå detta. För Git-nybörjare rekommenderar vi att du använder sammanslagning (över ombasering) eftersom det inte kräver tvingad push-överföring till en gren och därför inte skriver om incheckningshistoriken.

Mer information om skillnaderna mellan sammanslagning och ombasering av incheckningar finns i Atlassians dokumentation om ämnet.

• Om det finns en sammanslagningskonflikt löser du den i användargränssnittet för Git-mappar.
• Om det inte finns någon konflikt skickas sammanfogningen till den fjärranslutna Git-lagringsplatsen med .git push

Rebase en gren på en annan gren

Få åtkomst till Git Rebase-åtgärden genom att välja den från menyn kebab längst upp till höger i dialogrutan Git-åtgärder.

Ombasering ändrar incheckningshistoriken för en gren. Precis som git mergeintegrerar git rebase ändringar från en gren till en annan. Rebase gör följande:

1. Sparar incheckningarna på din aktuella gren till ett tillfälligt område.
2. Återställer den aktuella grenen till den valda grenen.
3. Gör om varje enskild incheckning som tidigare sparats på den aktuella grenen, vilket resulterar i en linjär historik som kombinerar ändringar från båda grenarna.

En detaljerad förklaring av ombaseringen finns i git rebase.

Varning

Om du använder rebase kan det orsaka versionsproblem för medarbetare som arbetar på samma lagringsplats.

Ett vanligt arbetsflöde är att ombasering av en funktionsgren på huvudgrenen.

Så här gör du en ombasering av en gren på en annan gren:

1. På menyn Gren i användargränssnittet för Git-mappar väljer du den gren som du vill ändra bas på.

2. Välj Rebase från menyn för kebab.

   

3. Välj den gren som du vill ändra bas på.

   Ombaseringen integrerar ändringar från den gren som du väljer här i den aktuella grenen.

Databricks Git-mappar körs git commit och git push --force för att uppdatera den fjärranslutna Git-lagringsplatsen.

Lösa sammanslagningskonflikter

Sammanslagningskonflikter inträffar när 2 eller fler Git-användare försöker sammanfoga ändringar till samma rader i en fil till en gemensam gren och Git inte kan välja de "rätt" ändringar som ska tillämpas. Sammanslagningskonflikter kan också uppstå när en användare försöker hämta eller sammanfoga ändringar från en annan gren till en gren med icke-bakåtkompatibla ändringar.

Om en åtgärd som pull, rebase eller sammanslagning orsakar en sammanslagningskonflikt visar användargränssnittet för Git-mappar en lista över filer med konflikter och alternativ för att lösa konflikterna.

Du har två primära alternativ:

• Använd användargränssnittet för Git-mappar för att lösa konflikten.
• Avbryt Git-åtgärden, ta bort ändringarna i den motstridiga filen manuellt och försök sedan utföra Git-åtgärden igen.

När du löser sammanslagningskonflikter med Användargränssnittet för Git-mappar måste du välja mellan att manuellt lösa konflikterna i redigeraren eller behålla alla inkommande eller aktuella ändringar.

Behåll alla aktuella eller ta inkommande ändringar

Om du vet att du bara vill behålla alla aktuella eller inkommande ändringar klickar du på kebaben till höger om filnamnet i anteckningsboksfönstret och väljer antingen Behåll alla aktuella ändringar eller Ta alla inkommande ändringar. Klicka på knappen med samma etikett för att checka in ändringarna och lösa konflikten.

Dricks

Vill du veta vilket alternativ du ska välja? Färgen på varje alternativ matchar de respektive kodändringar som ska behållas i filen.

Lösa konflikter manuellt

Med manuell konfliktlösning kan du avgöra vilken av de motstridiga raderna som ska accepteras i kopplingen. För sammanslagningskonflikter löser du konflikten genom att direkt redigera innehållet i filen med konflikterna.

Lös konflikten genom att välja de kodrader som du vill bevara och ta bort allt annat, inklusive konfliktmarkörerna för Git-sammanslagning. När du är klar väljer du Markera som löst.

Om du bestämmer dig för att du har gjort fel val när du löser sammanslagningskonflikter klickar du på knappen Avbryt för att avbryta processen och ångra allt. När alla konflikter har lösts klickar du på alternativet Fortsätt sammanfogning eller Fortsätt ombasering för att lösa konflikten och slutföra åtgärden.

Git reset

I Databricks Git-mappar kan du utföra en Git reset i Azure Databricks-användargränssnittet. Git-återställning i Databricks Git-mappar motsvarar git reset --hard kombinerat med git push --force.

Git-återställning ersätter grenens innehåll och historik med det senaste tillståndet för en annan gren. Du kan använda detta när redigeringar står i konflikt med den överordnade grenen, och du har inget emot att förlora dessa redigeringar när du återställer till den överordnade grenen. Läs mer om git reset –hard.

Återställ till en uppströmsgren (fjärranslutning)

Med git reset i det här scenariot:

• Du återställer den valda grenen (till exempel feature_a) till en annan gren (till exempel main).
• Du återställer även den överordnade grenen (fjärrgrenen feature_a ) till main.

Viktigt!

När du återställer förlorar du alla icke-bekräftade och bekräftade ändringar i både den lokala och fjärranslutna versionen av grenen.

Så här återställer du en gren till en fjärrgren:

1. I användargränssnittet för Git-mappar på menyn Gren väljer du den gren som du vill återställa.

   

2. Välj Återställ från menyn för kebab.

   

3. Välj den gren som ska återställas.

   

Konfigurera gles utcheckningsläge

Sparse-utcheckning är en inställning på klientsidan som gör att du kan klona och arbeta med endast en delmängd av fjärrlagringsplatsernas kataloger i Databricks. Detta är särskilt användbart om lagringsplatsens storlek ligger utanför de databricks-gränser som stöds.

Du kan använda Sparse Checkout-läget när du lägger till (kloning) en ny lagringsplats.

1. I dialogrutan Lägg till Git-mapp öppnar du Avancerat.

2. Välj Sparse-utcheckningsläge.

   

3. I rutan Cone patterns (Konmönster ) anger du de konutcheckningsmönster som du vill använda. Avgränsa flera mönster med radbrytningar.

För närvarande kan du inte inaktivera gles utcheckning för en lagringsplats i Azure Databricks.

Så här fungerar konmönster

Information om hur konmönstret fungerar i det glesa utcheckningsläget finns i följande diagram som representerar fjärrlagringsplatsens struktur.

Om du väljer Sparse-utcheckningsläge, men inte anger något konmönster, tillämpas standardkonmönstret. Detta omfattar endast filerna i roten och inga underkataloger, vilket resulterar i en lagringsplatsstruktur enligt följande:

Om du ställer in det glesa mönstret för utcheckningskonen parent/child/grandchild så inkluderas allt innehåll grandchild i katalogen rekursivt. Filerna omedelbart i rotkatalogen /parent, /parent/child och ingår också. Se katalogstrukturen i följande diagram:

Du kan lägga till flera mönster avgränsade med radbrytningar.

Kommentar

Undantagsbeteenden (!) stöds inte i Git-konmönstersyntax.

Ändra glesa inställningar för utcheckning

När en lagringsplats har skapats kan det glesa utcheckningskonmönstret redigeras från Inställningar > Avancerade > konmönster.

Notera följande beteende:

• Om du tar bort en mapp från konmönstret tas den bort från Databricks om det inte finns några icke-bakåtkompatibla ändringar.

• Om du lägger till en mapp via redigering av det glesa utcheckningskonmönstret läggs den till i Databricks utan att det krävs ytterligare hämtning.

• Det går inte att ändra glesa utcheckningsmönster för att ta bort en mapp när det finns icke-utelämnade ändringar i mappen.

  En användare redigerar till exempel en fil i en mapp och genomför inga ändringar. Hon försöker sedan ändra det glesa utcheckningsmönstret så att det inte innehåller den här mappen. I det här fallet godkänns mönstret, men den faktiska mappen tas inte bort. Hon måste återställa mönstret för att inkludera mappen, checka in ändringar och sedan tillämpa det nya mönstret igen.

Kommentar

Du kan inte inaktivera gles utcheckning för en lagringsplats som skapades med Sparse Checkout-läget aktiverat.

Göra och push-överföra ändringar med gles utcheckning

Du kan redigera befintliga filer och checka in och skicka dem från Git-mappen. När du skapar nya mappar med filer ska du inkludera dem i det konmönster som du angav för lagringsplatsen.

Att inkludera en ny mapp utanför konmönstret resulterar i ett fel under inchecknings- och push-åtgärden. Du kan åtgärda det genom att redigera konmönstret så att det innehåller den nya mappen som du försöker checka in och push-överföra.

Mönster för en lagringsplatskonfigurationsfil

Konfigurationsfilen för incheckningsutdata använder mönster som liknar gitignore-mönster och gör följande:

• Positiva mönster möjliggör inkludering av utdata för matchande notebook-filer.
• Negativa mönster inaktiverar inkludering av utdata för matchande notebook-filer.
• Mönster utvärderas i ordning för alla notebook-filer.
• Ogiltiga sökvägar eller sökvägar som .ipynb inte matchar notebook-filer ignoreras.

Positivt mönster: Om du vill inkludera utdata från en notebook-sökväg folder/innerfolder/notebook.ipynbanvänder du följande mönster:

**/*
folder/**
folder/innerfolder/note*

Negativt mönster: Om du vill exkludera utdata för en notebook-fil kontrollerar du att inget av de positiva mönstren matchar eller lägger till ett negativt mönster på rätt plats i konfigurationsfilen. Negativa (exkludera) mönster börjar med !:

!folder/innerfolder/*.ipynb
!folder/**/*.ipynb
!**/notebook.ipynb

Gles utcheckningsbegränsning

Sparse-utcheckning fungerar för närvarande inte för Azure DevOps-lagringsplatser som är större än 4 GB.

Lägga till en lagringsplats och ansluta via fjärranslutning senare

Om du vill hantera och arbeta med Git-mappar programmatiskt använder du REST-API:et för Git-mappar.