Infrastruktur som kod: Hur vi Förnyade vår utvecklings- / släppprocess för att omfatta vår teamskala

(11 dec 2020)

I den här artikeln visar vi hur vi hanterade vår kontinuerliga implementeringsprocess tidigare, vad som fick oss att ändra vad vi har, och vilka ansträngningar vi gjorde för att göra processen så enkel / effektiv som möjligt.

Artikeln kan ge en första devops smak, men i huvudsak påverkar release-processen alla lag och hur de fungerar på egen hand eller samarbeta med andra team kommer vi att visa hur roller flyttas bara genom att ändra processen.

Om oss

Vi på Halan hjälper till att erbjuda logistiklösningar på begäran och på begäran ( avbetalningar, leverans, betalningar online, e-handel) för den underbetjänade befolkningen av befintlig teknik inom transport och andra tjänster kan du kolla in vår ap p här ( android / iOS )

Ge den gamla processen det beror på det goda och det dåliga

Vi kommer att börja med hur vi hanterade vår process tidigare och hur det påverkade oss antingen positivt eller negativt.

För mitt team har vi nästan allt distribuerat över AWS med GitHub som vårt versionskontrollsystem, så vi måste ta reda på ett sätt att skicka funktioner från våra GitHub-repor till AWS-tjänster.

Versionskontroll av distributioner

Vi förlitar sig på AWS-kodrörledning , vi satte utlösare för att starta en distributionsrör när ett nytt engagemang slås samman till en av huvudgrenarna som representerar de kända stadierna: dev , prod och iscenesättning miljöer.

översikt över hur distributioner utlöses

Detta flöde betyder att alla funktioner i huvudgrenen finns på produktion, som säkert gör sammanslagning för att bemästra ett tabuämne att diskutera och inte alla hade att tillstånd för att slå samman din PR till master.

Samma sak var för andra grenar men det var inte t verkligen ett problem, eftersom dev och staging envs inte är så skrämmande.

Vår QC började testa och verifiera funktioner när de slås samman på staging, vilket innebär att de först testar på staging env och sedan verifierade kommer funktionen att slås samman i master -grenen. det verkar fungera bra men låt oss titta på nackdelarna med en sådan process.

Detta gjorde det möjligt för oss att testa och distribuera flera funktioner samtidigt på varje steg (dev, staging), vilket är bra och dåligt på samma gång eftersom:

  • Det betyder att utvecklare inte behöver vänta på varandra för att få kontroll över dev / staging-miljön.
  • Men det betyder att funktioner på dev-steg kunde felaktigt orsaka varandra att antingen inte fungerar eller arbete (falskt positivt), och båda dessa fall är riktigt dåliga och kan få koden att gå på produktion medan den inte riktigt fungerar.

Divergerande grenar, onödig omstrukturering

Som du kanske redan har lagt märke till, sa vi att för att distribuera på dev env, du måste slå samman din kod på dev-grenen. Nåväl, den delen förstörde tyvärr snabbt tidslinjen för vår gren som:

  • Inte alla funktioner som har testats på dev går i produktion så vi hade som spökeförpliktelser i vår enhetliga dev-gren .
  • Ett experimentlaboratorium utan tvekan, människor kan upptäcka att de har gjort något fel efter ett tag och bestämmer sig för att släppa sin kod / åtaganden och starta en ny, men det lämnar oss fortfarande med sina gamla åtaganden slogs samman på dev-grenen.

Denna typ av beteende producerade vad vi kallar divergens mellan grenar, för att slå samman en -funktion gren som har master som bas till dev, du måste lösa konflikter ! vilket är obekvämt konstigt att du bokstavligen strider mot spöken och löser saker som aldrig kommer att vara på produktion längre, vilket säkert ger dig två dåliga alternativ:

  • Skapa en ny gren för din funktion gaffelad från din ursprungliga funktionsgren och lösa konflikter på den, och slå samman den ursprungliga filialen till master.
  • Lös konflikter i din gren och välj sedan dina åtaganden till en ny gren när de slås samman till master.

När fler utvecklare går med i vårt team kommer saker att bli mer fula och avvikelser kommer säkert att ta en stigning.

Förnya bygg- / distribueringsprocessen

Det första vi tänkte på är hur vi kan bli av med de avvikande grenarna, vi behöver en ny metod för att säkert leverera funktioner till produktion sömlöst och styra hur många funktioner som distribueras på produktion utan att involvera källkontroll med distributionsverksamhet.

En liten recension av AWS

Först måste vi identifiera de viktigaste element som kommer att spela en roll hos oss i processen:

  • Github : källkontroll har repor för varje mikrotjänst där ute.
  • Amazon ECR : ett Docker-avbildsregister som är uppdelad i ”repos” representerar varje repo också en mikrotjänst och innehåller bilderna som har drivits för tjänsten X och kan användas eller distribueras till den här tjänsten direkt för att få den att fungera.
  • Amazon ECS / EC2 / EKS : det är här våra mikrotjänster bor, tillsammans med sina miljöer, är ECS uppdelad i kluster, varje kluster har ett antal tjänster var och en har uppgiftsdefinition som innehåller information som miljövariabler , beräkna specifikationer, nätverk osv.

Så vi måste hitta ett sätt att binda dem tillsammans för att göra det lättare för oss som dev-team att leverera funktioner och för QC att kontrollera och verifiera dessa funktioner.

Vi tänkte att vi kunde definiera en mellanhandstjänst, en -tjänst som ansvarar för distribuerar andra tjänster. Vi hade två huvudkommandon som vi ville att den här tjänsten skulle hantera:

  • Bygg kommando: we vill kunna bygga en bild och driva den till ECR från vilken gren / engagemang vi vill från en viss GitHub-repo till en viss ECR-repo.
  • Distribuera kommando: vi vill kunna distribuera en viss bild från en repo på ECR till alla kluster som har tjänsten X.

Låt oss ta var och en av dessa kommandon under mikroskopet och se vad var och en av dessa involverar, vi börjar med Bygg Kommando:

  • Först och främst måste vi klona repo vid det angivna engagemanget / grenen.
  • Skapa en dockningsbild med Dockerfilen i den repo.
  • Tryck på byggd bild till ECR repo med en ny tagg om det behövs eller senast.

Även om alla dessa steg verkligen är doab le i vår nya distributionstjänst, men vi fann att det är besvärligt eftersom att bygga docker bilder konsumerar mycket resurser och det kommer att begränsa vår nya tjänst till några samtidiga -distributioner eller göra det så gigantiskt i resurser.

Vi tänkte att vi kunde starta en ny arbetsflöde Github på den repo och skicka till allt uppgiftsdetaljer som vilken gren som ska checkas ut och vilken ECR-repo som ska tryckas till, när den äntligen är klar kommer den att signalera användaren tillbaka med en webbkrok . Naturligtvis finns det andra lösningar för det, till exempel Jenkins för bättre säkerhet för att se till att din kod bygger på maskiner du hanterar.

Det ändrade arbetsflödet vi nämnde ovan, det går nu som följer:

  • Ta emot byggdetaljer från användaren.
  • Utlös en Github -åtgärd angiven repo.
  • Github-åtgärder snurrar en ny maskin som meddelar oss tillbaka med byggstatus när gjort kommer det också att märka åtagandet med Jira-kortnummer du arbetar med.

Andra kommandot är Depoly kommandot, vilket är mycket enklare än byggkommandot, vi behöver bara här:

  • Få distributionsinformation från användaren.
  • Starta en ny distributionsuppgift i varje kluster som fortsätter tjänsten och tillhandahåller webbadressen i ECR.

arbetsflöde för distribution

Det är verkligen det för distribution! bara ett underlättande jobb mellan två AWS-produkter, låt oss jämföra detta arbetsflöde med vad vi hade tidigare och se hur vår release-strategi förändrades.

Att använda den nya processen för att distribuera din kod på någon av stadierna (prod, dev, staging) kräver ingen typ av sammanslagningar , -koden är helt oberoende av distribution , vi kan ha 20 funktioner redo på huvudgrenen och väljer bara att distribuera 10 av dem.

Men detta innebär också att vi bara kan ha en funktion som testat på dev-grenen såvida inte två devs gick med på att rebase på varandra.

Deployment History and Tagging

Detta gav oss också en bättre återställning strategi mot produktionsfrågor. Nu har vi en taggad huvudfilial för varje funktion / uppgift vi hade, när vi står inför en produktionsfråga och vill återställa en funktion kan vi enkelt navigera tillbaka till den här funktionen startade och återgå till engagemanget innan det om möjligt.

Också som gjorde det möjligt för oss att slå samman alla funktionsfunktioner på mastergrenen, även om de inte kommer att distribueras, kan vi fortfarande ha dem på master redo för nästa serie funktioner som ska vara i produktion vid behov, vilket säkert kommer att hjälpa våra teamet fokuserar på att leverera uppgifter utan att oroa sig för när den uppgiften kommer att slås samman till master för att distribueras, här slås vi samman först och sedan oroar oss för distributioner.

Nästa steg

Vi arbetar för närvarande för att automatisera vår process bättre, inklusive miljövariabler och maskinspecifikationer, kommer de alla att finnas tillgängliga som kod, när vi ändrar dessa specifikationer, som automatiskt återspeglar ect på våra maskiner på AWS i respektive Miljö , inget behov av att handkoda dessa värden varje gång på AWS.

Med detta får vi bättre kontroll och synlighet på alla våra tjänstekonfigurationer, allt i vår infrastruktur kommer att finnas i kod och ett klick bort för att uppdatera! också som gör att vi ändrar vår infrastruktur oberoende av tjänsteleverantören, vi kan till exempel byta från AWS till Google-molnet och behöver bara ändra kommandona som används av distributionstjänsten för att distribuera vår infrastruktur på den nya tjänsteleverantören.

Lämna ett svar

Din e-postadress kommer inte publiceras. Obligatoriska fält är märkta *