Co to jest ciągła integracja (CI)?

Ciągła integracja to kolejny logiczny krok po posiadaniu systemu kontroli wersji, takiego jak GIT i zdalny system kontroli wersji, taki jak Gitlab lub GitHub dla wspólnych przedsięwzięć. Problem, z którym borykają się duże projekty, polega na tym - w miarę jak nowe żądania ciągnięcia, muszą zostać przetestowane, a następnie zintegrowane z głównym oddziałem, a wysiłek ten może z łatwością zająć od kilku godzin do kilku tygodni, w zależności od wielkości projektu, lokalizacja członków zespołu itp.

Jak każdy taki problem, logicznym krokiem jest zautomatyza. Robimy to, konfigurując wyzwalacz w taki sposób, że ilekroć nowsze zatwierdzenia są scalone w oddział, agent (na przykład Gitlab Runner) automatycznie buduje środowisko i kod, uruchamia wszystkie testy jednostkowe i testy integracji przeciwko niemu. Jeśli pojawi się jakikolwiek błąd, daje to ostrzeżenie i raport awaryjny, w przeciwnym razie otrzymasz zielony sygnał, w którym wszystko działa.

Oczywiście, przeniesione do logicznej ekstremalnej skrajności, możesz również zautomatyzować wdrożenie, skonfigurować zautomatyzowane testy A/B i usunąć interwencję człowieka z procesu. To jest określane jako ciągłe dostawy i/lub ciągłe wdrażanie w zależności od poziomu automatyzacji. Ale skupilibyśmy się na ciągłej integracji w tym samouczku.

Wymagania wstępne

Skoncentrujemy się na skonfigurowaniu prostego przepływu CI w samouczku za pomocą instancji Gitlab nad HTTPS, którą omówiliśmy w poprzednim poście.

Dodatkowo zakładamy również, że skonfigurowałeś konto użytkownika w tej instancji Gitlab i masz repozytorium (sklonowany na lokalnym komputerze) zarządzany pod twoją nazwą użytkownika. To repozytorium będziemy używać do zademonstrowania przepływu pracy CI. W samouczku jego nazwa będzie mój projekt.

Aby to wszystko wymienić:

1. Instancja Gitlab
2. Puste repozytorium, zwane my-proct
3. Lokalny klon tego repozytorium
4. Twoja lokalna instancja GIT skonfigurowana do wprowadzania zmian w zdalny.

Tworzenie prostej aplikacji

W tym repozytorium utwórzmy prosty węzeł.Aplikacja JS. Ta aplikacja jest prostym ekspresem.serwer JS, który ma być wdrażany w kontenerze Docker. Serwer daje ładunek HTTP, mówiąc „cześć świat” w Twojej przeglądarce.

W korzeni lokalnego repozytorium utwórz plik App.JS i dodaj następujące wiersze:

„Użyj ścisłego”;
const express = wymaga („express”);
// stałe
const port = 8080;
const host = '0.0.0.0 ';
// aplikacja
const app = express ();
App.get ('/', (req, res) =>
res.Wyślij („Hello World \ n”);
);
App.Słuchaj (port, host);
konsola.log ('Uruchamianie na http: // $ host: $ port');

Następnie utwórz inny plik pakiet.JSON i dodaj do niego następujące czynności:

„Nazwa”: „Docker_Web_App”,
"wersja 1.0.0 ",
„Opis”: „Węzeł.JS on Docker ",
„Autor”: „John Doe”,
„Main”: „Serwer.JS ",
„Skrypty”:
„Start”: „Serwer węzłów.JS "
,
„Zależności”:
„Express”: „^4.16.1 "

Wreszcie, stwórz Dockerfile i dodaj do niego następującą zawartość:

Od węzła: 8
# Utwórz katalog aplikacji
Workdir/usr/src/app
# Zainstaluj zależności aplikacji
# Lidcard służy do zapewnienia obu pakietów.JSON i blokowanie pakietów.JSON są kopiowane
Pakiet kopiowania*.JSON ./
Uruchom instalację NPM
# Jeśli budujesz swój kod do produkcji
# Uruchom instalację npm --only = produkcja
# Źródło aplikacji pakiet
KOPIUJ…
Expose 8080
CMD [„Node”, „App”]

Proces kompilacji tej aplikacji obejmowałby utworzenie kontenera węzłów i instalację zależności (jak Express.moduł JS). Ten proces powinien nastąpić bez żadnych błędów. Ze względu na prostotę nie będziemy omawiać żadnych testów w tym samouczku.

Gitlab Runner Pipeline

Teraz dodamy kolejny plik do naszego repozytorium, który byłby wywoływany .Gitlab-Ci.yml . Ten plik zawierałby instrukcje budowania naszego projektu. Teraz, za każdym razem, gdy naciskamy na naszą instancję Gitlab, Gitlab wywołałby biegacza do budowy i przetestowania projektu.

Przypisujemy ten rurociąg różny Oferty pracy które mogą działać niezależnie od siebie, dzięki czemu proces kompilacji jest bardziej elastyczny. Dla powyższego repozytorium jest to ważne .Gitlab-Ci.yml Utwórz ten plik w korzeni repozytorium:

Zdjęcie: węzeł: najnowszy
gradacja:
- zbudować
Pamięć podręczna:
Ścieżki:
- node_modules/
instalowanie_dependencje:
Etap: buduj
scenariusz:
- Instalacja NPM

Mamy tylko jeden etap zbudować I to po prostu Instalacja NPM jako skrypt. Jest to polecenie, które musisz ręcznie uruchomić za każdym razem, gdy zmiana przychodzi do twojego projektu. Biegacz Gitlab zrobiłby to za Ciebie. Runner może być zainstalowany w klastrze Kubernetes, VPS w chmurze lub na lokalnej stacji roboczej, a jeśli będzie aktywny, będzie czekał na instrukcje z serwera GitLab, aby wykonać kompilację.

Instalujemy i konfigurowaliśmy lokalnie biegacz, aby go zautomatyzować.

Uzyskanie tokenu biegacza

Otwórz swoje repozytorium na Gitlab i odwiedź jego ustawienia CD/CI. Jest to Ustawienia → CD/CI wewnątrz repozytorium testowego.

Pozostaw ustawienie Auto DevOps na jego domyślnie i kliknij ZWIĘKSZAĆ Aby rozszerzyć ogólne ustawienia rurociągu, a otrzymasz token biegacza. Skopiuj jego wartość i, oczywiście, zachowaj prywatność, jeśli cenisz swój projekt.

Korzystając z tego tokenu, Twój lokalny gitlab Runner Exceutable będzie mógł bezpiecznie zarejestrować się w instancji Gitlab.

Instalowanie biegacza Gitlab

Gitlab-Runner to mały lekki program napisany w Go, który działa powiązane z CI Oferty pracy na lokalnym komputerze i wysyła wyniki do Gitlab, aby rozważyć zmiany. Jest to pojedynczy plik wykonywalny, który można zainstalować na dowolnym głównym systemie operacyjnym. Postępuj zgodnie z instrukcjami tutaj, dla konkretnego systemu operacyjnego. Te instalacje różnią się dziko, więc wymienianie wszystkich jest niemożliwe.

Alternatywnie możesz użyć biegacza jako usługi Docker, ale trzymajmy się tradycyjnej instalacji, ponieważ polecenia są prostsze do odczytania i zrozumienia czytelnika. Po zainstalowaniu na lokalnej stacji roboczej musisz wykonać polecenie:

$ Gitlab-Runner Register

Zada ci to kilka pytań od koordynatora GITLAB-CI, który byłby twoją instancją Gitlab:

$ Gitlab-Runner Register
Wprowadź adres URL koordynatora GITLAB-CI (e.G. https: // gitlab.com/):
https: // gitlab.przykład.com

Poprosiłoby to o token biegacza, który uzyskaliśmy w poprzedniej sekcji:

Wprowadź token GITLAB-CI dla tego biegacza:

Your_Secret_Token

Następnie w celu identyfikacji opisu i możesz po prostu pominąć dodanie dowolnego tagów, uderzając:

Wprowadź opis Gitlab-CI dla tego biegacza:

[Nazwa hosta]: demo konfiguracji CI za pomocą biegacza

Wprowadź tagi GITLAB-CI dla tego biegacza (przecinek oddzielony):

Rejestracja biegacza… Udało mi się

Co najważniejsze, poprosi cię o wykonawcę (więcej o tym za chwilę), wybierzemy Docker ze względu na nasz przykład.

Wprowadź wykonawcę: Docker-Ssh+Machine, Kubernetes, Parallele, Shell, SSH, VirtualBox, Docker+Machine, Docker, Docker-Ssh:

doker

Podstawowy obraz dokera, w którym miałby miejsce kompilacja, należy następnie określić, nasza przykładowa aplikacja używa węzła, więc określamy obraz węzła:

Wprowadź domyślny obraz dokera (e.G. Ruby: 2.1):

Węzeł: najnowszy

Runner zarejestrował się pomyślnie. Zapraszam do rozpoczęcia, ale jeśli jest już uruchomiony, konfiguracja powinna zostać automatycznie ponownie załadowana!

Teraz coś, co wymaga małego wyjaśnienia, jest to, co dokładnie są Wykonawcy? Sposób, w jaki przepływ pracy CI polega na tym, że budowanie modułów, ich testów itp Oferty pracy a wykonawcy wykonują te zadania. Jeśli wybrałeś VirtualBox jako wykonawcę, Gitlab Runner zintegrowałby się z lokalnie zainstalowanym VirtualBox i uruchomił zadania CI w maszynie wirtualnej, jeśli wybierzesz kubernetes, to wydarzy się w klastrze Kubernetes, w chmurze, jeśli możesz wybrać SSH, możesz delegować zadania CI na zdalny serwer.

Nasz przykładowy projekt opiera się na Docker, więc sensowne jest użycie Dockera jako naszego wykonawcy. Musisz mieć Docker zainstalowany lokalnie dla tego.

Posiadanie wielu opcji wykonawców sprawia, że ​​biegacz jest bardziej elastyczny. Możesz zbudować lokalnie, ponieważ pliki projektu są zbyt duże lub możesz chcieć wykonać na zdalnym serwerze z 20 rdzeniami i połową terabajtu pamięci RAM, ponieważ proces kompilacji jest intensywny obliczeniowo, określenie opcji wykonawcy daje taką elastyczność.

Wreszcie, w swojej powłoce chcesz rozpocząć usługę biegacza:

$ Gitlab-Runner start

Widzenie .Gitlab-Ci.YML w akcji

Teraz dokonaliśmy wszystkich tych zmian w naszym lokalnym repozytorium, stworzyło całą aplikację.JS, pakiet.JSON, Dockerfile i .Gitlab-Ci.Pliki YML. Przypuszczalnie popełniłeś zmiany w lokalnym repozytorium, uruchamiając:

$ git scena_name_name
$ git commit -m „commit Message”

Przesuńmy zmiany do naszego zdalnego gitlab.

$ git push -u pochodzenie

Następnie możesz otworzyć swój projekt w Gitlab, przejdź do My-Project → Rurociąg I zobaczysz to tag z napisem „minął” obok dokonanego zobowiązania. Kolejne zatwierdzenia będą miały również tagi.

To są podstawy CI za pomocą Gitlab i Runner. Mam nadzieję, że podobał Ci się ten post i nauczyłeś się czegoś nowego.