Importera och migrera lagringsplatser från TFVC till Git

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

Du kan migrera kod från en befintlig TFVC-lagringsplats (Team Foundation Version Control) till en ny Git-lagringsplats inom samma organisation. Migrering till Git är en involverad process för stora TFVC-lagringsplatser och team. Centraliserade versionskontrollsystem, till exempel TFVC, beter sig annorlunda än Git på grundläggande sätt. Växeln innebär mycket mer än att lära sig nya kommandon. Det är en störande förändring som kräver noggrann planering. Du måste tänka på:

• Revidera verktyg och processer
• Ta bort binärfiler och körbara filer
• Träna ditt team

Förutsättningar

Vi rekommenderar starkt att du läser centraliserad versionskontroll till Git och avsnittet Migrera från TFVC till Git innan du påbörjar migreringen.

Importupplevelsen är perfekt för små, enkla TFVC-lagringsplatser. Den är också lämplig för lagringsplatser som redan är rena, enligt beskrivningen i centraliserad versionskontroll till Git och avsnittet Migrera från TFVC till Git . De här avsnitten rekommenderar även andra verktyg för mer avancerade TFVC-lagringsplatskonfigurationer.

Importera lagringsplatsen

1. Välj Lagringsplatser, Filer.

   

2. I listrutan på lagringsplatsen väljer du Importera lagringsplats.

   

3. Välj TFVC i listrutan Källtyp

4. Skriv sökvägen till den lagringsplats/gren/mapp som du vill importera till Git-lagringsplatsen. Till exempel: $/Fabrikam/FabrikamWebsite

5. Om du vill migrera historik från TFVC-lagringsplatsen väljer du Migrera historik och väljer antalet dagar. Du kan migrera upp till 180 dagars historik från den senaste ändringsuppsättningen. En länk till TFVC-lagringsplatsen läggs till i incheckningsmeddelandet för den första ändringsuppsättningen som migreras till Git, vilket gör det enkelt att hitta äldre historik när det behövs.

6. Ge ett namn till den nya Git-lagringsplatsen och välj Importera. Beroende på storleken på importen är Git-lagringsplatsen klar om några minuter.

   

Felsökning

Den här upplevelsen är optimerad för små, enkla TFVC-lagringsplatser eller lagringsplatser som förberetts för en migrering. Det innebär att den har några begränsningar.

1. Den migrerar bara innehållet i roten eller en gren. Om du till exempel har ett TFVC-projekt $/Fabrikam där det finns en gren och en mapp under sig, importerar en sökväg till $/Fabrikam den mappen medan $/Fabrikam/<branch> den bara importerar grenen.
2. Den importerade lagringsplatsen och tillhörande historik (om den importeras) får inte överstiga 1 GB i storlek.
3. Du kan importera upp till 180 dagars historik.

Om någon av de tidigare angivna uppgifterna är en blockerare för din import rekommenderar vi att du provar externa verktyg som Git-TFS för att importera och läsa våra whitepapers – Centraliserad versionskontroll till Git och följande avsnittet Migrera från TFVC till Git .

Migrera från TFVC till Git

Innan du migrerar källkoden från ett centraliserat versionskontrollsystem till Git ska du förstå skillnaderna mellan de två och förbereda migreringen.

• Kravspecifikationer
• Steg för att migrera
  • Kolla in den senaste versionen
  • Ta bort binärfiler och byggverktyg
  • Konvertera versionskontrollspecifik konfiguration
  • Kontrollera ändringarna och utför migreringen
  • Avancerade migreringar
• Uppdatera arbetsflödet

Kravspecifikation

För att underlätta migreringen finns det många krav innan du importerar lagringsplatsen i föregående avsnitt i den här artikeln.

• Migrera endast en enda gren. När du planerar migreringen väljer du en ny förgreningsstrategi för Git. Om du bara migrerar huvudgrenen stöds ett ämnesgrensbaserat arbetsflöde som Gitflow eller GitHub Flow.
• Utför en tipsmigrering, precis som i, importera endast den senaste versionen av källkoden. Om TFVC-historiken är enkel kan du välja att migrera viss historik, upp till 180 dagar, så att teamet bara kan arbeta från Git. Mer information finns i Planera migreringen till Git.
• Undanta binära tillgångar som bilder, vetenskapliga datauppsättningar eller spelmodeller från lagringsplatsen. Dessa tillgångar bör använda Git LFS-tillägget (Large File Storage), som importverktyget inte konfigurerar.
• Behåll den importerade lagringsplatsen under 1 GB i storlek.

Om lagringsplatsen inte uppfyller dessa krav använder du verktygetGit-TFS för att utföra migreringen i stället.

Migrate

Det är enkelt att migrera från TFVC:

1. Kolla in den senaste versionen av grenen från TFVC på din lokala disk.
2. Ta bort binärfiler och byggverktyg från lagringsplatsen och konfigurera ett pakethanteringssystem som NuGet.
3. Konvertera versionskontrollspecifika konfigurationsdirektiv . Du kan till exempel konvertera .tfignore filer till .gitignoreoch konvertera .tpattributes filer till .gitattributes.
4. Kontrollera ändringarna och utför migreringen till Git.

Steg 1–3 är valfria. Om det inte finns några binärfiler på lagringsplatsen och det inte finns något behov av att konfigurera en .gitignore eller en .gitattributeskan du fortsätta direkt till checka in ändringar och utföra migreringssteget .

Kolla in den senaste versionen

Skapa en ny arbetsyta och mappa en arbetsmapp för serverkatalogen som migreras till Git. Den här åtgärden kräver inte en fullständig mappmappning. Mappa endast mappar som innehåller binärfiler som ska tas bort från lagringsplatsen och mappar som innehåller systemspecifika konfigurationsfiler för versionskontroll som .tfignore.

När mappningarna har konfigurerats hämtar du mappen lokalt:

tf get /version:T /recursive

Ta bort binärfiler och byggverktyg

Eftersom Git lagrar historiken för ändrade filer genom att tillhandahålla en kopia av varje fil i historiken till varje utvecklare kan kontrollen av binära filer direkt till lagringsplatsen göra att lagringsplatsen växer snabbt och leder till prestandaproblem.

För byggverktyg och beroenden som bibliotek använder du en paketeringslösning med versionsstöd, till exempel NuGet. Många verktyg och bibliotek med öppen källkod är redan tillgängliga i NuGet-galleriet, men för egna beroenden skapar du nya NuGet-paket.

När beroenden har flyttats till NuGet ska du se till att de inte ingår i Git-lagringsplatsen genom att lägga till dem i .gitignore.

Konvertera versionskontrollspecifik konfiguration

Team Foundation Version Control tillhandahåller en .tfignore fil som säkerställer att vissa filer inte läggs till i TFVC-lagringsplatsen. Du kan använda .tfignore filen för automatiskt genererade filer som build-utdata så att de inte checkas in av misstag.

Om projektet förlitar sig på det här beteendet konverterar du .tfignore filen till en .gitignore fil.

TFVC-klienter mellan plattformar ger också stöd för en .tpattributes fil som styr hur filer placeras på den lokala disken eller checkas in på lagringsplatsen. Om en .tpattributes fil används konverterar du den till en .gitattributes fil.

Kontrollera ändringarna och utför migreringen

Kontrollera eventuella ändringar som tar bort binärfiler, migrerar till pakethantering eller konverterar versionskontrollspecifik konfiguration. När du gör den här slutliga ändringen i TFVC kan du göra importen.

Avancerade migreringar

VerktygetGit-TFS är en dubbelriktad brygga mellan TFVS och Git, och du kan använda det för att utföra en migrering. Git-TFS är lämpligt för en migrering med fullständig historik, mer än de 180 dagar som importverktyget stöder. Eller så kan du använda Git-TFS för att försöka migrering som innehåller flera grenar och sammanslagningsrelationer.

Innan du försöker migrera med Git-TFS bör du vara medveten om följande grundläggande skillnader mellan hur TFVC och Git Store-historiken är:

• Git lagrar historiken som en ögonblicksbild av lagringsplatsen i tid, medan TFVC registrerar de diskreta åtgärder som inträffade på en fil. Ändringstyper i TFVC som byt namn, ta bort borttagning och återställning kan inte uttryckas i Git. I stället för att se att filen A har bytt namn till filen Bspårar den bara att filen A har tagits bort och filen B lades till i samma incheckning.
• Git har ingen direkt analog till en TFVC-etikett. Etiketter kan innehålla valfritt antal filer i valfri specifik version och kan återspegla filer i olika versioner. Även om git-taggarna är konceptuellt likartade pekar de på en ögonblicksbild av hela lagringsplatsen vid en viss tidpunkt. Om projektet förlitar sig på TFVC-etiketter för att veta vad som levererades kanske Git-taggarna inte ger den här informationen.
• Sammanslagningar i TFVC sker på filnivå, inte på hela lagringsplatsen. Endast en delmängd av ändrade filer kan sammanfogas från en gren till en annan. Återstående ändrade filer kan sedan sammanfogas i en efterföljande ändringsuppsättning. I Git påverkar en sammanslagning hela lagringsplatsen, och båda uppsättningarna med enskilda ändringar kan inte ses som en sammanslagning.

På grund av dessa skillnader rekommenderar vi att du gör en tipsmigrering och håller TFVC-lagringsplatsen online, men skrivskyddad, för att visa historik.

Om du vill prova en avancerad migrering med Git-TFS kan du läsa klona en enda gren med historik eller klona alla grenar med sammanslagningshistorik.

Uppdatera arbetsflödet

Att flytta från ett centraliserat versionskontrollsystem till Git är mer än att bara migrera kod. Teamet behöver utbildning för att förstå hur Git skiljer sig från det befintliga versionskontrollsystemet och hur dessa skillnader påverkar det dagliga arbetet.

Läs mer om hur du migrerar från centraliserad versionskontroll till Git.