Lernprogramm: Bereitstellen von GitHub auf Azure Kubernetes Service mit Jenkins

In diesem Lernprogramm wird eine Beispiel-App von GitHub in einem Azure Kubernetes Service (AKS) -Cluster bereitgestellt, indem in Jenkins eine fortlaufende Integration (Continuous Integration, CI) und eine kontinuierliche Bereitstellung (CONTINUOUS Deployment, CD) eingerichtet wird.

Dieses Tutorial umfasst folgende Aufgaben:

Voraussetzungen

Um dieses Lernprogramm abzuschließen, benötigen Sie diese Elemente:

• Grundlegendes Verständnis von Kubernetes, Git, CI/CD und Containerimages

• Ein AKS-Cluster, konfiguriert mit den kubectl.

• Eine Azure Container Registry (ACR)-Registrierung, der ACR-Anmeldeservername und der AKS-Cluster, der für die AUTHENTIFIZIERUNG mit der ACR-Registrierung konfiguriert ist.

• Ein Jenkins-Controller, der auf einem virtuellen Azure-Computer bereitgestellt wird.

• Die Azure CLI-Version 2.0.46 oder höher ist installiert und konfiguriert. Führen Sie az --version aus, um die Version zu ermitteln. Wenn Sie eine Installation oder ein Upgrade durchführen müssen, finden Sie weitere Informationen unter Azure CLI installieren.

• Docker auf Ihrem Entwicklungssystem installiert

• Ein GitHub-Konto, GitHub-Zugriffstoken und Git-Client, der auf Ihrem Entwicklungssystem installiert ist

• Wenn Sie Ihre eigene Jenkins-Instanz anstelle dieser skriptbasierten Methode zum Bereitstellen von Jenkins bereitstellen, muss Ihre Jenkins-Instanz Docker installiert und konfiguriert sowie kubectl haben.

Vorbereiten Ihrer App

In diesem Artikel verwenden Sie eine Azure-Beispiel-Abstimmungsanwendung, die eine Webschnittstelle und Redis für die temporäre Datenspeicherung enthält.

Bevor Sie Jenkins und AKS für automatisierte Bereitstellungen integrieren, bereiten Sie zuerst die Azure-Abstimmungsanwendung manuell vor und stellen sie in Ihrem AKS-Cluster bereit. Mit dieser manuellen Bereitstellung können Sie die Anwendung in Aktion sehen.

Klonen Sie das folgende GitHub-Repository für die Musteranwendung - https://github.com/Azure-Samples/azure-voting-app-redis. Um das Repository in Ihr eigenes GitHub-Konto zu "forken", wählen Sie die Schaltfläche "Fork" oben rechts aus.

Klonen Sie den Fork in Ihr Entwicklungssystem. Stellen Sie sicher, dass Sie beim Klonen dieses Repositorys die URL Ihres Forks verwenden.

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

Wechseln Sie in das Verzeichnis Ihres geklonten Forks:

cd azure-voting-app-redis

Verwenden Sie zum Erstellen der containerimages, die für die Beispielanwendung erforderlich sind, die Datei docker-compose.yaml mit docker-compose:

docker-compose up -d

Die erforderlichen Basisimages werden abgerufen und die Anwendungscontainer erstellt. Anschließend können Sie den Befehl "Docker-Images " verwenden, um das erstellte Image anzuzeigen. Es wurden drei Bilder heruntergeladen oder erstellt. Das azure-vote-front-Bild enthält die Anwendung und verwendet das nginx-flask Image als Basis. Das redis Bild wird verwendet, um eine Redis-Instanz zu starten:

$ 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

Melden Sie sich bei Ihrer Azure-Containerregistrierung an.

az acr login -n <acrLoginServer>

Ersetzen Sie <acrLoginServer> durch Ihren ACR-Anmeldeserver.

Verwenden Sie den Docker-Tag-Befehl , um das Image mit dem ACR-Anmeldeservernamen und einer Versionsnummer zu v1markieren. Verwenden Sie Ihren eigenen <acrLoginServer> Namen, der im vorherigen Schritt abgerufen wurde:

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

Verschieben Sie schließlich das Azure-Vote-Front-Image in Ihre ACR-Registrierung . Ersetzen Sie <acrLoginServer> erneut durch den Anmeldeservernamen Ihrer eigenen ACR-Registrierung, zum Beispiel myacrregistry.azurecr.io.

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

Bereitstellen der Beispielanwendung für AKS

Um die Beispielanwendung für Ihren AKS-Cluster bereitzustellen, können Sie die Kubernetes-Manifestdatei im Stammverzeichnis des Azure-Abstimmungs-Repository-Repositorys verwenden. Öffnen Sie die azure-vote-all-in-one-redis.yaml-Manifestdatei mit einem Editor, z. B. vi. Ersetzen Sie microsoft durch den Namen Ihres ACR-Anmeldeservers. Dieser Wert befindet sich in Zeile 60 der Manifestdatei:

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

Verwenden Sie als Nächstes den Befehl "kubectl anwenden ", um die Anwendung auf Ihrem AKS-Cluster bereitzustellen:

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

Ein Kubernetes-Lastenausgleichsdienst wird erstellt, um die Anwendung für das Internet verfügbar zu machen. Dieser Prozess kann einige Minuten in Anspruch nehmen. Um den Fortschritt der Bereitstellung des Load Balancers zu überwachen, verwenden Sie den Befehl "kubectl get service" mit dem --watch Argument.

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

Nachdem die EXTERNAL-IP-Adresse von "Ausstehend " in eine IP-Adresse geändert wurde, können Sie Control + C den Kubectl-Überwachungsvorgang beenden.

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

Um die Anwendung in Aktion zu sehen, öffnen Sie einen Webbrowser mit der externen IP-Adresse Ihres Diensts. Die Azure-Abstimmungsanwendung wird angezeigt, wie im folgenden Beispiel gezeigt:

Konfigurieren des Jenkins-Controllers

Wenden Sie die folgenden Änderungen an, um AKS-Bereitstellungen vom Jenkins Controller zu aktivieren:

Port 80 für eingehenden Verkehr öffnen.

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

Ersetzen Sie <Resource_Group_name> und <Jenkins_Controller_VM> durch die entsprechenden Werte.

SSH zum Jenkins Controller

ssh azureuser@<PublicIPAddress>

Ersetzen Sie <PublicIPAddress> mit der IP-Adresse des Jenkins-Controllers.

Installieren & Anmelden bei AzCLI

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

az login

Installieren von 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;

Installieren von Kubectl und Herstellen einer Verbindung mit AKS

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

Ersetzen Sie <Resource_Group> und <AKS_Name> durch die entsprechenden Werte.

Konfigurieren des Zugriffs

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

Erstellen einer Jenkins-Umgebungsvariable

Eine Jenkins-Umgebungsvariable wird verwendet, um den ACR-Anmeldeservernamen zu enthalten. Auf diese Variable wird während des Jenkins-Buildauftrags verwiesen. Führen Sie die folgenden Schritte aus, um diese Umgebungsvariable zu erstellen:

• Wählen Sie auf der linken Seite des Jenkins-Portals "Jenkins>Configure System verwalten" aus.

• Wählen Sie unter "Globale Eigenschaften" die Option "Umgebungsvariablen" aus. Fügen Sie eine Variable mit dem Namen ACR_LOGINSERVER und dem Wert Ihres ACR-Anmeldeservers hinzu.

  

• Wenn sie abgeschlossen ist, wählen Sie unten auf der Seite "Speichern" aus.

Erstellen einer Jenkins-Anmeldeinformation für ACR

Während des CI/CD-Prozesses erstellt Jenkins neue Containerimages basierend auf Anwendungsupdates und muss diese Images dann an die ACR-Registrierung übertragen .

Damit Jenkins aktualisierte Containerimages an ACR pushen kann, müssen Sie Anmeldeinformationen für ACR angeben.

Konfigurieren Sie für die Trennung von Rollen und Berechtigungen einen Dienstprinzipal für Jenkins mit Mitwirkendenberechtigungen für Ihre ACR-Registrierung.

Erstellen eines Service Principals für Jenkins für die Verwendung von ACR

Erstellen Sie zunächst einen Dienstprinzipal und nutzen Sie den Befehl az ad sp create-for-rbac.

az ad sp create-for-rbac

Dieser Befehl erzeugt eine Ausgabe ähnlich wie im folgenden Beispiel:

{
  "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>"
}

Notieren Sie sich die appId und das Kennwort. Diese Werte werden in den folgenden Schritten verwendet, um die Anmeldeinformationsressource in Jenkins zu konfigurieren.

Rufen Sie die Ressourcen-ID Ihrer ACR-Registrierung mit dem Befehl az acr show ab, und speichern Sie sie als Variable.

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

Ersetzen Sie <Resource_Group> und <acrLoginServer> durch die entsprechenden Werte.

Erstellen Sie eine Rollenzuweisung, um dem Dienstprinzipal die Mitwirkungsrechte am ACR-Register zuzuweisen.

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

Ersetzen Sie <appId> durch den Wert, der in der Ausgabe des vorherigen Befehls zum Erstellen des Dienstprinzipals bereitgestellt wird.

Erstellen einer Anmeldeinformationsressource in Jenkins für den ACR-Dienstprinzipal

Mit der in Azure erstellten Rollenzuweisung speichern Sie jetzt Ihre ACR-Anmeldeinformationen in einem Jenkins-Anmeldeinformationsobjekt. Auf diese Anmeldeinformationen wird während des Jenkins-Buildauftrags verwiesen.

Wählen Sie auf der linken Seite des Jenkins-Portals Manage Jenkins>Manage Credentials>Jenkins Store>Globale Anmeldeinformationen (uneingeschränkt)>Anmeldeinformationen hinzufügen aus.

Stellen Sie sicher, dass die Art der Anmeldeinformationen Benutzername mit Kennwort ist, und geben Sie die folgenden Elemente ein:

• Benutzername – Die appId des Dienstprinzipals, der für die Authentifizierung mit Ihrer ACR-Registrierung erstellt wurde.
• Kennwort - Das Kennwort des Dienstprinzipals, der für die Authentifizierung mit Ihrem ACR Registry erstellt wurde.
• ID – Anmeldeinformationsbezeichner wie acr-credentials

Nachdem das Anmeldeformular ausgefüllt wurde, sieht es wie im folgenden Beispiel aus:

Wählen Sie "OK" aus, und kehren Sie zum Portal "Jenkins" zurück.

Erstellen eines Jenkins-Projekts

Wählen Sie auf der Startseite Ihres Jenkins-Portals auf der linken Seite " Neues Element " aus:

1. Geben Sie azure-vote als Auftragsname ein. Wählen Sie Freestyle-Projekt und dann OK aus.

2. Wählen Sie im Abschnitt Allgemein das GitHub-Projekt aus und geben Sie die URL Ihres geforkten Repositories ein, z. B. https://github.com/<Ihr-GitHub-Konto>/azure-voting-app-redis.

3. Wählen Sie im Abschnitt QuellcodeverwaltungGit und geben Sie Ihre Fork-Repository-URL .git ein, z. B. https://github.com/<Ihr-github-konto>/azure-voting-app-redis.git

4. Wählen Sie im Abschnitt "Buildtrigger"den GitHub-Hook-Trigger für GITscm-Abrufe aus.

5. Wählen Sie unter "Buildumgebung" die Option "Geheime Texte oder Dateien verwenden" aus.

6. Wählen Sie unter "Bindungen"> hinzufügen" (getrennt) aus.

   • Geben Sie die Eingabe ACR_ID für die Benutzernamevariable und ACR_PASSWORD die Kennwortvariable ein.

     

7. Wählen Sie aus, ob Sie einen Build-Schritt vom Typ Execute shell hinzufügen möchten und verwenden Sie den folgenden Text. Dieses Skript erstellt ein neues Containerimage und verschiebt es an Ihre ACR-Registrierung.

   # 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. Fügen Sie einen weiteren Buildschritt vom Typ Shell ausführen hinzu und verwenden Sie den folgenden Text. Dieses Skript aktualisiert die Anwendungsbereitstellung in AKS mit dem neuen Containerimage von 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. Klicken Sie nach Abschluss auf "Speichern".

Testen des Jenkins-Builds

Bevor Sie den Auftrag basierend auf GitHub-Commits automatisieren, testen Sie den Jenkins-Build manuell.

Dieser Build überprüft, ob der Auftrag ordnungsgemäß konfiguriert wurde. Es bestätigt, dass die richtige Kubernetes-Authentifizierungsdatei vorhanden ist und dass die Authentifizierung bei ACR funktioniert.

Wählen Sie im linken Menü des Projekts " Jetzt erstellen" aus.

Der erste Build länger, da die Docker-Imageebenen auf den Jenkins-Server heruntergezogen werden.

Die Builds führen die folgenden Aufgaben aus:

1. Klonen des GitHub-Repositorys
2. Erstellt ein neues Containerimage
3. Überträgt das Container-Image in die ACR-Registry.
4. Aktualisiert das Image, das von der AKS-Deployment verwendet wird.

Da am Anwendungscode keine Änderungen vorgenommen wurden, ist die Webbenutzeroberfläche unverändert.

Nachdem der Buildauftrag abgeschlossen ist, wählen Sie Build Nr. 1 unter Build-Historie aus. Wählen Sie die Konsolenausgabe aus, und zeigen Sie die Ausgabe aus dem Buildprozess an. Die letzte Zeile sollte auf einen erfolgreichen Build hinweisen.

Erstellen eines GitHub-Webhooks

Mit einem erfolgreichen manuellen Build integrieren Sie nun GitHub in den Jenkins-Build. Verwenden Sie einen Webhook, um den Jenkins-Buildauftrag bei jedem Commit von Code auf GitHub auszuführen.

Führen Sie die folgenden Schritte aus, um den GitHub-Webhook zu erstellen:

1. Navigieren Sie in einem Webbrowser zu Ihrem geforkten GitHub-Repository.

2. Wählen Sie "Einstellungen" und dann " Webhooks " auf der linken Seite aus.

3. Wählen Sie " Webhook hinzufügen" aus. Für die Nutzlast-URL geben Sie http://<publicIp:8080>/github-webhook/ ein, wobei <publicIp> die IP-Adresse des Jenkins-Servers ist. Stellen Sie sicher, dass Sie das nachgestellte / einschließen. Lassen Sie die anderen Standardwerte für den Inhaltstyp unverändert und bei Auslösen von Push-Ereignissen.

4. Wählen Sie "Webhook hinzufügen" aus.

   

Testen der vollständigen CI/CD-Pipeline

Jetzt können Sie die gesamte CI/CD-Pipeline testen. Wenn Sie einen Code-Commit an GitHub übertragen, werden die folgenden Schritte ausgeführt:

1. Der GitHub-Webhook benachrichtigt Jenkins.
2. Jenkins startet den Buildauftrag und ruft den neuesten Code-Commit von GitHub ab.
3. Ein Docker-Build wird mit dem aktualisierten Code gestartet, und das neue Containerimage wird mit der neuesten Buildnummer markiert.
4. Dieses neue Containerimage wird an die Azure-Containerregistrierung übertragen.
5. Ihre auf Azure Kubernetes Service ausgeführte Anwendung wird mit dem neuesten Image aus der Azure Container Registry aktualisiert.

Öffnen Sie auf Ihrem Entwicklungscomputer die geklonte Anwendung mit einem Code-Editor. Öffnen Sie im Verzeichnis "/azure-vote/azure-vote " die Datei mit dem Namen config_file.cfg. Aktualisieren Sie die Abstimmungswerte in dieser Datei auf etwas anderes als Katzen und Hunde, wie im folgenden Beispiel gezeigt:

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

Speichern Sie die Datei, committen Sie die Änderungen, und übertragen Sie sie an Ihren Fork des GitHub-Repositorys. Der GitHub-Webhook löst einen neuen Buildauftrag in Jenkins aus. Überwachen Sie im Jenkins-Webdashboard den Buildprozess. Es dauert ein paar Sekunden, den neuesten Code abzurufen, das aktualisierte Image zu erstellen und zu übertragen und die aktualisierte Anwendung in AKS bereitzustellen.

Nachdem der Build abgeschlossen ist, aktualisieren Sie Ihren Webbrowser der Azure-Beispiel-Abstimmungsanwendung. Ihre Änderungen werden angezeigt, wie im folgenden Beispiel gezeigt:

Nächste Schritte