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

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

Du kan skapa Git-mappar med hjälp av Databricks-användargränssnittet eller webbterminalen.

Kommentar

• Du måste ha CAN MANAGE behörighet för den överordnade mappen där du vill skapa Git-mappen.
• Din arbetsyta måste ha konfigurerade Git-autentiseringsuppgifter. Se Konfigurera Git-autentiseringsuppgifter och ansluta en fjärransluten lagringsplats till Azure Databricks.

Klona från användargränssnittet

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

2. Klicka på Skapa>Git-mapp.

   

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

   Fält	Description
   URL för Git-lagringsplats	URL:en för den Git-lagringsplats som du vill klona i formatet https://example.com/organization/project.git
   Git-leverantör	Git-providern för den lagringsplats som du vill klona. Alternativen är GitHub, GitHub Enterprise, GitLab och Azure DevOps (Azure Repos)
   Git-mappnamn	Namnet på mappen på arbetsytan som ska innehålla innehållet i den klonade lagringsplatsen
   Gles utcheckning	Om du vill använda sparse checkout, där endast en delmängd av ditt förvaringsplatsens kataloger klonas, och detta anges med hjälp av ett konmönster. Det här är användbart om lagringsplatsen är större än de begränsningar som stöds av Databricks .
   Använd Git CLI (Beta)	Aktivera för att köra Git-standardkommandon direkt från en Databricks-terminal. Detta ger åtkomst till avancerade operationer som pre-commit hookar, Git-undermoduler och Large File Storage (LFS). Se Använda Git CLI-kommandon (Beta).

4. 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.

Klona från webbterminalen

Du kan också skapa Git-mappar med CLI-åtkomst direkt från webbterminalen:

1. Öppna webbterminalen. Se Köra gränssnittskommandon i Azure Databricks-webbterminalen.

2. Gå till den överordnade katalogen i /Workspace:

   cd /Workspace/Users/<your-email>/<project>
   

   Kommentar

   Du kan inte skapa Git-mappar med Git CLI-åtkomst i /Repos eller i befintliga Git-mappar.

3. Klona lagringsplatsen:

   git clone <remote-url>
   

   Kommandot git clone använder de Git-inloggningsuppgifter som konfigurerats på din arbetsyta. Se Konfigurera Git-autentiseringsuppgifter och ansluta en fjärransluten lagringsplats till Azure Databricks.

4. Uppdatera webbläsaren för att se den nya mappen i arbetsytans filwebbläsare.

Använda Git CLI-kommandon (Beta)

Viktigt!

Den här funktionen finns i Beta.

Med Git-mappar med Git CLI-åtkomst kan du köra git-standardkommandon direkt från en Databricks-terminal. Du kan:

• Kör valfritt Git-kommando, inklusive git stash, git pull --forceoch git rebase -i.
• Integrera linting och kodgenomsökning med commit-hakar.
• Arbeta med lagringsplatser som överskrider 2 GB minne och 4 GB diskgränser för git-standardmappar.
• Använd Git submoduler och Large File Storage (LFS).
• Mellanlagra flera ändringar lokalt på din maskin innan du skickar dem till den fjärrbaserade biblioteket.

Om du vill använda Git CLI-åtkomst måste din arbetsyta ha serverlös beräkning aktiverad med miljöversion 4 eller senare.

Skapa en Git-mapp med Git CLI-åtkomst

Så här skapar du en Git-mapp med CLI-åtkomst:

• När du använder webbterminalen har alla lagringsplatser som du klonar Git CLI åtkomst automatiskt.
• När du använder användargränssnittet måste du aktivera förhandsversionen av Använda Git CLI när du skapar Git-mappen.

När du har skapat en Git-mapp med CLI-åtkomst kör du valfritt Git-standardkommando från webbterminalen:

cd /Workspace/Users/<your-email>/<project>/my-repo

# Interactive rebase
git rebase -i main

# Stash uncommitted changes
git stash

# Work with submodules
git submodule update --init --recursive

Git CLI-begränsningar

Git-mappar med CLI-åtkomst har följande begränsningar:

• Arbetsytor med aktiverade tillåtna fjärr-URL-listor kan inte använda Git CLI-funktioner.
• Git CLI-kommandon ignorerar administratörsinställningen som blockerar åtagande av notebook-utdata.
• Lagrings-API:et stöds inte för Git-mappar med CLI-åtkomst.
• Du kan inte aktivera Git CLI-åtkomst för befintliga Git-mappar.

Felsöka Git CLI-åtgärder

• Terminalen frågar efter autentiseringsuppgifter för varje åtgärd: Git CLI-funktionen är inte aktiverad på din arbetsyta. Kontakta arbetsytans administratör för att kontrollera att förhandsversionen är aktiverad.
• Det går inte att aktivera CLI-åtkomst: Arbetsytor med fjärranslutna URL-tillåtna listor kan inte använda Git CLI-funktioner. Kontakta arbetsytans administratör för att granska arbetsytans nätverkskonfiguration.
• Git-åtgärder misslyckas med behörighetsfel: Kontrollera att du har CAN MANAGE behörighet för den överordnade mappen och att dina Git-autentiseringsuppgifter för arbetsytan är giltiga. Se Konfigurera Git-autentiseringsuppgifter och ansluta en fjärransluten lagringsplats till Azure Databricks.

Bästa praxis: Samarbeta i Git-mappar

Databricks Git-mappar fungerar som inbäddade Git-klienter på din arbetsyta, så att du kan samarbeta via Git-baserad källkontroll och versionshantering. För effektivt teamsamarbete:

• Varje teammedlem har en egen Git-mapp mappad till den fjärranslutna Git-lagringsplatsen, där de arbetar i sin egen utvecklingsgren.
• Endast en användare utför Git-åtgärder på varje Git-mapp. Flera användare som utför Git-åtgärder i samma mapp kan orsaka problem med grenhantering, till exempel att en användare oavsiktligt byter grenar åt alla.

Så här delar du din Git-mappkonfiguration med en medarbetare:

1. Klicka på Kopiera länk för att skapa Git-mappen i banderollen överst på Databricks-arbetsytan.
2. Skicka URL:en till din medarbetare.
3. När din medarbetare öppnar URL:en ser de dialogrutan Skapa Git-mapp i förväg ifylld med din Git-mappkonfiguration.
4. De klickar på Skapa Git-mapp för att klona lagringsplatsen till sin egen arbetsyta under den aktuella arbetsmappen.

Så här kopierar du en Git-mapp från en annan användare:

1. Öppna den andra användarens Git-mapp på den delade arbetsytan.
2. Klicka på Skapa Git-mapp i banderollen längst upp. Dialogrutan Skapa Git-mapp öppnas med konfigurationen för Git-lagringsplatsen ifylld.
3. Klicka på Skapa Git-mapp för att klona lagringsplatsen till din egen arbetsyta.

Ö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å kebab i det övre högra hörnet om du vill 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:

Icke-committade ändringar på den aktuella grenen överförs och visas som icke-committade ändringar på den nya grenen, om de icke-committade ändringarna inte strider mot koden på den nya grenen. Ignorera ändringarna före eller efter förgreningsväxlar om du inte tänker överföra de icke-bakåtkompatibla ändringarna.

Den lokala versionen av en gren kan finnas kvar i den associerade Git-mappen i upp till 30 dagar efter att fjärrgrenen har tagits bort. Ta bort lagringsplatsen för att helt ta bort en lokal gren i en Git-mapp.

Viktigt!

Om du byter grenar kan du ta bort arbetsytetillgångar när den nya grenen inte innehåller dessa tillgångar. Om du växlar tillbaka till den aktuella grenen återskapas de borttagna tillgångarna med nya ID:n och URL:er. Den här ändringen kan inte ångras.

Om du har delat eller bokmärkt tillgångar från en Git-mapp kontrollerar du att tillgången finns på den nya grenen innan du byter.

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 kebab 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.

• 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 hjälp av git push.

Rebase en gren på en annan gren

Öppna Git Rebase-åtgärden genom att välja den från kebabmeny 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.

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 Branch 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 kebabmenyn.

   

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ör 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 Git-mappar i Databricks 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ärrgren)

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 från menyn Branch 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 bara en del av fjärrdatabasernas 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 glesa utcheckningar för ett repo 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 ett 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 utcheckningsläge för ett repo som skapades med det här 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.

Ta bort en Git-mapp

Så här tar du bort en Git-mapp från din arbetsyta:

1. Högerklicka på Git-mappen och välj Flytta till papperskorgen.
2. Skriv git-mappnamnet för att bekräfta.
3. Klicka på Bekräfta och flytta till papperskorgen.