Källkontroll i Azure Data Factory

GÄLLER FÖR: Azure Data Factory Azure Synapse Analytics

Som standard är UX-författarna (Azure Data Factory User Interface Experience) direkt mot datafabrikstjänsten. Den här upplevelsen har följande begränsningar:

• Data Factory-tjänsten innehåller inte någon lagringsplats för lagring av JSON-entiteter för dina ändringar. Det enda sättet att spara ändringar är via knappen Publicera alla och alla ändringar publiceras direkt till datafabrikstjänsten.
• Data Factory-tjänsten är inte optimerad för samarbete och versionskontroll.
• Den Azure Resource Manager-mall som krävs för att distribuera själva Data Factory ingår inte.

För att ge en bättre redigeringsupplevelse kan du med Azure Data Factory konfigurera en Git-lagringsplats med antingen Azure Repos eller GitHub. Git är ett versionskontrollsystem som möjliggör enklare spårning och samarbete. Den här artikeln beskriver hur du konfigurerar och arbetar på en git-lagringsplats tillsammans med att markera metodtips och en felsökningsguide.

Du kan också referera till Kontinuerlig integrering och leverans (CI/CD) i Azure Data Factory för att lära dig mer om det större CI/CD-mönstret, där källkontroll är en viktig aspekt.

Mer information om hur Azure Data Factory integreras med Git finns i självstudievideon på 15 minuter nedan:

Fördelar med Git-integrering

Nedan visas en lista över några av fördelarna med git-integrering för redigeringsupplevelsen:

• Källkontroll: När dina datafabriksarbetsbelastningar blir avgörande vill du integrera din fabrik med Git för att tillämpa flera fördelar med källkontroll som följande:
  • Möjlighet att spåra/granska ändringar.
  • Möjlighet att återställa ändringar som introducerade buggar.
• Partiella sparanden: När du redigerar mot datafabrikstjänsten kan du inte spara ändringar som ett utkast, och alla publiceringar måste godkännas av datafabriken. Oavsett om dina pipelines inte är färdiga eller om du helt enkelt inte vill förlora ändringar om datorn kraschar, tillåter git-integrering inkrementella ändringar av datafabriksresurser oavsett vilket tillstånd de befinner sig i. När du konfigurerar en git-lagringsplats kan du spara ändringar så att du bara kan publicera efter att du har testat dina ändringar till din belåtenhet.
• Samarbete och kontroll: Om du har flera teammedlemmar som bidrar till samma fabrik kanske du vill låta dina teammedlemmar samarbeta med varandra via en kodgranskningsprocess. Du kan också konfigurera din fabrik så att inte alla deltagare har samma behörigheter. Vissa teammedlemmar kan bara tillåtas göra ändringar via Git och endast vissa personer i teamet får publicera ändringarna i fabriken.
• Bättre CI/CD: Om du distribuerar till flera miljöer med en kontinuerlig leveransprocess gör git-integrering vissa åtgärder enklare. Några av dessa åtgärder är:
  • Konfigurera versionspipelinen så att den utlöses automatiskt så snart det görs ändringar i din dev-fabrik.
  • Anpassa de egenskaper i din fabrik som är tillgängliga som parametrar i Resource Manager-mallen. Det kan vara användbart att bara behålla den obligatoriska uppsättningen egenskaper som parametrar och ha allt annat hårdkodat.
• Bättre prestanda: En genomsnittlig fabrik med git-integrering läses in 10 gånger snabbare än en redigering mot datafabrikstjänsten. Den här prestandaförbättringen beror på att resurser laddas ned via Git.

Ansluta till en Git-lagringsplats

Det finns fyra olika sätt att ansluta en Git-lagringsplats till din datafabrik för både Azure Repos och GitHub. När du har anslutit till en Git-lagringsplats kan du visa och hantera din konfiguration i hanteringshubben under Git-konfiguration i avsnittet Källkontroll .

Konfigurationsmetod 1: Startsida

På startsidan för Azure Data Factory väljer du Konfigurera kodlagringsplats högst upp.

Konfigurationsmetod 2: Redigeringsarbetsyta

I azure Data Factory UX-redigeringsarbetsytan väljer du den nedrullningsbara menyn Data Factory och väljer sedan Konfigurera kodlagringsplats.

Konfigurationsmetod 3: Hanteringshubben

Gå till hanteringshubben i Azure Data Factory Studio. Välj Git-konfiguration i avsnittet Källkontroll . Om du inte har någon ansluten lagringsplats väljer du Konfigurera.

Konfigurationsmetod 4: När fabriken skapas

När du skapar en ny datafabrik i Azure Portal kan du konfigurera Git-lagringsplatsinformation på fliken Git-konfiguration.

Skapa med Git-integrering för Azure-lagringsplatser

Visuell redigering med Azure Repos Git-integrering stöder källkontroll och samarbete för arbete med dina datafabrikspipelines. Du kan associera en datafabrik med en Azure Repos Git-organisationslagringsplats för källkontroll, samarbete, versionshantering och så vidare. En enda Azure Repos Git-organisation kan ha flera lagringsplatser, men en Git-lagringsplats för Azure Repos kan bara associeras med en datafabrik. Om du inte har någon Azure Repos-organisation eller lagringsplats följer du de här anvisningarna för att skapa dina resurser.

Inställningar för Azure Repos

Konfigurationsfönstret beskriver steg för steg hur du konfigurerar var och en av följande inställningar för kodlagringsplatsen:

Redigera lagringsplatsens inställningar

Om du behöver justera inställningarna för din konfigurerade Git-lagringsplats för Azure Repos kan du välja Redigera.

Du kan uppdatera publiceringsgrenen och bestämma om du vill inaktivera publiceringsknappen från ADF-studion eller inte. Om du väljer att inaktivera publiceringsknappen från studion är publiceringsknappen nedtonad i studion. Detta hjälper dig att undvika att skriva över den senaste automatiserade publiceringsdistributionen.

Använda en annan Microsoft Entra-klientorganisation

Git-lagringsplatsen för Azure Repos kan finnas i en annan Microsoft Entra-klientorganisation. Om du vill ange en annan Microsoft Entra-klient måste du ha administratörsbehörighet för den Azure-prenumeration som du använder. Mer information finns i Ändra prenumerationsadministratör.

Använda ditt personliga Microsoft-konto

Om du vill använda ett personligt Microsoft-konto för Git-integrering kan du länka din personliga Azure-lagringsplats till organisationens Active Directory.

1. Lägg till ditt personliga Microsoft-konto i organisationens Active Directory som gäst. Mer information finns i Lägga till Microsoft Entra B2B-samarbetsanvändare i Azure Portal.

2. Logga in på Azure Portal med ditt personliga Microsoft-konto. Växla sedan till organisationens Active Directory.

3. Gå till avsnittet Azure DevOps, där du nu ser din personliga lagringsplats. Välj lagringsplatsen och anslut med Active Directory.

Efter de här konfigurationsstegen är din personliga lagringsplats tillgänglig när du konfigurerar Git-integrering i Data Factory-användargränssnittet.

Mer information om hur du ansluter Azure Repos till din organisations Active Directory finns i Ansluta din Azure DevOps-organisation till Microsoft Entra-ID.

Skapa med GitHub-integrering

Visuell redigering med GitHub-integrering stöder källkontroll och samarbete för arbete med dina datafabrikspipelines. Du kan associera en datafabrik med en GitHub-kontolagringsplats för källkontroll, samarbete och versionshantering. Ett enda GitHub-konto kan vara värd för flera lagringsplatser och varje lagringsplats kan associeras med flera datafabriker. Genom att konfigurera varje datafabrik för att använda en annan gren på samma lagringsplats kan du underhålla separata miljöer (till exempel utveckling, mellanlagring och produktion) samtidigt som du hanterar deras konfigurationer oberoende av varandra. Om du inte har något GitHub-konto eller en lagringsplats följer du de här anvisningarna för att skapa dina resurser.

GitHub-integreringen med Data Factory stöder både offentliga GitHub (dvs. https://github.com), GitHub Enterprise Cloud och GitHub Enterprise Server. Du kan använda både offentliga och privata GitHub-lagringsplatser med Data Factory så länge du har läs- och skrivbehörighet till lagringsplatsen i GitHub. Om du vill ansluta till en offentlig lagringsplats väljer du alternativet Använd länklagringsplats eftersom de inte visas i listrutan i Lagringsplatsens namn. ADF:s GitHub Enterprise-serverintegrering fungerar endast med officiellt stödda versioner av GitHub Enterprise Server.

För lagringsplatser som ägs av GitHub-organisationskontot måste administratören auktorisera ADF-appen. För lagringsplatser som ägs av GitHub-användarkontot kan en användare med minst samarbetspartnersbehörighet auktorisera ADF-appen. Den här behörigheten ger inte ADF-appen direkt åtkomst till alla lagringsplatser som ägs av kontot/organisationen. Den tillåter bara att ADF-appen agerar åt användaren för att få åtkomst till lagringsplatser baserat på användarens åtkomstbehörigheter.

GitHub-inställningar

Konfigurationsfönstret visar följande Inställningar för GitHub-lagringsplats:

Redigera lagringsplatsens inställningar

Om du behöver justera inställningarna för din konfigurerade GitHub-lagringsplats kan du välja Redigera.

Du kan uppdatera publiceringsgrenen och bestämma om du vill inaktivera publiceringsknappen från ADF-studion eller inte. Om du väljer att inaktivera publiceringsknappen från studion är publiceringsknappen nedtonad i studion. Detta hjälper till att undvika att skriva över den senaste automatiserade publiceringsdistributionen.

GitHub-organisationer

För att ansluta till en GitHub-organisation måste organisationen bevilja behörighet till Azure Data Factory. En användare med administratörsbehörighet i organisationen måste utföra stegen nedan för att tillåta att datafabriken ansluter.

Ansluta till offentliga GitHub- eller GitHub Enterprise-moln för första gången i Azure Data Factory

Om du ansluter till offentliga GitHub eller GitHub Enterprise Cloud från Azure Data Factory för första gången följer du de här stegen för att ansluta till en GitHub-organisation.

1. I git-konfigurationsfönstret anger du organisationsnamnet i fältet GitHub-konto . En uppmaning om att logga in på GitHub visas.
2. Logga in med dina användarautentiseringsuppgifter.
3. Du uppmanas att auktorisera Azure Data Factory som ett program som heter AzureDataFactory. På den här skärmen visas ett alternativ för att bevilja behörighet för ADF att få åtkomst till organisationen. Om du inte ser alternativet att bevilja behörighet ber du en administratör att manuellt bevilja behörigheten via GitHub.

När du följer de här stegen kan din fabrik ansluta till både offentliga och privata lagringsplatser i din organisation. Om du inte kan ansluta kan du prova att rensa webbläsarens cacheminne och försöka igen.

Redan ansluten till offentliga GitHub eller GitHub Enterprise Cloud med ett personligt konto

Om du redan har anslutit till offentliga GitHub eller GitHub Enterprise Cloud och endast beviljat behörighet att komma åt ett personligt konto följer du stegen nedan för att bevilja behörigheter till en organisation.

1. Gå till GitHub och öppna Inställningar.

   

2. Välj ansökning. På fliken Auktoriserade OAuth-appar bör du se AzureDataFactory.

   

3. Välj programmet och ge programmet åtkomst till din organisation.

   

När du följer de här stegen kan din fabrik ansluta till både offentliga och privata lagringsplatser i din organisation.

Ansluta till GitHub Enterprise Server

Om du ansluter till GitHub Enterprise Server måste du använda en personlig åtkomsttoken för autentisering. Lär dig hur du skapar en personlig åtkomsttoken i Skapa en personlig åtkomsttoken.

Kända GitHub-begränsningar

• Du kan lagra skript- och datafiler på en GitHub-lagringsplats. Du måste dock ladda upp filerna manuellt till Azure Storage. En Data Factory-pipeline laddar inte automatiskt upp skript- eller datafiler som lagras på en GitHub-lagringsplats till Azure Storage.

• GitHub Enterprise med en äldre version än 2.14.0 fungerar inte i Microsoft Edge-webbläsaren.

• GitHub-integrering med datafabrikens verktyg för visuell redigering fungerar bara i den allmänt tillgängliga versionen av Data Factory.

Ansluta till Azure DevOps Server 2022

Om du ansluter till Azure DevOps Server 2022 måste du använda en personlig åtkomsttoken för autentisering. Lär dig hur du skapar en personlig åtkomsttoken här.

Anslut till lokala Azure DevOps genom att tillhandahålla och Azure DevOps Server URLAzure DevOps Project Collection

Ange token med åtkomstomfång som läs/skriv för kod.

Versionskontroll

Med versionskontrollsystem (kallas även källkontroll) kan utvecklare samarbeta om kod och spåra ändringar som görs i kodbasen. Källkontroll är ett viktigt verktyg för projekt med flera utvecklare.

Skapa funktionsgrenar

Varje Azure Repos Git-lagringsplats som är associerad med en datafabrik har en samarbetsgren. (main är standardgrenen för samarbete). Användare kan också skapa funktionsgrenar genom att klicka på + Ny gren i listrutan gren.

När det nya grenfönstret visas anger du namnet på funktionsgrenen och väljer en gren som du vill basera arbetet på.

När du är redo att sammanfoga ändringarna från funktionsgrenen till din samarbetsgren klickar du på listrutan för grenen och väljer Skapa pull-begäran. Den här åtgärden tar dig till Azure Repos Git där du kan skapa pull-begäranden, göra kodgranskningar och sammanfoga ändringar i din samarbetsgren. (main är standardvärdet). Du kan bara publicera till Data Factory-tjänsten från din samarbetsgren.

Konfigurera publiceringsinställningar

Som standard genererar datafabriken Resource Manager-mallarna för den publicerade fabriken och sparar dem i en gren med namnet adf_publish. Om du vill konfigurera en anpassad publiceringsgren lägger du till en publish_config.json fil i rotmappen i samarbetsgrenen. När du publicerar läser ADF den här filen, söker efter fältet publishBranchoch sparar alla Resource Manager-mallar på den angivna platsen. Om grenen inte finns skapar datafabriken den automatiskt. Ett exempel på hur den här filen ser ut finns nedan:

{
    "publishBranch": "factory/adf_publish"
}

Azure Data Factory kan bara ha en publiceringsgren i taget. När du anger en ny publiceringsgren tar Data Factory inte bort den tidigare publiceringsgrenen. Om du vill ta bort föregående publiceringsgren tar du bort den manuellt.

Publicera kodändringar

När du har sammanfogat ändringar i samarbetsgrenen (main är standard) klickar du på Publicera för att manuellt publicera dina kodändringar i huvudgrenen till Data Factory-tjänsten.

En sidoruta öppnas där du bekräftar att publiceringsgrenen och väntande ändringar är korrekta. När du har verifierat ändringarna klickar du på OK för att bekräfta publiceringen.

Metodtips för Git-integrering

Behörigheter

Vanligtvis vill du inte att alla teammedlemmar ska ha behörighet att uppdatera Data Factory. Följande behörighetsinställningar rekommenderas:

• Alla teammedlemmar bör ha läsbehörighet till Data Factory.
• Endast en utvald uppsättning personer ska tillåtas att publicera till Data Factory. För att göra det måste de ha rollen Data Factory-deltagare i resursgruppen som innehåller Data Factory. Mer information om behörigheter finns i Roller och behörigheter för Azure Data Factory.

Vi rekommenderar att du inte tillåter direkta incheckningar till samarbetsgrenen. Den här begränsningen kan hjälpa till att förhindra buggar eftersom varje incheckning går igenom en granskningsprocess för pull-begäran som beskrivs i Skapa funktionsgrenar.

Använda lösenord från Azure Key Vault

Vi rekommenderar att du använder Azure Key Vault för att lagra alla anslutningssträng eller lösenord eller hanterad identitetsautentisering för Länkade Data Factory-tjänster. Av säkerhetsskäl lagrar datafabriken inte hemligheter i Git. Ändringar av länkade tjänster som innehåller hemligheter, till exempel lösenord, publiceras omedelbart till Azure Data Factory-tjänsten.

Genom att använda Key Vault- eller MSI-autentisering blir det också enklare att integrera och distribuera kontinuerligt eftersom du inte behöver ange dessa hemligheter under distributionen av Resource Manager-mallen.

Felsöka Git-integrering

Inaktuell publiceringsgren

Nedan visas några exempel på situationer som kan orsaka en inaktuell publiceringsgren:

• En användare har flera grenar. I en funktionsgren tog de bort en länkad tjänst som inte är AKV-associerad (icke-AKV-länkade tjänster publiceras omedelbart oavsett om de finns i Git eller inte) och sammanfogade aldrig funktionsgrenen i samarbetsgrenen.
• En användare ändrade datafabriken med hjälp av SDK eller PowerShell
• En användare flyttade alla resurser till en ny gren och försökte publicera för första gången. Länkade tjänster bör skapas manuellt när du importerar resurser.
• En användare laddar upp en icke-AKV-länkad tjänst eller en Integration Runtime JSON manuellt. De refererar till resursen från en annan resurs, till exempel en datauppsättning, länkad tjänst eller pipeline. En icke-AKV-länkad tjänst som skapas via användargränssnittet publiceras omedelbart eftersom autentiseringsuppgifterna måste krypteras. Om du laddar upp en datauppsättning som refererar till den länkade tjänsten och försöker publicera tillåter användargränssnittet den eftersom den finns i git-miljön. Den avvisas vid publiceringstillfället eftersom den inte finns i datafabrikstjänsten.

Om publiceringsgrenen inte är synkroniserad med huvudgrenen och innehåller inaktuella resurser trots en publicering nyligen kan du använda någon av lösningarna nedan:

Alternativ 1: Använd funktionen Skriv över liveläge

Den publicerar eller skriver över koden från din samarbetsgren till liveläge. Den betraktar koden på lagringsplatsen som källan till sanningen.

Kodflöde: Samarbetsgren –> liveläge

Alternativ 2: Koppla från och återansluta Git-lagringsplats

Den importerar koden från liveläge till samarbetsgrenen. Den betraktar koden i liveläge som sanningskälla.

Kodflöde: Live-läge –> samarbetsgren

1. Ta bort din aktuella Git-lagringsplats
2. Konfigurera om Git med samma inställningar, men kontrollera att Importera befintliga Data Factory-resurser till lagringsplatsen är markerat och välj Samarbetsgren (samma gren)
3. Skapa en pull-begäran för att sammanslå ändringarna till samarbetsgrenen.

Välj någon av metoderna efter behov.

Alla resurser visas som nya vid publicering

När du publicerar kan alla resurser visas som nya även om de har publicerats tidigare. Detta kan inträffa om egenskapen lastCommitId återställs på fabrikens repoConfiguration-egenskap , antingen genom att distribuera om en ARM-fabriksmall eller uppdatera egenskapen factory repoConfiguration via PowerShell eller REST-API:et. Om du fortsätter att publicera resurserna kan du lösa problemet, men för att förhindra att det inträffar igen bör du undvika att uppdatera egenskapen factory repoConfiguration .

Växla till en annan Git-lagringsplats

Om du vill växla till en annan Git-lagringsplats går du till Git-konfigurationssidan i hanteringshubben under Källkontroll. Välj Koppla från.

Ange namnet på datafabriken och klicka på bekräfta för att ta bort Git-lagringsplatsen som är associerad med datafabriken.

När du har ta bort associationen med den aktuella lagringsplatsen kan du konfigurera Dina Git-inställningar för att använda en annan lagringsplats och sedan importera befintliga Data Factory-resurser till den nya lagringsplatsen.

Relaterat innehåll

• Mer information om övervakning och hantering av pipelines finns i Övervaka och hantera pipelines programmatiskt.
• Information om hur du implementerar kontinuerlig integrering och distribution finns i Kontinuerlig integrering och leverans (CI/CD) i Azure Data Factory.