Hantera dina projekt med versionkontroll

Du kan använda versionskontroll för att hantera utvecklingen av ett dataprojekt och för att hålla reda på ändringar.

När du arbetar med versionskontroll kan du checka in versioner av projekten under designarbetet. Detta gör att du kan se ändringar mellan två versioner av projektet. Du kan också utveckla dina dataprojekt med hjälp av en förgreningsstrategi. På så sätt kan du arbeta med en isolerad version av projektet i varje arbetsområde eller gren. Arbetsområdet kan delas av flera användare. Du kan sedan slå samman dina ändringar från arbetsområdet till en huvudgren för distribution till produktionen.

GitHub används som leverantör för versionskontroll.

Komma igång

• Skapa en användare i GitHub som klientorganisationen kan använda för att komma åt GitHub. Detta kan redan ha skapats åt dig av en administratör.

  Användaren måste ha följande behörigheter:

  • repo

  • read:org

  • read:user

  • read:project

• Du behöver skrivrättigheter till de databaser som du tänker ändra.

• Du måste skapa ett personligt åtkomsttoken till GitHub (klassiskt). Detaljerade personliga åtkomsttokens stöds inte.

  För mer information, se GitHub-dokumentation: Hantera dina personliga åtkomsttokens.

• Organisation är obligatorisk i GitHub-konfigurationen.

• Du behöver rollen Kan redigera i utrymmet där projektet finns för att kunna utföra åtgärder för versionskontroll.

• Innan du kan börja använda versionskontroll måste du ställa in en konfiguration för att ansluta till GitHub med den GitHub-användare som du skapade.

  Upprätta konfiguration för GitHub

• När du har skapat en koppling till GitHub kan du ansluta ett projekt till en databas.

  Koppling av ett projekt till en databas

Upprätta konfiguration för GitHub

Alla användare som vill arbeta med versionskontroll måste upprätta en konfiguration för att ansluta till GitHub med hjälp av ett GitHub-användarkonto.

Du kan konfigurera GitHub i Projekt. Se till att du har förberett dig enligt Komma igång.

1. Klicka på och sedan på GitHub-konfiguration.

2. Ställ in autentisering med hjälp av din organisation och GitHubs personliga åtkomsttoken som beskrivs i Komma igång.

3. Klicka på OK.

Du kan nu koppla dina projekt till en databas.

Koppling av ett projekt till en databas

Du måste koppla ett projekt till en databas innan du kan börja använda versionskontroll. Se till att du har upprättat en koppling till GitHub.

1. I Projekt klickar du på ... på ett projekt och väljer Koppla till versionskontroll.

2. Välj vilken databas som projektet ska kopplas till.

3. Lägg till en sökväg till baskatalog

   Om du vill koppla till ett befintligt projekt i GitHub måste du använda samma sökväg.

4. Du kan välja att checka in projektet och pusha projektet till fjärrdatabasen efter koppling. Ange ett incheckningsmeddelande.

   Om du inte väljer att checka in och pusha kommer en huvudgren att skapas i arbetsområdet men inte i fjärrdatabasen.

5. Klicka på Anslut.

Projektet är nu kopplat till den valda databasen. Detta anges längst ned på projektkortet med , namnet på databasen och den aktuella grenen.

När du öppnar projektet kommer titelraden nu att innehålla en GitHub-meny med alternativ för versionskontroll. Projektnamnet kommer också att kompletteras med namnet på den aktuella grenen.

Utveckla ett projekt med versionskontroll

Du kan använda versionskontroll på olika sätt:

• Arbetar direkt på huvudgrenen. Detta är främst lämpligt för en enskild utvecklare i ett projekt som vill hålla reda på ändringar, men kan också användas av en grupp utvecklare som arbetar synkroniserat.

• Arbeta med en förgreningsstrategi, där flera utvecklare kan bidra. Du kan också skapa grenar för att isolera nya funktioner eller ändringar från varandra.

Förenklat arbetsflöde för ett projekt med en enskild utvecklare

Du kan arbeta direkt på huvudgrenen i ett projekt. Detta tillvägagångssätt är enklare och innehåller färre åtgärder, men låter dig ändå hålla reda på ändringar. Om det finns fler än en utvecklare måste de vara noga med att vara synkroniserade.

När du har gjort ändringar i projektet som du vill tillämpa, gör du bara en Checka in och Pusha.

Arbetsflöde för ett projekt med flera utvecklare

Det här arbetsflödet kan användas om det finns fler än en utvecklare som arbetar med ett projekt, eller om du vill isolera ändringar. Detta innebär att du skapar en utvecklingsgren som du kan dela med andra användare. Med det här arbetsflödet kan utvecklarna hålla reda på varandras ändringar och bestämma när ändringarna ska slås samman med huvudgrenen.

1. Skapa ny gren

   Skapa en ny utvecklingsgren från huvudgrenen. Du kan dela grenen med fler användare.

2. Utveckla

   Gör alla nödvändiga ändringar i projektet.

   Anteckning om informationDatabasscheman och kopplingar underhålls inte i versionskontroll.

3. Tillämpa fjärrändringar

   Tillämpa fjärranslutna ändringar från en annan gren på ditt arbetsområde för att se till att du är uppdaterad med ändringar från den andra grenen. Detta är till hjälp för att undvika eller minska antalet motstridiga ändringar.

   Om du har två grenar som innehåller ändringar som kan komma i konflikt är en lösning att:

   1. Genomför ändringar i båda arbetsområdena.

   2. Sammanfoga båda grenarna till huvudgrenen.

   3. Tillämpa fjärrändringar igen.

4. Checka in och pusha

   Checka in och pusha dina ändringar till utvecklingsgrenen. Alla objekt kommer att pushas så det är en bra idé att validera ditt projekt innan du checkar in det.

5. Öppna en hämtningsbegäran och slå samman

   När du är klar med utvecklingen är det dags att slå samman ändringarna från arbetsområdet till huvudgrenen. Sammanslagning av en utvecklingsgren till huvudgrenen måste utföras i GitHub genom att öppna en hämtningsbegäran. Du kan ställa in godkännande för den gren som ska slås samman med huvudgrenen. För mer information, se dokumentation för GitHub hämtningsbegäran

Skapa ny gren

1. I Projekt klickar du på ... på ett projekt och väljer Skapa ny gren.

   Projektet måste vara kopplat till versionskontroll.

2. Välj för att skapa en gren från huvudgrenen.

3. Ange ett namn för grenen.

4. Ange ett prefix som ska läggas till alla scheman i projektet i Grenprefix för alla scheman. Detta gör att alla scheman kan namnges på ett unikt sätt för att undvika namnkonflikter.

5. Klicka på Skapa

En ny gren skapas från huvudgrenen och checkas ut från databasen. Grenen innehåller en ny version av projektet, där alla uppgifter har statusen Ny. De är alltså inte förberedda och innehåller inte några data.

Tillämpa fjärrändringar

Du kan tillämpa ändringar från fjärrdatabasen på ditt arbetsområde. Detta kan vara ändringar som skapats utanför Qlik Cloud integrerad versionskontroll, till exempel i GitHub eller med andra verktyg. På så sätt undviker du konflikter när du vill överföra dina ändringar till grenen.

1. I Projekt klickar du på ... på ett projekt och väljer Tillämpa fjärrändringar.

   Dialogrutan Tillämpa fjärrändringar till arbetsområde visas om det finns några ändringar.

2. Du kan nu välja vilka uppgifter du vill tillämpa ändringar för och inspektera ändringarna. För varje ändring kan du välja vilken version som ska användas, fjärrversionen eller den version som finns i ditt arbetsområde.

3. Klicka på Tillämpa fjärrändringar

Du måste lägga till källkopplingar och målkopplingar om ändringarna omfattar nya datauppgifter.

Checka in och pusha

Du kan checka in och pusha dina ändringar till grenen. Eftersom fjärrändringar som inte tillämpas på ditt arbetsområde kan skrivas över ska du utföra Tillämpa fjärrändringar innan du checkar in och pushar.

1. I Projekt klickar du på ... på ett projekt och väljer Checka in och pusha.

   Dialogrutan Checka in och pusha visas om det finns några ändringar.

2. Lägg till ett incheckningsmeddelande som kan hjälpa dig att hålla reda på vad som har ändrats.

3. Klicka på Checka in och pusha

Ta bort en gren

Du kan ta bort en gren när du har sammanfogat dina ändringar till huvudgrenen.

1. I Projekt klickar du på ... på den gren som ska tas bort och väljer Ta bort gren.

   Du kan även välja att ta bort fjärrgrenen i versionskontrollen.

   Om det finns ändringar som inte har bekräftats måste du bekräfta att dessa ändringar kommer att gå förlorade när du tar bort grenen.

Ta bort versionskontroll för ett projekt

Du kan koppla bort ditt projekt från versionskontroll. Om det finns befintliga grenar måste de tas bort innan du kan koppla bort projektet.

1. I Projekt klickar du på ... på det projekt som ska kopplas bort och väljer Koppla bort från GitHub.

Dela ett projekt med andra utrymmen eller klientorganisationer

Du kan dela en version av ett projekt med ett annat utrymme på samma klientorganisation eller på en annan klientorganisation. Detta är användbart när du vill skapa två miljöer, t.ex. en för utveckling och en för produktion.

1. Skapa ett nytt projekt med samma namn som det ursprungliga projektet.

   Sätt samma användningsfall och plattformstyp. Du kan använda olika kopplingar.

2. Koppla det nya projektet till samma databas och sökväg till baskatalogen som det ursprungliga projektet.

   Anteckning om informationVälj inte alternativet Checka in och pusha.

3. Om plattformskopplingen pekar på samma mål som det ursprungliga projektet, se till att du ändrar databasen eller schemat för datauppgifterna. Ett sätt att ändra scheman för alla uppgifter är att ändra Prefix för alla scheman i Metadata-projektets inställningar innan fjärrändringar tillämpas. Detta säkerställer att alla uppgifter skapas med detta prefix.

4. Tillämpa fjärrändringar genom att välja alla filer.

5. Lägg till saknade källkopplingar för alla mellanlagringsuppgifter.

   Klicka på Välj källdata in mellanlagringsuppgiften, välj koppling och klicka på Spara.

   Anteckning om informationKopplingen måste vara från samma typ av källa och peka på tabeller med samma namn som i det ursprungliga projektet.

6. Lägg till saknade käll- och målkopplingar för alla replikeringsuppgifter.

Detta skapar ytterligare ett arbetsområde. Du kan göra ändringar i projektet i ett av arbetsområdena och använda Tillämpa fjärrändringar för att synkronisera det andra arbetsområdet.

Säkerhetsöverväganden

Se till att du har synkroniserade säkerhetskonfigurationer mellan Qlik Talend Data Integration och GitHub.

• I Qlik Talend Data Integration baseras behörigheter på utrymmen som kan innehålla flera projekt. I GitHub baseras behörigheter på databaser som också kan innehålla flera projekt. Bästa praxis är att justera dem och koppla alla projekt i ett utrymme till samma databas.

• Tänk på att Qlik Talend Data Integration och GitHub använder olika behörigheter och roller för användare.

Metodtips

Här är några metodtips för när du arbetar med projekt som använder versionskontroll.

• Lägg till en README-fil som beskriver databasen i GitHub. Se About READMEs för mer information.

• Checka endast in projekt som är giltiga och testade.

  Om du lägger till projekt med uppgifter för mellanlagring eller registrerade data som inte har förberetts eller transformerats, ingår källkolumnerna ännu inte. Källkolumner läggs till när uppgiften förbereds och transformeras.

• När du skapar en gren för replikeringsprojekt ska du vara medveten om att grenarna som standard använder samma mål. Detta innebär att körning av uppgifter i grenen kan åsidosätta data i huvudversionen. För att undvika dataförlust ändrar du målinställningarna i grenen så att de inte står i konflikt med huvudversionen.

• När du skapar en gren kan det finnas fjärrändringar som ännu inte har tillämpats på arbetsområdet. Tillämpa fjärrändringar antingen före eller efter du skapar grenen, såvida du inte vill ta bort fjärrändringarna.

• Om du gör ändringar i samma datauppsättning i två olika grenar kan det leda till svårlösta sammanfogningskonflikter.

Begränsningar

• Det går inte att koppla från eller ta bort ett projekt med versionskoppling om det finns grenar. Grenarna måste de tas bort innan du kan koppla från eller ta bort projektet.

• Det går inte att byta namn på ett projekt med hjälp av versionskontroll.

• När du tar bort en klientorganisation kommer objekt som lagras med versionskontroll i GitHub inte att raderas. Du måste ta bort dessa objekt manuellt.

• om en databas används av flera projekt, eller innehåller många filer som inte lagras i Qlik Talend Data Integration kan prestandan försämras.

• Databasscheman och kopplingar underhålls inte i versionskontroll.

• Detaljerade personliga åtkomsttokens för GitHub stöds inte.

• En gren (utom huvudgrenen) kan endast användas av ett projekt per databas, även om två projekt finns i samma databas.

• Det är inte möjligt att tillämpa fjärrändringar från ett projekt som använder en annan målplattform. Om du till exempel gör ändringar i ett projekt i Snowflake kan du inte tillämpa ändringarna på ett Databricks-projekt.