Tutorial: Bereitstellen über GitHub in Azure Kubernetes Service mit JenkinsTutorial: Deploy from GitHub to Azure Kubernetes Service using Jenkins

In diesem Tutorial werden Continuous Integration (CI) und Continuous Deployment (CD) in Jenkins eingerichtet, um eine Beispiel-App aus GitHub in einem Azure Kubernetes Service (AKS)-Cluster bereitzustellen.This tutorial deploys a sample app from GitHub to an Azure Kubernetes Service (AKS) cluster by setting up continuous integration (CI) and continuous deployment (CD) in Jenkins. Auf diese Weise führt Jenkins, wenn Sie Ihre App durch Pushen von Commits an GitHub aktualisieren, automatisch einen neuen Containerbuild aus, überträgt Container-Images an Azure Container Registry (ACR), und führt dann Ihre App in AKS aus.That way, when you update your app by pushing commits to GitHub, Jenkins automatically runs a new container build, pushes container images to Azure Container Registry (ACR), and then runs your app in AKS.

Dieses Tutorial umfasst folgende Aufgaben:In this tutorial, you'll complete these tasks:

  • Bereitstellen einer Azure-Beispielabstimmungs-App in einem AKS-Cluster.Deploy a sample Azure vote app to an AKS cluster.
  • Erstellen eines einfachen Jenkins-Projekts.Create a basic Jenkins project.
  • Einrichten von Jenkins-Anmeldeinformationen für die Interaktion mit ACR.Set up credentials for Jenkins to interact with ACR.
  • Erstellen eines Jenkins-Buildauftrags und GitHub-Webhooks für automatisierte Builds.Create a Jenkins build job and GitHub webhook for automated builds.
  • Testen der CI/CD-Pipeline zum Aktualisieren einer Anwendung in AKS basierend auf GitHub-Codecommits.Test the CI/CD pipeline to update an application in AKS based on GitHub code commits.

VoraussetzungenPrerequisites

Für dieses Tutorial benötigen Sie Folgendes:To complete this tutorial, you need these items:

Vorbereiten Ihrer AppPrepare your app

In diesem Artikel verwenden Sie eine Azure-Abstimmungsanwendung, die eine in einem oder mehreren Pods gehostete Webschnittstelle und einen zusätzlichen Pod für die temporäre Datenspeicherung enthält.In this article, you use a sample Azure vote application that contains a web interface hosted in one or more pods, and a second pod hosting Redis for temporary data storage. Bevor Sie Jenkins und AKS für automatisierte Bereitstellungen integrieren, müssen Sie zuerst manuell die Azure-Abstimmungsanwendung in Ihrem AKS-Cluster vorbereiten und bereitstellen.Before you integrate Jenkins and AKS for automated deployments, first manually prepare and deploy the Azure vote application to your AKS cluster. Diese manuelle Bereitstellung ist die erste Version der Anwendung und ermöglicht Ihnen, die Anwendung in Aktion zu sehen.This manual deployment is version one of the application, and lets you see the application in action.

Hinweis

Die Azure-Beispielabstimmungsanwendung verwendet einen Linux-Pod, der zur Ausführung auf einem Linux-Knoten geplant wird.The sample Azure vote application uses a Linux pod that is scheduled to run on a Linux node. Der in diesem Artikel beschriebene Flow funktioniert auch für einen Windows Server-Pod, der für einen Windows Server-Knoten geplant ist.The flow outlined in this article also works for a Windows Server pod scheduled on a Windows Server node.

Forken Sie das folgende GitHub-Repository für die Beispielanwendung: https://github.com/Azure-Samples/azure-voting-app-redis.Fork the following GitHub repository for the sample application - https://github.com/Azure-Samples/azure-voting-app-redis. Wählen Sie die Schaltfläche Fork (Verzweigen) in der rechten oberen Ecke aus, um das Repository in Ihr GitHub-Konto zu verzweigen.To fork the repo to your own GitHub account, select the Fork button in the top right-hand corner.

Klonen Sie den Fork in Ihrem Entwicklungssystem.Clone the fork to your development system. Stellen Sie sicher, dass Sie beim Klonen dieses Repositorys die URL Ihres Forks verwenden:Make sure you use the URL of your fork when cloning this repo:

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

Wechseln Sie zum Verzeichnis Ihres geklonten Forks:Change to the directory of your cloned fork:

cd azure-voting-app-redis

Um die für die Beispielanwendung erforderlichen Containerimages zu erstellen, verwenden Sie die Datei docker-compose.yaml mit docker-compose:To create the container images needed for the sample application, use the docker-compose.yaml file with docker-compose:

docker-compose up -d

Die erforderlichen Basisimages werden gepullt, und die Anwendungscontainer werden erstellt.The required base images are pulled and the application containers built. Das erstellte Image kann anschließend mithilfe des Befehls docker-images angezeigt werden.You can then use the docker images command to see the created image. Drei Images wurden heruntergeladen oder erstellt.Three images have been downloaded or created. Das azure-vote-front-Image enthält die Anwendung und verwendet das nginx-flask-Image als Grundlage.The azure-vote-front image contains the application and uses the nginx-flask image as a base. Das redis-Image wird zum Starten einer Redis-Instanz verwendet:The redis image is used to start a Redis instance:

$ 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

Bevor Sie das Containerimage azure-vote-front an ACR pushen können, müssen Sie mithilfe des Befehls az acr list Ihren ACR-Anmeldeserver abrufen.Before you can push the azure-vote-front container image to ACR, get your ACR login server with the az acr list command. Im folgenden Beispiel wird die ACR-Anmeldeserveradresse für eine Registrierung in der Ressourcengruppe myResourceGroup abgerufen:The following example gets the ACR login server address for a registry in the resource group named myResourceGroup:

az acr list --resource-group myResourceGroup --query "[].{acrLoginServer:loginServer}" --output table

Verwenden Sie den Befehl docker tag, um das Image mit dem ACR-Anmeldeservernamen und der Versionsnummer v1 zu versehen.Use the docker tag command to tag the image with the ACR login server name and a version number of v1. Geben Sie Ihren eigenen <acrLoginServer>-Namen an, den Sie im vorherigen Schritt erhalten haben:Provide your own <acrLoginServer> name obtained in the previous step:

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

Pushen Sie das Image azure-vote-front schließlich in Ihre ACR-Registrierung.Finally, push the azure-vote-front image to your ACR registry. Ersetzen Sie erneut <acrLoginServer> durch den Anmeldeservernamen Ihrer eigenen ACR, z.B. myacrregistry.azurecr.io:Again, replace <acrLoginServer> with the login server name of your own ACR registry, such as myacrregistry.azurecr.io:

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

Bereitstellen der Beispielanwendung in AKSDeploy the sample application to AKS

Zum Bereitstellen der Beispielanwendung in Ihrem AKS-Cluster können Sie die Kubernetes-Manifestdatei im Stammverzeichnis des Repositorys der Azure-Abstimmungsanwendung verwenden.To deploy the sample application to your AKS cluster, you can use the Kubernetes manifest file in the root of the Azure vote repository repo. Öffnen Sie die Manifestdatei azure-vote-all-in-one-redis.yaml in einem Editor wie vi.Open the azure-vote-all-in-one-redis.yaml manifest file with an editor such as vi. Ersetzen Sie microsoft durch Ihren ACR-Anmeldeservernamen.Replace microsoft with your ACR login server name. Dieser Wert befindet sich in Zeile 47 der Manifestdatei:This value is found on line 47 of the manifest file:

containers:
- name: azure-vote-front
  image: microsoft/azure-vote-front:v1

Stellen Sie als Nächstes die Anwendung mithilfe des Befehls kubectl apply in Ihrem AKS-Cluster bereit:Next, use the kubectl apply command to deploy the application to your AKS cluster:

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

Es wird ein Kubernetes-Lastenausgleichsdienst erstellt, um die Anwendung im Internet verfügbar zu machen.A Kubernetes load balancer service is created to expose the application to the internet. Dieser Vorgang kann einige Minuten dauern.This process can take a few minutes. Verwenden Sie den Befehl kubectl get service mit dem Argument --watch, um den Fortschritt der Bereitstellung des Lastenausgleichs zu überwachen.To monitor the progress of the load balancer deployment, use the kubectl get service command with the --watch argument. Sobald die externe IP-Adresse nicht mehr ausstehend ist, sondern eine IP-Adresse angezeigt wird, verwenden Sie Control + C, um die kubectl-Überwachung zu beenden.Once the EXTERNAL-IP address has changed from pending to an IP address, use Control + C to stop the kubectl watch process.

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

NAME               TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.215.27   <pending>     80:30747/TCP   22s
azure-vote-front   LoadBalancer   10.0.215.27   40.117.57.239   80:30747/TCP   2m

Öffnen Sie die externe IP-Adresse Ihres Diensts in einem Webbrowser, um die Anwendung in Aktion zu sehen.To see the application in action, open a web browser to the external IP address of your service. Ihre Azure-Abstimmungsanwendung wird wie im folgenden Beispiel angezeigt:The Azure vote application is displayed, as shown in the following example:

Beispiel für eine in AKS ausgeführte Azure-Abstimmungsanwendung

Bereitstellen von Jenkins auf einer Azure-VMDeploy Jenkins to an Azure VM

Zum schnellen Bereitstellen von Jenkins zur Verwendung in diesem Artikel können Sie mit dem folgenden Skript einen virtuellen Azure-Computer bereitstellen, den Zugriff auf das Netzwerk konfigurieren und eine einfache Installation von Jenkins abschließen.To quickly deploy Jenkins for use in this article, you can use the following script to deploy an Azure virtual machine, configure network access, and complete a basic installation of Jenkins. Zur Authentifizierung zwischen Jenkins und dem AKS-Cluster kopiert das Skript Ihre Kubernetes-Konfigurationsdatei von Ihrem Entwicklungssystem auf das Jenkins-System.For authentication between Jenkins and the AKS cluster, the script copies your Kubernetes configuration file from your development system to the Jenkins system.

Warnung

Dieses Beispielskript ist für Demozwecke bestimmt, um schnell eine auf einer Azure-VM ausgeführte Jenkins-Umgebung bereitzustellen.This sample script is for demo purposes to quickly provision a Jenkins environment that runs on an Azure VM. Hierbei wird die benutzerdefinierte Azure-Skripterweiterung verwendet, um eine VM zu konfigurieren und dann die erforderlichen Anmeldeinformationen anzuzeigen.It uses the Azure custom script extension to configure a VM and then display the required credentials. Ihre ~/.kube/config wird auf die Jenkins-VM kopiert.Your ~/.kube/config is copied to the Jenkins VM.

Führen Sie die folgenden Befehle aus, um das Skript herunterzuladen und auszuführen.Run the following commands to download and run the script. Sie sollten den Inhalt jedes Skripts vor der Ausführung überprüfen: https://raw.githubusercontent.com/Azure-Samples/azure-voting-app-redis/master/jenkins-tutorial/deploy-jenkins-vm.sh.You should review the contents of any script prior to running it - https://raw.githubusercontent.com/Azure-Samples/azure-voting-app-redis/master/jenkins-tutorial/deploy-jenkins-vm.sh.

curl https://raw.githubusercontent.com/Azure-Samples/azure-voting-app-redis/master/jenkins-tutorial/deploy-jenkins-vm.sh > azure-jenkins.sh
sh azure-jenkins.sh

Es dauert einige Minuten, bis die VM erstellt und die erforderlichen Komponenten für Docker und Jenkins bereitgestellt wurden.It takes a few minutes to create the VM and deploy the required components for Docker and Jenkins. Wenn das Skript abgeschlossen ist, gibt es eine Adresse für den Jenkins-Server und einen Schlüssel zum Entsperren des Dashboards aus, wie in der folgenden Beispielausgabe gezeigt:When the script has completed, it outputs an address for the Jenkins server and a key to unlock the dashboard, as shown in the following example output:

Open a browser to http://40.115.43.83:8080
Enter the following to Unlock Jenkins:
667e24bba78f4de6b51d330ad89ec6c6

Öffnen Sie einen Webbrowser mit der angezeigten URL, und geben Sie den Entsperrschlüssel ein.Open a web browser to the URL displayed and enter the unlock key. Befolgen Sie die angezeigten Aufforderungen, um die Jenkins-Konfiguration abzuschließen:Follow the on-screen prompts to complete the Jenkins configuration:

  • Wählen Sie Install suggested plugins (Vorgeschlagene Plug-Ins installieren) aus.Choose Install suggested plugins
  • Erstellen Sie den ersten Administratorbenutzer.Create the first admin user. Geben Sie einen Benutzernamen (z.B. azureuser) und anschließend ein eigenes sicheres Kennwort ein.Enter a username, such as azureuser, then provide your own secure password. Geben Sie abschließend einen vollständigen Namen und eine E-Mail-Adresse an.Finally, type a full name and e-mail address.
  • Klicken Sie auf Speichern und Beenden.Select Save and Finish
  • Klicken Sie auf Start using Jenkins (Jenkins verwenden), sobald Jenkins bereit ist.Once Jenkins is ready, select Start using Jenkins
    • Sollte in Ihrem Browser beim Start von Jenkins eine leere Seite angezeigt werden, starten Sie den Jenkins-Dienst neu.If your web browser displays a blank page when you start using Jenkins, restart the Jenkins service. Um den Dienst neu zu starten, öffnen Sie mit SSH eine Verbindung mit der öffentlichen IP-Adresse Ihrer Jenkins-Instanz, und geben Sie sudo service jenkins restart ein.To restart the service, SSH to the public IP address of your Jenkins instance and type sudo service jenkins restart. Aktualisieren Sie nach dem Neustart des Diensts Ihren Webbrowser.Once the service has restarted, refresh you web browser.
  • Melden Sie sich mit dem Benutzernamen und dem Kennwort, die Sie während der Installation erstellt haben, bei Jenkins an.Sign in to Jenkins with the username and password you created in the install process.

Erstellen einer Jenkins-UmgebungsvariableCreate a Jenkins environment variable

Eine Jenkins-Umgebungsvariable wird verwendet, um den Namen des ACR-Anmeldeservers zu speichern.A Jenkins environment variable is used to hold the ACR login server name. Auf diese Variable wird während der Ausführung eines Jenkins-Buildauftrags verwiesen.This variable is referenced during the Jenkins build job. Erstellen Sie diese Umgebungsvariable anhand der folgenden Schritte:To create this environment variable, complete the following steps:

  • Wählen Sie auf der linken Seite des Jenkins-Portals Manage Jenkins (Jenkins verwalten) > Configure System (System konfigurieren) aus.On the left-hand side of the Jenkins portal, select Manage Jenkins > Configure System

  • Wählen Sie unter Global Properties (Globale Eigenschaften) die Option Environment variables (Umgebungsvariablen) aus.Under Global Properties, select Environment variables. Fügen Sie eine Variable mit dem Namen ACR_LOGINSERVER und Ihrem ACR-Anmeldeserver als Wert hinzu.Add a variable with the name ACR_LOGINSERVER and the value of your ACR login server.

    Jenkins-Umgebungsvariablen

  • Klicken Sie nach Abschluss des Vorgangs unten auf der Seite für die Jenkins-Konfiguration auf Save (Speichern).When complete, click Save at the bottom of the Jenkins configuration page.

Erstellen von Jenkins-Anmeldeinformationen für ACRCreate a Jenkins credential for ACR

Um Jenkins das Erstellen aktualisierter Containerimages und das anschließende Pushen an ACR zu ermöglichen, müssen Sie Anmeldeinformationen für ACR angeben.To allow Jenkins to build and then push updated container images to ACR, you need to specify credentials for ACR. Für diese Authentifizierung können Azure Active Directory-Dienstprinzipale verwendet werden.This authentication can use Azure Active Directory service principals. In den Voraussetzungen haben Sie den Dienstprinzipal für Ihren AKS-Cluster mit den Berechtigungen Leser in Ihrer ACR-Registrierung konfiguriert.In the pre-requisites, you configured the service principal for your AKS cluster with Reader permissions to your ACR registry. Durch diese Berechtigungen kann der AKS-Cluster Images aus der ACR-Registrierung pullen.These permissions allow the AKS cluster to pull images from the ACR registry. Während des CI/CD-Vorgangs erstellt Jenkins neue Containerimages basierend auf Anwendungsupdates. Diese müssen dann in die ACR-Registrierung gepusht werden.During the CI/CD process, Jenkins builds new container images based on application updates, and needs to then push those images to the ACR registry. Konfigurieren Sie für die Trennung von Rollen und Berechtigungen nun einen Dienstprinzipal für Jenkins mit den Berechtigungen Mitwirkender in Ihrer ACR.For separation of roles and permissions, now configure a service principal for Jenkins with Contributor permissions to your ACR registry.

Erstellen eines Dienstprinzipals für die Verwendung von ACR durch JenkinsCreate a service principal for Jenkins to use ACR

Erstellen Sie als Erstes mithilfe des Befehls az ad sp create-for-rbac einen Dienstprinzipal:First, create a service principal using the az ad sp create-for-rbac command:

$ az ad sp create-for-rbac --skip-assignment

{
  "appId": "626dd8ea-042d-4043-a8df-4ef56273670f",
  "displayName": "azure-cli-2018-09-28-22-19-34",
  "name": "http://azure-cli-2018-09-28-22-19-34",
  "password": "1ceb4df3-c567-4fb6-955e-f95ac9460297",
  "tenant": "72f988bf-86f1-41af-91ab-2d7cd011db48"
}

Notieren Sie sich die Werte appId und password in der Ausgabe.Make a note of the appId and password shown in your output. Diese Werte werden in den folgenden Schritten zum Konfigurieren der Anmeldeinformationsressource in Jenkins verwendet.These values are used in following steps to configure the credential resource in Jenkins.

Rufen Sie mithilfe des Befehls az acr show die Ressourcen-ID Ihrer ACR-Registrierung ab, und speichern Sie sie als Variable.Get the resource ID of your ACR registry using the az acr show command, and store it as a variable. Geben Sie Ihren Ressourcengruppennamen und den ACR-Namen an:Provide your resource group name and ACR name:

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

Erstellen Sie nun eine Rollenzuweisung, um den Dienstprinzipal die Berechtigungen Mitwirkender für die ACR zuzuweisen.Now create a role assignment to assign the service principal Contributor rights to the ACR registry. Geben Sie im folgenden Beispiel Ihre eigene appId an, die in der Ausgabe eines vorherigen Befehl aufgeführt wurde, um den Dienstprinzipal zu erstellen:In the following example, provide your own appId shown in the output a previous command to create the service principal:

az role assignment create --assignee 626dd8ea-042d-4043-a8df-4ef56273670f --role Contributor --scope $ACR_ID

Erstellen einer Anmeldeinformationsressource in Jenkins für den ACR-DienstprinzipalCreate a credential resource in Jenkins for the ACR service principal

Nachdem die Rollenzuweisung in Azure erstellt wurde, speichern Sie nun Ihre ACR-Anmeldeinformationen in einem Jenkins-Anmeldeinformationsobjekt.With the role assignment created in Azure, now store your ACR credentials in a Jenkins credential object. Auf diese Anmeldeinformationen wird während eines Jenkins-Erstellungsauftrags verwiesen.These credentials are referenced during the Jenkins build job.

Klicken Sie links im Jenkins-Portal auf Credentials (Anmeldeinformationen) > Jenkins > Global credentials (unrestricted) (Globale Anmeldeinformationen (nicht eingeschränkt)) > Add Credentials (Anmeldeinformationen hinzufügen) .Back on the left-hand side of the Jenkins portal, click Credentials > Jenkins > Global credentials (unrestricted) > Add Credentials

Stellen Sie sicher, dass als Typ für die Anmeldeinformationen Username with password ausgewählt ist, und geben Sie Folgendes ein:Ensure that the credential kind is Username with password and enter the following items:

  • Username (Benutzername): appId des für die Authentifizierung bei Ihrer ACR-Registrierung erstellten Dienstprinzipals.Username - The appId of the service principal created for authentication with your ACR registry.
  • Password (Kennwort): password des für die Authentifizierung bei Ihrer ACR-Registrierung erstellten Dienstprinzipals.Password - The password of the service principal created for authentication with your ACR registry.
  • ID: Bezeichner für die Anmeldeinformationen, z.B. acr-credentialsID - Credential identifier such as acr-credentials

Nach Abschluss des Vorgangs ähnelt das Formular für die Anmeldeinformationen etwa dem folgenden Beispiel:When complete, the credentials form looks like the following example:

Erstellen eines Jenkins-Anmeldeinformationsobjekts mit den Dienstprinzipalinformationen

Klicken Sie auf OK, und kehren Sie zum Jenkins-Portal zurück.Click OK and return to the Jenkins portal.

Erstellen eines Jenkins-ProjektsCreate a Jenkins project

Wählen Sie auf der Startseite des im Jenkins-Portal links New item (Neues Element) aus:From the home page of your Jenkins portal, select New item on the left-hand side:

  1. Geben Sie als Auftragsnamen azure-vote ein.Enter azure-vote as job name. Wählen Sie Freestyle Project und anschließend OK aus.Choose Freestyle project, then select OK

  2. Wählen Sie im Abschnitt Allgemein GitHub-Projekt aus, und geben Sie die URL Ihres geforkten Repositorys ein, z.B. https://github.com/<Ihr-GitHub-Konto>/azure-voting-app-redisUnder the General section, select GitHub project and enter your forked repo URL, such as https://github.com/<your-github-account>/azure-voting-app-redis

  3. Wählen Sie im Abschnitt Quellcodeverwaltung Git aus, und geben Sie die .git-URL Ihres geforkten Repositorys ein, z.B. https://github.com/<Ihr-GitHub-Konto>/azure-voting-app-redis.gitUnder the Source code management section, select Git, enter your forked repo .git URL, such as https://github.com/<your-github-account>/azure-voting-app-redis.git

  4. Wählen Sie im Bereich Build Triggers (Buildtrigger) die Option GitHub hook trigger for GITscm polling (GitHub-Hooktrigger für GITscm-Abruf) aus.Under the Build Triggers section, select GitHub hook trigger for GITscm polling

  5. Wählen Sie unter Build Environment (Buildumgebung) die Option Use secret texts or files (Geheime Texte oder Dateien verwenden) aus.Under Build Environment, select Use secret texts or files

  6. Wählen Sie unter Bindings (Bindungen) die Option Add (Hinzufügen) > Username and password (separated) (Benutzername und Kennwort (getrennt)) aus.Under Bindings, select Add > Username and password (separated)

    • Geben Sie ACR_ID unter Username Variable (Variable für Benutzernamen) und ACR_PASSWORD unter Password Variable (Variable für Kennwort) ein.Enter ACR_ID for the Username Variable, and ACR_PASSWORD for the Password Variable

      Jenkins-Bindungen

  7. Fügen Sie einen Build Step (Buildschritt) vom Typ Execute shell (Shell ausführen) hinzu, und verwenden Sie den folgenden Text.Choose to add a Build Step of type Execute shell and use the following text. Mit diesem Skript wird ein neues Containerimage erstellt und per Pushvorgang in Ihre ACR übertragen.This script builds a new container image and pushes it to your ACR registry.

    # 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 Build Step vom Typ Execute shell hinzu, und verwenden Sie den folgenden Text.Add another Build Step of type Execute shell and use the following text. Dieses Skript aktualisiert die Anwendungsbereitstellung in AKS mit dem neuen Containerimage aus ACR.This script updates the application deployment in AKS with the new container image from 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 --kubeconfig /var/lib/jenkins/config
    
  9. Klicken Sie nach Abschluss des Vorgangs auf Save.Once completed, click Save.

Testen des Jenkins-BuildsTest the Jenkins build

Bevor Sie den Auftrag basierend auf GitHub-Commits automatisieren, testen Sie die Jenkins-Erstellung zunächst manuell.Before you automate the job based on GitHub commits, first manually test the Jenkins build. Bei dieser manuellen Erstellung wird überprüft, ob der Buildauftrag richtig konfiguriert wurde, die richtige Kubernetes-Authentifizierungsdatei vorhanden ist und die Authentifizierung bei ACR funktioniert.This manual build validates that the job has been correctly configured, the proper Kubernetes authentication file is in place, and that the authentication with ACR works.

Wählen Sie im Menü auf der linken Seite des Projekts Build Now (Jetzt erstellen) aus.On the left-hand menu of the project, select Build Now.

Jenkins-Testbuild

Der erste Build dauert einen Moment, während die Docker-Imageebenen beim Jenkins-Server abgerufen werden.The first build takes a minute or two as the Docker image layers are pulled down to the Jenkins server. Nachfolgende Builds können die zwischengespeicherten Imageebenen verwenden und so die Buildzeiten verbessern.Subsequent builds can use the cached image layers to improve the build times.

Während des Buildvorgangs wird das GitHub-Repository auf dem Jenkins-Buildserver geklont.During the build process, the GitHub repository is cloned to the Jenkins build server. Ein neues Containerimage wird erstellt und per Pushvorgang in die ACR übertragen.A new container image is built and pushed to the ACR registry. Abschließend wird die Azure Vote-Anwendung, die im AKS-Cluster ausgeführt wird, aktualisiert, damit das neue Image verwendet wird.Finally, the Azure vote application running on the AKS cluster is updated to use the new image. Da am Anwendungscode keine Änderungen vorgenommen wurden, wird die Anwendung nicht geändert, wenn Sie die Beispiel-App in einem Webbrowser anzeigen.Because no changes have been made to the application code, the application is not changed if you view the sample app in a web browser.

Nachdem der Buildauftrag abgeschlossen ist, klicken Sie im Buildverlauf auf build #1.Once the build job is complete, click on build #1 under build history. Wählen Sie Console Output (Konsolenausgabe) aus, und zeigen Sie die Ausgabe des Buildvorgangs an.Select Console Output and view the output from the build process. In der letzten Zeile sollte die erfolgreiche Durchführung des Builds angezeigt werden.The final line should indicate a successful build.

Erstellen eines GitHub-WebhooksCreate a GitHub webhook

Nachdem die manuelle Erstellung abgeschlossen ist, integrieren Sie nun GitHub in den Jenkins-Build.With a successful manual build complete, now integrate GitHub into the Jenkins build. Der Webhook dient dazu, den Jenkins-Buildauftrag bei jedem Codecommit in GitHub auszuführen.A webhook can be used to run the Jenkins build job each time a code commit is made in GitHub. Führen Sie die folgenden Schritte aus, um den GitHub-Webhook zu erstellen:To create the GitHub webhook, complete the following steps:

  1. Navigieren Sie in einem Webbrowser zu Ihrem geforkten GitHub-Repository.Browse to your forked GitHub repository in a web browser.

  2. Wählen Sie Einstellungen und anschließend Webhooks auf der linken Seite aus.Select Settings, then select Webhooks on the left-hand side.

  3. Wählen Sie Webhook hinzufügen aus.Choose to Add webhook. Geben Sie als Payload URL (Nutzlast-URL) http://<publicIp:8080>/github-webhook/ ein, wobei <publicIp> die IP-Adresse des Jenkins-Servers ist.For the Payload URL, enter http://<publicIp:8080>/github-webhook/, where <publicIp> is the IP address of the Jenkins server. Stellen Sie sicher, dass Sie den nachgestellten Schrägstrich (/) hinzufügen.Make sure to include the trailing /. Übernehmen Sie die anderen Standardwerte für den Inhaltstyp, damit push-Ereignisse ausgelöst werden.Leave the other defaults for content type and to trigger on push events.

  4. Wählen Sie Webhook hinzufügen aus.Select Add webhook.

    Erstellen eines GitHub-Webhooks für Jenkins

Testen der gesamten CI/CD-PipelineTest the complete CI/CD pipeline

Nun können Sie die gesamte CI/CD-Pipeline testen.Now you can test the whole CI/CD pipeline. Wenn Sie einen Codecommit nach GitHub pushen, werden die folgenden Schritte ausgeführt:When you push a code commit to GitHub, the following steps happen:

  1. Der GitHub-Webhook ruft Jenkins auf.The GitHub webhook reaches out to Jenkins.
  2. Jenkins startet den Buildauftrag und pullt den letzten Codecommit aus GitHub.Jenkins starts the build job and pulls the latest code commit from GitHub.
  3. Ein Docker-Build wird mit dem aktualisierten Code gestartet, und das neue Containerimage wird mit der letzten Buildnummer markiert.A Docker build is started using the updated code, and the new container image is tagged with the latest build number.
  4. Dieses neue Containerimage wird an Azure Container Registry gepusht.This new container image is pushed to Azure Container Registry.
  5. Ihre bei Azure Kubernetes Service bereitgestellte Anwendung wird mit dem letzten Containerimage aus der Azure Container Registry aktualisiert.Your application deployed to Azure Kubernetes Service updates with the latest container image from the Azure Container Registry registry.

Öffnen Sie auf dem Entwicklungscomputer die geklonte Anwendung mit einem Code-Editor.On your development machine, open up the cloned application with a code editor. Öffnen Sie im Verzeichnis /azure-vote/azure-vote die Datei mit dem Namen config_file.cfg.Under the /azure-vote/azure-vote directory, open the file named config_file.cfg. Aktualisieren Sie die vote-Werte in dieser Datei auf andere Werte als „cats“ und „dogs“, wie im folgenden Beispiel gezeigt:Update the vote values in this file to something other than cats and dogs, as shown in the following example:

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

Nach der Aktualisierung können Sie die Datei speichern und die Änderungen committen und an Ihren Fork des GitHub-Repositorys pushen.When updated, save the file, commit the changes, and push these to your fork of the GitHub repository. Der GitHub-Webhook löst in Jenkins einen neuen Buildauftrag aus.The GitHub webhook triggers a new build job in Jenkins. Überwachen Sie den Buildprozess auf dem Jenkins-Webdashboard.In the Jenkins web dashboard, monitor the build process. Es dauert einige Sekunden, den aktuellen Code zu pullen, das aktualisierte Image zu erstellen und zu pushen und die aktualisierte Anwendung in AKS bereitzustellen.It takes a few seconds to pull the latest code, create and push the updated image, and deploy the updated application in AKS.

Wenn der Build abgeschlossen ist, aktualisieren Sie Ihren Webbrowser mit der Azure-Beispielabstimmungsanwendung.Once the build is complete, refresh your web browser of the sample Azure vote application. Ihre Änderungen werden wie im folgenden Beispiel angezeigt:Your changes are displayed, as shown in the following example:

Azure-Beispielabstimmungsanwendung in AKS durch den Jenkins-Buildauftrag aktualisiert

Nächste SchritteNext steps