Källkontroll i Azure Data Factory

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

Som standard arbetar Azure Data Factory-användargränssnittet (UX) direkt mot Azure Data Factory-tjä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.
• Azure Resource Manager (ARM)-mallen som krävs för att distribuera Data Factory ingår inte.

För att ge en bättre skapandeupplevelse kan du konfigurera Azure Data Factory med en Git-lagringsplats via antingen Azure-lagringsplatser eller GitHub. Git är ett versionskontrollsystem som möjliggör enklare spårning och samarbete. Den här artikeln beskriver hur man konfigurerar och arbetar i ett Git-repository samt lyfter fram bästa praxis och en felsökningsguide.

Du kan också referera till Kontinuös 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 följer en lista över några av de fördelar som Git-integration ger för författarupplevelsen:

• 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 klara eller om du helt enkelt inte vill förlora ändringar om din dator kraschar, möjliggör Git-integration inkrementella ändringar av data factory-resurser oavsett vilket tillstånd de befinner sig i. Att konfigurera ett Git-repository låter dig spara ändringar, vilket gör att du bara kan publicera efter att du 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-integration 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 mallen Resource Manager. 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-integration laddar tio gånger snabbare än en som skriver 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-lagringsplatser 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 Azure Data Factory väljer du Set up code repository längst upp.

Konfigurationsmetod 2: Redigeringsarbetsyta

I den Azure Data Factory UX-redigeringsarbetsytan väljer du listrutan Data Factory och väljer sedan Set up code repository.

Konfigurationsmetod 3: Hanteringsnav

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 portalen kan du konfigurera Git-lagringsplatsinformation i fliken Git-konfiguration.

Författare med Azure-lagringsplatser Git-integration

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

Azure-lagringsplatser inställningar

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 Azure-lagringsplatser Git-lagringsplats kan du välja att 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änd en annan Microsoft Entra klientorganisation

Azure-lagringsplatser Git-repot kan vara 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änd din personliga Microsoft-konto

Om du vill använda en personlig Microsoft-konto för Git-integrering kan du länka din personliga Azure-lagringsplats till organisationens služba Active Directory.

1. Lägg till ditt personliga Microsoft-konto i organisationens služba Active Directory som en gäst. Mer information finns i Lägg till Microsoft Entra B2B-samarbetsanvändare i Azure-portalen.

2. Logga in på Azure-portalen med dina personliga Microsoft-konto. Växla sedan till organisationens služba Active Directory.

3. Gå till avsnittet Azure DevOps, där du nu ser din personliga lagringsplats. Välj lagringsplatsen och anslut med služba 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-lagringsplatser till organisationens služba Active Directory finns i Anslut din Azure DevOps organisation till Microsoft Entra ID.

Skapa med GitHub integration

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 ett GitHub konto eller lagringsplats följer du de här instruktionerna för att skapa dina resurser.

Den 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 publika och privata GitHub-repositorier med Data Factory så länge du har läs- och skrivbehörighet till repositoryt 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-serverintegration fungerar endast med officiellt stödda versioner av GitHub Enterprise-server.

För lagringsplatser som ägs av GitHub organisationskonto måste administratören auktorisera ADF-appen. För lagringsplatser som ägs av GitHub användarkonto 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 GitHub lagringsplatsinställningar:

Redigera lagringsplatsens inställningar

Om du behöver justera inställningarna för din konfigurerade GitHub lagringsplats kan du välja att 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

Om du ansluter 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 Cloud 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 dessa steg för att ansluta till en GitHub organisation.

1. I fönstret Git-konfiguration anger du organisationsnamnet i fältet GitHub Account. En prompt för att logga in på GitHub dyker upp.
2. Logga in med dina användarautentiseringsuppgifter.
3. Du ombeds att godkänna Azure Data Factory som en applikation 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 Settings.

   

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 i ett GitHub-arkiv till Azure Storage.

• GitHub Enterprise med en version som är äldre än 2.14.0 fungerar inte i Microsoft Edge webbläsare.

• 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 Azure DevOps Server URL och Azure DevOps Project Collection

Ange en token med läs-/skrivbehörighet för kod.

Skärmbild som visar konfiguration av ADO-åtkomsttoken.

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-lagringsplatser 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 välja + Ny gren i grenrullgardinsmenyn.

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 slå ihop ändringarna från din funktionsbranch till din samarbetsbranch, välj i branch-rullgardinsmenyn och välj Create pull request. Den här åtgärden tar dig till Azure-lagringsplatser Git där du kan skapa pull-begäranden, göra kodgranskningar och sammanfoga ändringar i din samarbetsgren. (main är standardvärdet). Du får bara publicera till Data Factory-tjänsten från din samarbetsgren.

Konfigurera publiceringsinställningar

Som standard genererar datafabriken Resource Manager mallar 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 publishBranch och 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

Efter att du har sammanslagit ändringar i samarbetsgrenen (main som är standard), välj 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 väljer du 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 detta måste de ha rollen Data Factory-deltagare i den resursgrupp 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 anslutningssträngar, 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.

Att använda Key Vault eller hanterad identitetsautentisering gör också kontinuerlig integration och distribution enklare eftersom du inte behöver lämna dessa hemligheter under Resource Manager-malldistributionen.

Felsökning av Git-integration

Utdaterad 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 kopplad till Azure Key Vault (AKV) (icke-AKV-länkade tjänster publiceras omedelbart oavsett om de är i Git eller inte) och slog aldrig ihop funktionsgrenen med 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 datamängd som refererar till den länkade tjänsten och försöker publicera, tillåter användargränssnittet det eftersom det finns i Git-miljön. Den kommer att avvisas vid publiceringstillfället eftersom den inte finns i data factory-tjä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 Overwrite live-lägesfunktionalitet

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 pullförfrågan 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 välj 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 Continuous integration and delivery (CI/CD) i Azure Data Factory.