Samouczek: wdrażanie z usługi GitHub w usłudze Azure Kubernetes Service przy użyciu narzędzia Jenkins

Ten samouczek wdraża przykładową aplikację z usługi GitHub w klastrze usługi Azure Kubernetes Service (AKS), konfigurując ciągłą integrację (CI) i ciągłe wdrażanie (CD) w usłudze Jenkins.

W tym samouczku wykonasz następujące zadania:

Wymagania wstępne

Do ukończenia tego samouczka potrzebne są następujące elementy:

• Podstawowa wiedza na temat Kubernetes, Git, CI/CD i obrazów kontenerów

• Klaster AKS i kubectl skonfigurowany z poświadczeniami klastra AKS.

• Rejestr usługi Azure Container Registry (ACR), nazwa serwera logowania usługi ACR i klaster AKS skonfigurowany do uwierzytelniania za pomocą rejestru ACR.

• Kontroler serwera Jenkins wdrożony na maszynie wirtualnej platformy Azure.

• Interfejs wiersza polecenia platformy Azure w wersji 2.0.46 lub nowszej został zainstalowany i skonfigurowany. Uruchom az --version, aby znaleźć wersję. Jeśli konieczna będzie instalacja lub uaktualnienie, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure.

• Docker zainstalowany w systemie deweloperskim

• Konto usługi GitHub, osobisty token dostępu usługi GitHub i klient Git zainstalowany w systemie deweloperskim

• Jeśli udostępnisz własne wystąpienie serwera Jenkins zamiast tego przykładowego skryptu przeznaczonego do wdrożenia Jenkins, wystąpienie serwera Jenkins wymaga zainstalowania i skonfigurowania platformy Docker oraz narzędzia kubectl.

Przygotowywanie aplikacji

W tym artykule użyto przykładowej aplikacji do głosowania na platformie Azure, która zawiera interfejs internetowy i usługę Redis na potrzeby tymczasowego magazynu danych.

Przed zintegrowaniem usług Jenkins i AKS na potrzeby wdrożeń automatycznych należy najpierw przygotować i wdrożyć aplikację do głosowania platformy Azure w klastrze usługi AKS. To ręczne wdrożenie umożliwia wyświetlenie aplikacji w działaniu.

Skopiuj następujące repozytorium GitHub dla aplikacji przykładowej — https://github.com/Azure-Samples/azure-voting-app-redis. Aby sforkować repozytorium na własne konto GitHub, wybierz przycisk Fork w prawym górnym rogu.

Sklonuj fork do systemu developerskiego. Podczas klonowania tego repozytorium upewnij się, że używasz adresu URL rozwidlenia:

git clone https://github.com/<your-github-account>/azure-voting-app-redis.git

Przejdź do katalogu sklonowanego rozwidlenia:

cd azure-voting-app-redis

Aby utworzyć obrazy kontenerów potrzebne dla przykładowej aplikacji, użyj pliku docker-compose.yaml z poleceniem docker-compose:

docker-compose up -d

Wymagane obrazy podstawowe są pobierane, a kontenery aplikacji budowane. Następnie możesz użyć polecenia docker images , aby wyświetlić utworzony obraz. Pobrano lub utworzono trzy obrazy. Obraz azure-vote-front zawiera aplikację i używa obrazu nginx-flask jako podstawy. Obraz redis jest używany do uruchamiania wystąpienia usługi Redis:

$ docker images

REPOSITORY                   TAG        IMAGE ID            CREATED             SIZE
azure-vote-front             latest     9cc914e25834        40 seconds ago      694MB
redis                        latest     a1b99da73d05        7 days ago          106MB
tiangolo/uwsgi-nginx-flask   flask      788ca94b2313        9 months ago        694MB

Zaloguj się do rejestru kontenerów platformy Azure.

az acr login -n <acrLoginServer>

Zastąp <acrLoginServer> swoim serwerem logowania ACR.

Użyj polecenia docker tag , aby oznaczyć obraz nazwą serwera logowania usługi ACR i numerem v1wersji . Użyj własnej <acrLoginServer> nazwy uzyskanej w poprzednim kroku:

docker tag azure-vote-front <acrLoginServer>/azure-vote-front:v1

Na koniec wypchnij obraz azure-vote-front do rejestru usługi ACR. Ponownie zastąp ciąg <acrLoginServer> nazwą serwera logowania własnego rejestru ACR, na przykład myacrregistry.azurecr.io:

docker push <acrLoginServer>/azure-vote-front:v1

Wdróż przykładową aplikację do AKS

Aby wdrożyć przykładową aplikację w klastrze usługi AKS, możesz użyć pliku manifestu Kubernetes w katalogu głównym repozytorium głosowania platformy Azure. Otwórz plik manifestu za pomocą edytora azure-vote-all-in-one-redis.yaml , takiego jak vi. Zastąp microsoft nazwą serwera logowania ACR. Ta wartość znajduje się w wierszu 60 pliku manifestu:

containers:
- name: azure-vote-front
  image: azuredocs/azure-vote-front

Następnie użyj polecenia kubectl apply , aby wdrożyć aplikację w klastrze usługi AKS:

kubectl apply -f azure-vote-all-in-one-redis.yaml

Usługa modułu równoważenia obciążenia Kubernetes jest tworzona w celu uwidocznienia aplikacji w Internecie. Proces może potrwać kilka minut. Aby monitorować postęp wdrażania modułu równoważenia obciążenia, użyj polecenia kubectl get service z argumentem --watch .

$ kubectl get service azure-vote-front --watch

Gdy adres EXTERNAL-IP zmieni się z oczekującego na adres IP, użyj Control + C, aby zatrzymać proces obserwacji kubectl.

NAME               TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE

Aby zobaczyć działanie aplikacji, otwórz przeglądarkę internetową na zewnętrzny adres IP usługi. Zostanie wyświetlona aplikacja do głosowania platformy Azure, jak pokazano w poniższym przykładzie:

Konfigurowanie kontrolera serwera Jenkins

Zastosuj następujące zmiany, aby włączyć wdrożenia usługi AKS z poziomu kontrolera Jenkins:

Otwórz port 80 przychodzący.

az vm open-port \
--resource-group <Resource_Group_name> \
--name <Jenkins_Controller_VM>  \
--port 80 --priority 1020

Zastąp <Resource_Group_name> i <Jenkins_Controller_VM> odpowiednimi wartościami.

Połączenie SSH z kontrolerem serwera Jenkins

ssh azureuser@<PublicIPAddress>

Zastąp <PublicIPAddress> adresem IP kontrolera Jenkins.

Instalowanie i logowanie się do modułu AzCLI

curl -L https://aka.ms/InstallAzureCli | bash

az login

Zainstaluj platformę Docker

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common -y;
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -;
sudo apt-key fingerprint 0EBFCD88;
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable";
sudo apt-get update;
sudo apt-get install docker-ce -y;

Instalowanie narzędzia Kubectl i nawiązywanie połączenia z usługą AKS

sudo az aks install-cli
sudo az aks get-credentials --resource-group <Resource_Group> --name <AKS_Name>

Zastąp <Resource_Group> i <AKS_Name> odpowiednimi wartościami.

Konfigurowanie dostępu

sudo usermod -aG docker jenkins;
sudo usermod -aG docker azureuser;
sudo touch /var/lib/jenkins/jenkins.install.InstallUtil.lastExecVersion;
sudo service jenkins restart;
sudo cp ~/.kube/config /var/lib/jenkins/.kube/
sudo chmod 777 /var/lib/jenkins/
sudo chmod 777 /var/lib/jenkins/config

Tworzenie zmiennej środowiskowej serwera Jenkins

Zmienna środowiskowa serwera Jenkins jest używana do przechowywania nazwy serwera logowania usługi ACR. Ta zmienna jest przywołyowana podczas zadania kompilacji narzędzia Jenkins. Aby utworzyć tę zmienną środowiskową, wykonaj następujące kroki:

• Po lewej stronie portalu serwera Jenkins wybierz pozycję Zarządzaj usługą Jenkins>Konfiguruj system

• W obszarze Właściwości globalne wybierz pozycję Zmienne środowiskowe. Dodaj zmienną o nazwie ACR_LOGINSERVER i wartości serwera logowania usługi ACR.

  

• Po zakończeniu wybierz pozycję Zapisz w dolnej części strony.

Utwórz poświadczenia Jenkins dla ACR

Podczas procesu ciągłej integracji/ciągłego wdrażania Jenkins tworzy nowe obrazy kontenerów na podstawie aktualizacji aplikacji, a następnie musi przesłać te obrazy do rejestru ACR.

Aby umożliwić usłudze Jenkins wypychanie zaktualizowanych obrazów kontenerów do ACR, należy określić dane uwierzytelniające dla ACR.

Aby oddzielić role i uprawnienia, skonfiguruj jednostkę usługi dla serwera Jenkins z uprawnieniami Współautor do rejestru usługi ACR.

Tworzenie jednostki usługi dla usługi Jenkins w celu używania usługi ACR

Najpierw utwórz podmiot usługi przy użyciu polecenia az ad sp create-for-rbac :

az ad sp create-for-rbac

To polecenie generuje dane wyjściowe podobne do następującego przykładu:

{
  "appId": "<app-ID>",
  "displayName": "azure-cli-2018-09-28-22-19-34",
  "name": "http://azure-cli-2018-09-28-22-19-34",
  "password": "<password>",
  "tenant": "<tenant-ID>"
}

Zanotuj identyfikator appId i hasło. Te wartości są używane w poniższych krokach, aby skonfigurować zasób poświadczeń w usłudze Jenkins.

Pobierz identyfikator zasobu rejestru usługi ACR przy użyciu polecenia az acr show i zapisz go jako zmienną.

ACR_ID=$(az acr show --resource-group <Resource_Group> --name <acrLoginServer> --query "id" --output tsv)

Zastąp <Resource_Group> i <acrLoginServer> odpowiednimi wartościami.

Utwórz przypisanie roli, aby przypisać uprawnienia Współtwórcy podmiotowi usługi do rejestru ACR.

az role assignment create --assignee <appID> --role Contributor --scope $ACR_ID

Zastąp <appId> wartością podaną w danych wyjściowych poprzedniego polecenia, aby utworzyć jednostkę usługi.

Utwórz zasób poświadczeń w Jenkins dla głównego użytkownika usługi ACR

Przypisanie roli utworzone na platformie Azure umożliwia teraz przechowywanie poświadczeń usługi ACR w obiekcie poświadczeń serwera Jenkins. Te poświadczenia są przywołyne podczas zadania kompilacji serwera Jenkins.

Po lewej stronie portalu Jenkins wybierz Zarządzaj Jenkins>Zarządzaj poświadczeniami>Sklep Jenkins>Poświadczenia globalne (bez ograniczeń)>Dodaj poświadczenia

Upewnij się, że rodzaj poświadczeń to Nazwa użytkownika z hasłem i wprowadź następujące elementy:

• Nazwa użytkownika — identyfikator aplikacji jednostki usługi utworzonej do uwierzytelniania za pomocą rejestru ACR.
• Hasło — hasło podmiotu usługi utworzonego do uwierzytelniania w rejestrze ACR.
• ID — identyfikator poświadczeń, taki jak acr-credentials

Po zakończeniu formularz poświadczeń wygląda następująco:

Wybierz przycisk OK i wróć do portalu narzędzia Jenkins.

Tworzenie projektu narzędzia Jenkins

Na stronie głównej portalu usługi Jenkins wybierz pozycję Nowy element po lewej stronie:

1. Wprowadź azure-vote jako nazwę zadania. Wybierz pozycję Projekt Freestyle, a następnie wybierz przycisk OK

2. W sekcji Ogólne wybierz Projekt GitHub i wprowadź adres URL sklonowanego repozytorium, taki jak https://github.com/<your-github-account>/azure-voting-app-redis

3. W sekcji Zarządzanie kodem źródłowym wybierz pozycję Git, wprowadź adres URL rozwidlenia repozytorium .git , taki jak https://github.com/<your-github-account>/azure-voting-app-redis.git

4. W sekcji Build Triggers (Wyzwalacze kompilacji) wybierz GitHub hook trigger for GITscm polling

5. W obszarze Środowisko kompilacji wybierz pozycję Użyj tajnych tekstów lub plików

6. W obszarze Powiązania wybierz pozycję Dodaj>nazwę użytkownika i hasło (oddzielone)

   • Wprowadź ACR_ID wartość dla zmiennej nazwy użytkownika i ACR_PASSWORDzmiennej hasła

     

7. Wybierz opcję dodania kroku kompilacji typu Uruchomienie powłoki i użyj następującego tekstu. Ten skrypt tworzy nowy obraz kontenera i wypycha go do rejestru usługi ACR.

   # Build new image and push to ACR.
   WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
   docker build -t $WEB_IMAGE_NAME ./azure-vote
   docker login ${ACR_LOGINSERVER} -u ${ACR_ID} -p ${ACR_PASSWORD}
   docker push $WEB_IMAGE_NAME
   

8. Dodaj kolejny etap budowania typu Wykonaj skrypt powłoki i użyj następującego tekstu. Ten skrypt aktualizuje wdrożenie aplikacji w usłudze AKS przy użyciu nowego obrazu kontenera z usługi ACR.

   # Update kubernetes deployment with new image.
   WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
   kubectl set image deployment/azure-vote-front azure-vote-front=$WEB_IMAGE_NAME
   

9. Po zakończeniu kliknij przycisk Zapisz.

Testowanie kompilacji narzędzia Jenkins

Przed zautomatyzowanie zadania na podstawie zatwierdzeń usługi GitHub ręcznie przetestuj kompilację serwera Jenkins.

Ta kompilacja sprawdza, czy zadanie zostało poprawnie skonfigurowane. Potwierdza ona, że jest prawidłowy plik uwierzytelniania Kubernetes i że uwierzytelnianie w usłudze ACR działa.

W menu po lewej stronie projektu wybierz pozycję Kompiluj teraz.

Pierwsza kompilacja trwa dłużej, gdy warstwy obrazu platformy Docker są ściągane na serwer Jenkins.

Kompilacje (buildy) wykonują następujące zadania:

1. Klonuje repozytorium GitHub
2. Tworzy nowy obraz kontenera
3. Wypycha obraz kontenera do rejestru ACR
4. Aktualizuje obraz używany przez wdrożenie usługi AKS

Ponieważ w kodzie aplikacji nie wprowadzono żadnych zmian, internetowy interfejs użytkownika jest niezmieniony.

Po zakończeniu zadania kompilacji wybierz pozycję kompilacja #1 w obszarze Historia kompilacji. Wybierz pozycję Dane wyjściowe konsoli i wyświetl dane wyjściowe z procesu kompilacji. Końcowy wiersz powinien wskazywać pomyślną kompilację.

Utwórz webhook GitHub

Po pomyślnym zakończeniu ręcznej kompilacji teraz zintegruj usługę GitHub z kompilacją serwera Jenkins. Użyj webhooka, aby uruchomić zadanie kompilacji Jenkins za każdym razem, gdy kod jest zatwierdzany w GitHub.

Aby utworzyć element webhook usługi GitHub, wykonaj następujące kroki:

1. Przejdź w przeglądarce internetowej do swojego zaforkowanego repozytorium GitHub.

2. Wybierz Ustawienia, a następnie wybierz Webhooki na lewej stronie.

3. Wybierz opcję Dodaj webhook. W polu Adres URL ładunku wprowadź http://<publicIp:8080>/github-webhook/, gdzie <publicIp> jest adresem IP serwera Jenkins. Pamiętaj, aby uwzględnić końcowe /. Pozostaw inne wartości domyślne dla typu zawartości i ustaw na wyzwalanie zdarzeń typu push.

4. Wybierz Dodaj webhook.

   

Testowanie kompletnego potoku ciągłej integracji/ciągłego wdrażania

Teraz możesz przetestować cały potok CI/CD. Podczas wypychania zatwierdzenia kodu do usługi GitHub są wykonywane następujące kroki:

1. Webhook GitHub powiadamia Jenkinsa.
2. Narzędzie Jenkins uruchamia zadanie kompilacji i ściąga najnowsze zatwierdzenie kodu z usługi GitHub.
3. Kompilacja platformy Docker jest uruchamiana przy użyciu zaktualizowanego kodu, a nowy obraz kontenera jest oznaczony najnowszym numerem kompilacji.
4. Ten nowy obraz kontenera jest wypychany do usługi Azure Container Registry.
5. Twoja aplikacja działająca w usłudze Azure Kubernetes Service jest aktualizowana za pomocą najnowszego obrazu z Azure Container Registry.

Na komputerze deweloperskim otwórz sklonowaną aplikację za pomocą edytora kodu. W katalogu /azure-vote/azure-vote otwórz plik o nazwie config_file.cfg. Zaktualizuj wartości głosowania w tym pliku na coś innego niż koty i psy, jak pokazano w poniższym przykładzie:

# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Blue'
VOTE2VALUE = 'Purple'
SHOWHOST = 'false'

Po zaktualizowaniu zapisz plik, zatwierdź zmiany i prześlij je do twojego forka repozytorium GitHub. Element webhook usługi GitHub wyzwala nowe zadanie kompilacji w usłudze Jenkins. Na pulpicie nawigacyjnym internetowym narzędzia Jenkins monitoruj proces kompilacji. Pobieranie najnowszego kodu, tworzenie i wypychanie zaktualizowanego obrazu oraz wdrażanie zaktualizowanej aplikacji w usłudze AKS trwa kilka sekund.

Po zakończeniu kompilacji odśwież przeglądarkę internetową przykładowej aplikacji do głosowania na platformie Azure. Zmiany są wyświetlane, jak pokazano w poniższym przykładzie:

Dalsze kroki