Infrastruktura jako kod: jak my Zmieniliśmy nasz proces rozwoju / wydawania, aby objąć skalę naszego zespołu

(11 grudnia 2020 r.)

W tym artykule pokazujemy, jak radziliśmy sobie z procesem ciągłego wdrażania w przeszłości, co skłoniło nas do zmiany tego, co mamy, i jakie wysiłki podjęliśmy, aby proces był tak prosty / skuteczny, jak to tylko możliwe.

Artykuł może dać początkowy smak Devops, ale w istocie proces wydania wpływa na wszystkie zespoły i ich samodzielne funkcjonowanie lub współpracować z innymi zespołami, pokażemy, jak zmienia się rola, zmieniając tylko proces.

O nas

W Halan pomagamy oferować rozwiązania logistyczne na żądanie i usługi przewozowe ( raty, dostawa, płatności online, e-commerce) dla niedostatecznie obsługiwanej populacji przez istniejące technologie w transporcie i innych usługach, możesz sprawdzić naszą ap p tutaj ( android / iOS )

Przekazywanie starego procesu to się należy, dobre i złe

Zaczniemy od tego, jak radziliśmy sobie z naszym procesem w przeszłości i jak wpłynęło to na nas pozytywnie lub negatywnie.

Dla mojego zespołu mamy prawie wszystko zostało wdrożone przez AWS z GitHubem jako naszym systemem kontroli wersji, więc musimy znaleźć sposób na wysyłanie funkcji z naszych repozytoriów GitHub do usług AWS.

Wdrożenia kontroli wersji

opierając się na potoku kodu AWS , ustawiliśmy wyzwalacze, aby rozpocząć potok wdrażania za każdym razem, gdy nowe zatwierdzenie zostanie scalone w jedną z głównych gałęzi reprezentujących znane etapy: dev , prod i inscenizacja środowiskach.

omówienie sposobu wyzwalania wdrożeń

Ten przepływ oznacza że jakakolwiek funkcja w gałęzi master znajduje się na produkcji, , co z pewnością sprawia, że ​​scalanie staje się tematem tabu do omówienia, a nie każdy miał że pozwolenie na scalenie Twojego PR na master.

To samo dotyczyło innych gałęzi, ale to nie było Naprawdę problem, ponieważ środowiska deweloperskie i tymczasowe nie są tak naprawdę przerażające.

Nasza kontrola jakości zaczęła testować i weryfikować funkcje, gdy są one scalane w fazie przejściowej, co oznacza, że ​​najpierw testują na etapach środowiska, a następnie po zweryfikowaniu , funkcja zostanie włączona do gałęzi master . wydaje się, że działa dobrze, ale spójrzmy na wady takiego procesu.

Pozwoliło nam to przetestować i wdrożyć wiele funkcji jednocześnie na każdym etapie (tworzenie, staging), co jest dobre i złe w w tym samym czasie, ponieważ:

  • Oznacza to, że programiści nie muszą czekać na siebie nawzajem, aby przejąć kontrolę nad środowiskiem deweloperskim / przejściowym.
  • Ale oznacza to, że funkcje są włączone etap dev może omyłkowo spowodować, że nie będzie działać lub działa (fałszywie dodatni), a oba te przypadki są naprawdę złe i mogą powoduje, że kod przechodzi do produkcji, gdy tak naprawdę nie działa.

Rozbieżne gałęzie, niepotrzebne ponowne bazowanie

Jak pewnie już zauważyłeś, powiedzieliśmy, że aby wdrożyć dev env, musisz scalić swój kod w gałęzi dev. Cóż, ta część niestety szybko zepsuła oś czasu naszej gałęzi, ponieważ:

  • Nie wszystkie funkcje, które były testowane na programistach, trafiają do produkcji, więc mieliśmy jak duchowe zmiany w naszej ujednoliconej gałęzi deweloperów .
  • Bez wątpienia laboratorium eksperymentalne, ludzie mogą odkryć, że robili coś złego po pewnym czasie i zdecydować się porzucić kod / zatwierdzenia i rozpocząć nowy, ale to nadal pozostawia nas z ich starymi zatwierdzeniami scalone w gałęzi dev.

Ten rodzaj zachowania spowodował to, co nazywamy dywergencją między gałęziami, aby scalić funkcję , którego gałąź główna jest podstawą w dev, musisz przekształcić konflikty ! co jest niezręcznie dziwne, że dosłownie walczysz z duchami i rozwiązujesz rzeczy, które nigdy nie będą w produkcji , to z pewnością daje ci dwie kiepskie opcje:

  • Zbuduj nową gałąź dla swojej funkcji rozwidloną z oryginalnej gałęzi funkcji i rozwiąż na niej konflikty, a po zakończeniu testów połącz oryginalną gałąź z główną.
  • Rozwiąż konflikty w swojej gałęzi, a następnie wybierz swoje zatwierdzenia do nowej gałęzi podczas łączenia się w główną.

Wraz z dołączeniem większej liczby programistów do naszego zespołu, sprawy zaczną się brzydsze a dywergencja z pewnością wzrośnie.

Przebudowa procesu budowania / wdrażania

Pierwszą rzeczą, o której myśleliśmy, było pozbycie się tych rozbieżnych gałęzi, potrzebujemy nowej metody aby bezpiecznie dostarczać funkcje do produkcji, bezproblemowo i kontrolować liczbę funkcji wdrażanych w środowisku produkcyjnym bez angażowania kontroli źródła w działalność wdrożeniową.

Mały przegląd AWS

Najpierw musimy zidentyfikować główne elementy, które będą odgrywać rolę w tym procesie:

  • Github : kontrola źródła posiadanie repozytoriów dla każdej mikrousługi.
  • Amazon ECR : rejestr obrazów Dockera, który jest podzielone na „repo”, każde repozytorium reprezentuje również mikroserwis i zawiera obrazy, które zostały przekazane do usługi X i mogą być używane lub wdrażane bezpośrednio w tej usłudze, aby działała.
  • Amazon ECS / EC2 / EKS : tutaj żyją nasze mikrousługi, wraz z ich środowiskami, ECS jest podzielony na klastry, każdy klaster zawiera wiele usług, z których każda ma definicję zadania, która zawiera informacje takie jak zmienne środowiskowe , specyfikacje obliczeniowe, sieć itp.

Musimy więc znaleźć sposób na ich połączenie, aby ułatwić nam jako zespołowi programistów dostarczanie funkcji oraz kontrolę i weryfikację tych funkcji. funkcji.

Pomyśleliśmy, że możemy zdefiniować usługę pośrednika, usługę , która jest odpowiedzialna za wdrażanie innych usług. Mieliśmy dwa główne polecenia, które chcieliśmy obsługiwać tej usługi:

  • Polecenie kompilacji: my chcesz mieć możliwość zbudowania obrazu i przekazania go do ECR z dowolnej gałęzi / zatwierdzenia, z określonego repozytorium GitHub do określonego repozytorium ECR.
  • Wdróż polecenie: chcemy mieć możliwość wdrożenia określonego obrazu z repozytorium w ECR do wszystkich klastrów obsługujących usługę X.

Weźmy każde z tych poleceń pod mikroskopem i zobaczmy, na czym one polegają, zaczynamy od polecenia Build :

  • Przede wszystkim musimy sklonować repozytorium w określonej gałęzi / zatwierdzenia.
  • Zbuduj obraz dockera, używając pliku Dockerfile w tym repozytorium.
  • Wypchnij wbudowany obraz do repozytorium ECR z nowym lub najnowszym tagiem.

Chociaż wszystkie te kroki są z pewnością do zrobienia le w naszej nowej usłudze wdrażania, ale okazało się, że jest to kłopotliwe, ponieważ tworzenie docker obrazów zajmuje dużo zasoby , co ograniczy naszą nową usługę do kilku współbieżnych lub uczynić go tak gigantycznym pod względem zasobów.

Pomyśleliśmy, że zamiast wykonywać całą tę pracę nad samą usługą, moglibyśmy rozpocząć nowy workflow na Github w tym repozytorium i przejdź do niego wszystko szczegóły zadania, takie jak gałąź do pobrania i repozytorium ECR do wypchnięcia, kiedy zostanie ukończone, zasygnalizuje użytkownikowi z powrotem za pomocą web-hook . Oczywiście istnieją inne rozwiązania, takie jak Jenkins dla lepszego bezpieczeństwa, aby upewnić się, że twój kod jest zbudowany na maszynach, którymi zarządzasz.

To zmieniło przepływ pracy, o którym wspomnieliśmy powyżej, teraz wygląda następująco:

  • Odbierz szczegóły kompilacji od użytkownika.
  • Uruchom akcję Github na określone repozytorium.
  • Akcje Github obrócą nową maszynę , która powiadomi nas o stanie kompilacji, gdy gotowe, oznacza to również zatwierdzenie Numer karty Jira , nad którym pracujesz.

Drugim poleceniem jest Depoly , które jest o wiele prostsze niż polecenie kompilacji, tutaj musimy tylko:

  • Odbierz szczegóły wdrożenia od użytkownika.
  • Rozpocznij nowe zadanie wdrażania w każdym klastrze zawierającym usługę i podaj adres URL obrazu w ECR.

przepływ pracy podczas wdrażania

To naprawdę wszystko, jeśli chodzi o wdrożenie! tylko praca ułatwiająca pracę między dwoma produktami AWS, porównajmy ten przepływ pracy z tym, co mieliśmy wcześniej i zobaczmy, jak zmieniła się nasza strategia wydawania.

Korzystanie z nowego procesu wdrażania kodu na dowolnym z etapów (prod, dev, staging) nie wymaga scaleń , kod jest całkowicie niezależny od wdrożenie , moglibyśmy mieć 20 funkcje gotowe w gałęzi głównej i można wybrać tylko wdrożyć 10 z nich.

Ale to również oznacza, że ​​możemy mieć tylko jedną funkcję testowane w gałęzi deweloperskiej, chyba że dwóch programistów zgodziło się na rebase na sobie nawzajem.

Historia wdrażania i oznaczanie

Pozwoliło nam to również na lepsze wycofanie strategia przeciwko problemom produkcyjnym. Teraz mamy otagowaną gałąź główną dla każdej funkcji / zadania mieliśmy, gdy napotkaliśmy problem produkcyjny i chcielibyśmy cofnąć jakąś funkcję, możemy łatwo wrócić do miejsca, w którym ta funkcja się zaczęła i jeśli to możliwe, cofnąć się do wcześniejszego zatwierdzenia.

Pozwoliło nam to również na scalenie wszystkich działających funkcji w gałęzi głównej, nawet jeśli nie zostaną one wdrożone, możemy nadal mieć je na serwerze głównym gotowe, aby kolejna partia funkcji pojawiła się w produkcji w razie potrzeby, co z pewnością pomoże zespół skupia się na dostarczaniu zadań bez martwienia się o to, kiedy to zadanie zostanie scalone w główne do wdrożenia, tutaj najpierw scalamy, a potem martwimy się o wdrożenia.

Następne kroki

Obecnie pracujemy nad automatyzacją nasz proces, w tym zmienne środowiskowe i specyfikacje maszyn, wszystkie będą dostępne jako kod, gdy zmienimy te specyfikacje, które automatycznie odzwierciedlą ect na naszych komputerach w AWS w odpowiednim Środowisku , nie ma potrzeby ręcznego kodowania tych wartości za każdym razem w AWS.

Dzięki temu będziemy mieć lepszą kontrolę i widoczność wszystkich konfiguracji naszych usług, wszystko w naszej infrastrukturze będzie zakodowane i wystarczy jedno kliknięcie, aby zaktualizować! co również sprawia, że ​​zmiana naszej infrastruktury jest niezależna od dostawcy usług, moglibyśmy na przykład przejść z AWS do chmury Google i wystarczy zmienić polecenia używane przez usługę wdrażania, aby wdrożyć naszą infrastrukturę u nowego dostawcy usług.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *