Jak zainstalować serwis GitLab przy użyciu Docker Compose?

Cześć. Dzisiaj zaprezentuję Wam jak możecie w ciągu godziny zainstalować serwer GitLab oraz uruchomić w nim swoje pierwszy proces CI/CD.

Ten artykuł wchodzi w skład cyklu pokazującego jak rozpocząć pracę w popularnych narzędziach CI/CD. W ramach artykułu pokażę Wam jak zainstalować narzędzie CI/CD oraz jak przygotować proces budowania oraz testowania prostego projekty opartego na Mavenie.

Czym jest GitLab?

Gitlab jest narzędziem wspierającym tworzenie oprogramowania przy użyciu procesów Continuous Integration i  Continuous Delivery. Jego głównym elementem jest system kontroli wersji Git. Oprócz tego udostępnia wiele funkcji, które wspierają pracę programistów w ciągłym budowaniu, testowaniu i automatycznej instalacji projektów na różne środowiska.

Czym jest Docker Compose?

Aby dowiedzieć się czym jest Docker Compose przejdź do artykułu: Jak zainstalować Jenkinsa przy użyciu Docker Compose?

Wymagane narzędzia

Przed rozpoczęciem pracy należy przygotować wymagane narzędzia. Opis tych narzędzi znajdziesz również na stronie: Jak zainstalować Jenkinsa przy użyciu Docker Compose?

Konfiguracja dla Docker Compose

Pracę nad instalacją rozpoczniemy od utworzenia dedykowanego katalogu, w którym będziemy przechowywać dane i konfigurację Gitlaba.

> mkdir gitlab

Dla wygody ustawimy też zmienną środowiskowa, która zawierać będzie ścieżkę do naszego katalogu z Gitlabem:

> export GITLAB_HOME=$(pwd)/gitlab

W kolejnym kroku tworzymy plik docker-compose.yml z poniższą zawartością:

# docker-compose.yml
version: '3.7'
services:
  web:
    image: 'gitlab/gitlab-ce:latest'
    restart: always
    hostname: 'localhost'
    container_name: gitlab-ce
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://localhost'
    ports:
      - '8080:80'
      - '8443:443'
    volumes:
      - '$GITLAB_HOME/config:/etc/gitlab'
      - '$GITLAB_HOME/logs:/var/log/gitlab'
      - '$GITLAB_HOME/data:/var/opt/gitlab'
    networks:
      - gitlab
  gitlab-runner:
    image: gitlab/gitlab-runner:alpine
    container_name: gitlab-runner    
    restart: always
    depends_on:
      - web
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - '$GITLAB_HOME/gitlab-runner:/etc/gitlab-runner'
    networks:
      - gitlab

networks:
  gitlab:
    name: gitlab-network

Konfiguracja ta określa jakie kontenery chcemy uruchomić. W naszym przypadku będzie to serwis GitLab wraz z jednym GitLab runnerem (osobnym modułem do uruchamiania zadań CI/CD). Najważniejsze parametry konfiguracji to:

• image – obraz docker, który chcemy wykorzystać w naszym serwerze
• ports – lista portów, które udostępniamy na zewnątrz kontenera. W naszej konfiguracji udostępniamy porty 80, 443 (portal www)
• container_name – nazwa naszego kontenera
• volumes – określa wolumeny, które są wykorzystane przez kontener. W naszej konfiguracji mamy tutaj katalogi współdzielone z naszym systemem (podkatalogi w $GITLAB_HOME) oraz dodatkowy wolumen umożliwiający dostęp do środowiska Docker z poziomu GitLab runnera.
• networks – określa wirtualną sieć w której będą działać kontenery. W naszym wypadku portal www oraz runner działają w jednej sieci „gitlab-network”

Instalujemy Gitlaba

Uruchomienie kontenerów realizowane jest za pomocą komendy:

> docker-compose up -d

Po uruchomieniu Docker pobierze obrazy GitLaba oraz GitLab Runnera z serwerów. Na moim komputerze wyglądało to tak:

Aby zalogować się pierwszy raz do serwisu GitLab potrzebne jest tymczasowe hasło, które jest generowane automatycznie podczas instalacji. Hasło pobieramy za pomocą komendy:

> docker exec -it gitlab-ce grep 'Password:' /etc/gitlab/initial_root_password

Uruchamiamy GitLaba

Nasz GitLab dostępny jest pod adresem: http://localhost:8080. Po przejściu na ten adres powinien pojawić nam poniższy ekran:

Uwaga: pierwsze uruchomienie portalu może zająć kilka minut.

Aby zalogować się do portalu musimy podać w polu Username „root” a w polu Password tymczasowe hasło, które pobraliśmy wcześniej.

Po zalogowaniu powinien się pojawić następujący ekran:

Gratuluję, GitLab został poprawnie uruchomiony!

Wstępna konfiguracja portalu

Zanim przejdziemy dalej warto jest zmienić kilka ustawień portalu. Na początku wyłączymy otwartą rejestrację dla wszystkich. W tym celu klikamy na przycisk View Setting dostępny na górnej belce z ostrzeżeniem (adres do panelu: http://localhost:8080/admin/application_settings/general#js-signup-settings). Na nowej stronie odznaczamy Sign-up enabled i zapisujemy zmiany.

Kolejnym krokiem powinna być zmiana użytkownika. W tym celu przechodzimy na stronę: http://localhost:8080/-/profile/account i podajemy nazwę w polu Change username. Zatwierdzamy klikając na Update username.

Ostatnią zmianę jaką wykonamy jest zmiana hasła. W tym celu przechodzimy na stronę: http://localhost:8080/-/profile/password/edit i podajemy tymczasowe hasło oraz nowe hasło. Zmianę zatwierdzamy klikając Save password.

Konfiguracja GitLab runnera

Aby skorzystać z GitLab runnera w GitLabie należy go skonfigurować. Do poprawnej konfiguracji potrzebny będzie nam token skopiowany z portalu. W tym celu przechodzimy do adresu: http://localhost:8080/admin/runners i klikamy przycisk Copy token.

W kolejnym kroku przechodzi do konsoli i uruchamiamy poniższe polecenie:

> docker exec -it gitlab-runner gitlab-runner register --url "http://gitlab-ce" --clone-url "http://gitlab-ce"

Po uruchomieniu pojawi się nam moduł do konfiguracji. W module podajemy następujące informacje:

• Enter the GitLab instance URL: potwierdzamy wprowadzoną wartość (klikamy enter)
• Enter the registration token: podajemy skopiowany powyżej token.
• Enter a description for the runner: podajemy nazwę runnera, np. docker-runner
• Enter tags for the runner: tutaj zostawiamy puste pole
• Enter an executor: tutaj wpisujemy docker
• Enter the default Docker image: tutaj podajemy domyślny obraz dockerowy, np. maven:latest

Po prawidłowym skonfigurowaniu powinniśmy zobaczyć potwierdzenie Runner registred successfully:

Oprócz podstawowej konfiguracji musimy jeszcze umożliwić dostęp kontenerom uruchamianym z poziomu runnera do wirtualnej sieci, w której działa GitLab. W tym celu uruchamiamy edytor (np. vi)

>  sudo vi gitlab/gitlab-runner/config.toml

I dodajemy do konfiguracji runnera na końcu linię: network_mode = „gitlab-network”

Żeby sprawdzić, czy runner jest dostępny z poziomu GitLaba wchodzimy na adres: http://localhost:8080/admin/runners

Tworzymy nasze pierwsze repozytorium

Po skonfigurowaniu runnera możemy utworzyć nasze pierwsze repozytorium. W tym celu przechodzimy na stronę: http://localhost:8080/projects/new i klikamy import project.

Na następnym ekranie wybieramy Import project from: Repo from URL. Następnie podajemy w Git repository URL adres: https://github.com/czerniga/helloworld.git. Na końcu zatwierdzamy klikając Create project.

Po chwili powinniście mieć pierwsze repozytorium skopiowane do swojego GitLaba.

Tworzymy pipeline CI/CD

Aby utworzyć pipeline CI/CD dla projektu klikamy w głównym meny po lewej CI/CD a potem Editor. Na ekranie pojawi się opcja utworzenia pliku .gitlab-ci.yml, który będzie zawierał definicje naszego pipeline. Plik ten zostanie utworzony w repozytorium Git.

Po przejściu na nowy ekran widzimy edytor naszego pipeline’a. W edytorze wklejamy poniższą zawartość:

image: maven:latest

stages:
  - build
  - test

build-job:
  stage: build
  script:
    - echo "Compiling the code..."
    - mvn clean package
    - echo "Compile complete."
  artifacts:
    paths:
    - target   

test-job:
  stage: test
  dependencies: 
    - build-job  
  script:
    - ls -al
    - echo "Running tests"
    - java -cp target/helloworld-1.1.jar com.coveros.demo.helloworld.HelloWorld

Powyższa definicja określa nam jak ma działać proces CI/CD. Najważniejsze elementy to:

• image: obraz docker, który wykorzystamy do budowania naszego projektu
• stages: lista kroków naszego procesu
• build-job: pierwszy krok naszego procesu, którego celem jest zbudowanie naszej projektu. Dodatkowo zapisujemy artefakty w celu wykorzystania go w kolejnym kroku
• test-job: drugi krok, którego celem będzie uruchomienie naszego projektu

Po wklejeniu naszego pliku zatwierdzamy zmiany klikając Commit changes.

Po zatwierdzeniu GitLab uruchomi proces. Aby sprawdzić jego wyniki przechodzimy w menu po lewej do CI/CD -> Pipelines. Na ekranie powinniśmy zobaczyć że nasze pierwsze zadanie zostało już uruchomione.

Możemy przejść do szczegółów tego zadania klikając na przycisk pending lub numer builda #1

Po chwili zadanie powinno zostać zbudowane i przetestowane.

Gratulację, właśnie utworzyłeś swoje pierwsze zadanie CI/CD w GitLabie!

Zatrzymujemy kontener

Kontenery zawierające nasz serwis zostały uruchomione z przełącznikiem powodującym pracę w tlę. Jeśli chcecie zatrzymać portal należy wykonać polecenie:

docker-compose down

Podsumowanie

W tym poradniku pokazałem jak można uruchomić serwis GitLab wraz z jednym GitLab runnerem. Podana tutaj konfiguracja powoduje, że wszystkie dane serwisu zapisywane są w katalogu na Waszym komputerze/serwerze. Z tego powodu dane nie zostaną skasowane w momencie zatrzymania czy usunięcia kontenerów.