Källkontroll i Azure Data Factory

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

Som standard Azure Data Factory UX-skribenterna direkt mot datafabrikstjänsten. Den här upplevelsen har följande begränsningar:

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

För att ge en bättre redigeringsupplevelse Azure Data Factory du 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 bästa praxis och en felsökningsguide.

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 dra nytta av 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 sparar: När du skapar mot datafabrikstjänsten kan du inte spara ändringar som ett utkast och alla publiceringar måste klara datafabriksverifieringen. Oavsett om dina pipelines inte är klara eller om du inte vill förlora ändringar om datorn kraschar, tillåter Git-integrering inkrementella ändringar av datafabriksresurser oavsett i vilket tillstånd de befinner sig. Genom att konfigurera en git-lagringsplats kan du spara ändringar så att du bara kan publicera när du har testat ändringarna på ett nöjd sätt.
• 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 att göra ändringar via Git och endast vissa personer i teamet får publicera ändringarna till fabriken.
• Bättre CI/CD: Om du distribuerar till flera miljöer med en kontinuerlig leveransprocessgör git-integreringen vissa åtgärder enklare. Några av dessa åtgärder är:
  • Konfigurera din lanseringspipeline så att den utlöses automatiskt så snart det finns ändringar som gjorts i utvecklingsfabriken.
  • Anpassa de egenskaper i din fabrik som är tillgängliga som parametrar i Resource Manager mallen. Det kan vara användbart att endast ha den nödvändiga uppsättningen egenskaper som parametrar och att allt annat är hårdkodat.
• Bättre prestanda: En genomsnittlig fabrik med Git-integrering läser 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.

Anslut 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 anslutt till en Git-lagringsplats kan du visa och hantera konfigurationen i hanteringshubben under Git-konfiguration i avsnittet Källkontroll

Konfigurationsmetod 1: Startsida

På Azure Data Factory väljer du Konfigurera koddatabas längst upp.

Konfigurationsmetod 2: Redigeringsarbetsyta

På den Azure Data Factory UX-redigeringsarbetsytan väljer du Data Factory nedrullningsningsmenyn och väljer sedan Konfigurera koddatabas.

Konfigurationsmetod 3: Hanteringshubb

Gå till hanteringshubben i ADF UX. Välj Git-konfiguration i avsnittet Källkontroll. Om du inte har någon ansluten lagringsplats klickar du på 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 Git-integrering för Azure Repos 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 Git-organisation för Azure-lagringsplatsen kan ha flera lagringslager, men en Git-lagringsplats för Azure-lagringsplatsen kan bara associeras med en datafabrik. Om du inte har en organisation eller lagringsplats för Azure Repos följer du dessa anvisningar för att skapa dina resurser.

Inställningar för Azure Repos

Konfigurationsfönstret visar följande inställningar för Azure Repos-kodlagringsplatsen:

Använda en annan Azure Active Directory klientorganisation

Git-lagringsplatsen för Azure-lagringsplatsen kan finnas i en Azure Active Directory klientorganisation. För att kunna ange en annan Azure AD-klientorganisation måste du ha administratörsbehörighet för den prenumeration som du använder. Mer information finns i Ändra prenumerationsadministratör

Använda din personliga Microsoft-konto

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

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

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

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

Efter de här konfigurationsstegen är din personliga lagringsplatsen tillgänglig när du ställer in Git-integrering i Data Factory användargränssnitt.

Mer information om hur du ansluter Azure-lagringsplatsen till din organisations Active Directory finns i Anslut Azure DevOps-organisationen för att Azure Active Directory.

Skapa med GitHub-integrering

Visuell redigering med GitHub har stöd för källkontroll och samarbete för arbete med dina datafabrikspipelines. Du kan associera en datafabrik med en GitHub-kontodatabas för källkontroll, samarbete och versionshantering. Ett enskilt GitHub-konto kan ha flera lagringslager, men en GitHub-lagringsplats kan bara associeras med en datafabrik. Om du inte har ett konto GitHub lagringsplats följer du dessa anvisningar för att skapa dina resurser.

Den GitHub integreringen med Data Factory stöder både offentliga GitHub (det vill säga https://github.com ) och GitHub Enterprise. Du kan använda både offentliga och privata GitHub databaser med Data Factory så länge du har läs- och skrivbehörighet till lagringsplatsen i GitHub.

För att konfigurera GitHub lagringsplatsen måste du ha administratörsbehörighet för den Azure-prenumeration som du använder.

GitHub inställningar

Konfigurationsfönstret visar följande inställningar GitHub lagringsplatsen:

GitHub organisationer

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

Ansluta till GitHub första gången i Azure Data Factory

Om du ansluter till en GitHub från Azure Data Factory 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 Konto. En uppmaning om att logga GitHub visas.
2. Logga in med dina användarautentiseringsuppgifter.
3. Du uppmanas att auktorisera Azure Data Factory ett program som heter AzureDataFactory. På den här skärmen visas ett alternativ för att bevilja behörighet för ADF för åtkomst till organisationen. Om du inte ser alternativet för att bevilja behörighet kan du be en administratör att bevilja behörigheten manuellt via GitHub.

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

Redan ansluten till GitHub med ett personligt konto

Om du redan har anslutit till GitHub och endast beviljats 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 Program. 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 kommer din fabrik att kunna ansluta till både offentliga och privata lagringsplatsen i din organisation.

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 version som är äldre än 2.14.0 fungerar inte i Microsoft Edge webbläsaren.

• GitHub integrering med Data Factory visuella redigeringsverktyg fungerar bara i den allmänt tillgängliga versionen av Data Factory.

Versionskontroll

Med versionskontrollsystem (även kallat källkontroll) kan utvecklare samarbeta kring 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 arbetet ska baseras på.

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

Konfigurera publiceringsinställningar

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

{
    "publishBranch": "factory/adf_publish"
}

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

Publicera kodändringar

När du har sammanfogat ändringarna i samarbetsgrenen ( är standardinställningen) klickar du på Publicera för att manuellt publicera kodändringarna i main-grenen main till Data Factory tjänsten.

Ett sidofönster ö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 select-uppsättning personer ska kunna publicera till Data Factory. För att göra det 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 eventuella anslutningssträngar eller lösenord eller hanterad identitetsautentisering för Data Factory Länkade tjänster. Av säkerhetsskäl lagrar datafabriken inte hemligheter i Git. Ändringar i länkade tjänster som innehåller hemligheter, till exempel lösenord, publiceras omedelbart till Azure Data Factory tjänsten.

Med Key Vault- eller MSI-autentisering blir det också enklare att kontinuerlig integrering och distribution eftersom du inte behöver ange dessa hemligheter under Resource Manager malldistribution.

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, en länkad tjänst eller en pipeline. En icke-AKV-länkad tjänst som skapats via UX 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 UX den eftersom den finns i git-miljön. Den avvisas vid publiceringen eftersom den inte finns i datafabrikstjänsten.

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

Alternativ 1: Använd funktionen för att skriva över liveläge

Den publicerar eller skriver över koden från din samarbetsgren till live-läget. Den kommer att betrakta koden på din lagringsplats som sanningskällan.

Kodflöde: Samarbetsgren -> Live-läge

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

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

Kodflöde: Liveläge - > Samarbetsgren

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

Välj en lämplig metod efter behov.

Alla resurser visas som nya vid publicering

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

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å din datafabrik och klicka på Bekräfta för att ta bort git-lagringsplatsen som är associerad med din datafabrik.

När du har tagit bort associationen med den aktuella lagringsplatsen kan du konfigurera dina Git-inställningar så att de använder en annan lagringsplatsen och sedan importera befintliga Data Factory till den nya lagringsplatsen.

Nästa steg

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