1. Übersicht
Jenkins ist eine der beliebtesten Lösungen für Continuous Integration. Sie wird verwendet, um die wesentlichen nicht von Menschen ausgeführten Teile des Softwareentwicklungsprozesses zu automatisieren. Durch die Bereitstellung von Jenkins in Kubernetes in Google Cloud und die Verwendung des GKE-Plug-ins können wir Build-Ausführer bei Bedarf schnell und automatisch skalieren. In Kombination mit Cloud Storage können wir eine Anwendung mit minimalem Aufwand erstellen und testen.
Aufgabe
- Jenkins in einem Kubernetes-Cluster bereitstellen
- Das Jenkins-GKE-Plug-in bereitstellen und konfigurieren, damit Jenkins Pods als Ausführungsknoten erstellen und löschen kann
- Beispiel-SpringBoot-Anwendung erstellen und testen
- Container in Google Container Registry erstellen und veröffentlichen
- Beispielanwendung in einer GKE-Staging- und Produktionsumgebung bereitstellen
Voraussetzungen
- Ein Google Cloud-Projekt mit eingerichteter Abrechnung. Wenn Sie noch kein Konto haben, erstellen Sie eines.
2. Einrichtung
Dieses Codelab kann vollständig auf der Google Cloud Platform ausgeführt werden, ohne dass eine lokale Installation oder Konfiguration erforderlich ist.
Cloud Shell
In diesem Codelab stellen wir verschiedene Cloud-Ressourcen und ‑Dienste über die Befehlszeile mit Cloud Shell bereit und verwalten sie.
APIs aktivieren
Hier sind die APIs, die wir für unser Projekt aktivieren müssen:
- Compute Engine API: Erstellt und führt virtuelle Maschinen aus
- Kubernetes Engine API: Erstellen und Verwalten containerbasierter Anwendungen
- Cloud Build API: Plattform für kontinuierliche Integration und kontinuierliche Bereitstellung von Google Cloud
- Service Management API: Ermöglicht Dienstanbietern die Veröffentlichung von Diensten auf der Google Cloud Platform.
- Cloud Resource Manager API: Erstellt, liest und aktualisiert Metadaten für Google Cloud-Ressourcencontainer.
Aktivieren Sie die erforderlichen APIs mit dem folgenden gcloud-Befehl:
gcloud services enable compute.googleapis.com \
container.googleapis.com \
cloudbuild.googleapis.com \
servicemanagement.googleapis.com \
cloudresourcemanager.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}
GCS-Bucket erstellen
Wir benötigen einen GCS-Bucket, um unsere Testarbeit hochzuladen. Erstellen wir einen Bucket mit unserer Projekt-ID im Namen, um für Eindeutigkeit zu sorgen:
gsutil mb gs://${GOOGLE_CLOUD_PROJECT}-jenkins-test-bucket/
3. Kubernetes-Cluster erstellen
Cluster erstellen
Als Nächstes erstellen wir einen GKE-Cluster, auf dem unser Jenkins-System gehostet wird, einschließlich der Pods, die als Worker-Knoten ausgeführt werden. Durch den zusätzlichen Bereich, der durch das Flag --scopes angegeben ist, kann Jenkins auf Cloud Source Repositories und Container Registry zugreifen. Führen Sie in der Cloud Console folgenden Befehl aus:
gcloud container clusters create jenkins-cd \ --machine-type n1-standard-2 --num-nodes 1 \ --zone us-east1-d \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform" \ --cluster-version latest
Stellen wir außerdem zwei Cluster bereit, um die Staging- und Produktionsversionen unserer Beispielanwendung zu hosten:
gcloud container clusters create staging \ --machine-type n1-standard-2 --num-nodes 1 \ --zone us-east1-d \ --cluster-version latest
gcloud container clusters create prod \ --machine-type n1-standard-2 --num-nodes 2 \ --zone us-east1-d \ --cluster-version latest
Bestätigen
Sobald die Cluster erstellt wurden, können wir prüfen, ob sie mit gcloud container clusters list ausgeführt werden.
Die Ausgabe sollte in der Spalte STATUS den Wert RUNNING enthalten:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS jenkins-cd us-east1-d 1.15.9-gke.9 34.74.77.124 n1-standard-2 1.15.9-gke.9 2 RUNNING prod us-east1-d 1.15.9-gke.9 35.229.98.12 n1-standard-2 1.15.9-gke.9 2 RUNNING staging us-east1-d 1.15.9-gke.9 34.73.92.228 n1-standard-2 1.15.9-gke.9 2 RUNNING
4. Jenkins mit Helm bereitstellen
Helm installieren
Wir verwenden Helm, einen Anwendungspaketmanager für Kubernetes, um Jenkins in unserem Cluster zu installieren. Laden Sie zuerst das Projekt mit den Kubernetes-Manifesten herunter, die wir zum Bereitstellen von Jenkins verwenden:
git clone https://github.com/GoogleCloudPlatform/continuous-deployment-on-kubernetes.git ~/continuous-deployment-on-kubernetes
Wechseln Sie in das Projektverzeichnis:
cd ~/continuous-deployment-on-kubernetes/
Erstellen Sie eine Clusterrollenbindung, um sich selbst Berechtigungen für die Rolle „cluster-admin“ zu erteilen:
kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-admin --user=$(gcloud config get-value account)
Stellen Sie eine Verbindung zu Ihrem Jenkins-Cluster her, indem Sie die Anmeldedaten abrufen:
gcloud container clusters get-credentials jenkins-cd --zone us-east1-d --project ${GOOGLE_CLOUD_PROJECT}
Laden Sie die Helm-Binärdatei in die Cloud Console herunter:
wget https://storage.googleapis.com/kubernetes-helm/helm-v2.14.1-linux-amd64.tar.gz
Entpacken Sie die Datei und kopieren Sie die enthaltene Helm-Datei in Ihr aktuelles Arbeitsverzeichnis:
tar zxfv helm-v2.14.1-linux-amd64.tar.gz && \ cp linux-amd64/helm .
Tiller ist die Serverseite von Helm, die im Kubernetes-Cluster ausgeführt wird. Erstellen Sie ein Dienstkonto mit dem Namen tiller:
kubectl create serviceaccount tiller \ --namespace kube-system
und binden Sie sie an die Clusterrolle cluster-admin, damit sie Änderungen vornehmen kann:
kubectl create clusterrolebinding tiller-admin-binding \ --clusterrole=cluster-admin \ --serviceaccount=kube-system:tiller
Jetzt können wir Helm initialisieren und das Repository aktualisieren:
./helm init --service-account=tiller && \ ./helm repo update
Bestätigen
Prüfen Sie mit ./helm version, ob Helm einsatzbereit ist. Es sollten die Versionsnummern des Clients und des Servers zurückgegeben werden:
Client: &version.Version{SemVer:"v2.14.1", GitCommit:"5270352a09c7e8b6e8c9593002a73535276507c0", GitTreeState:"clean"}
Server: &version.Version{SemVer:"v2.14.1", GitCommit:"5270352a09c7e8b6e8c9593002a73535276507c0", GitTreeState:"clean"}
Jenkins installieren
Nachdem Helm auf unserem Cluster installiert ist, können wir mit der Jenkins-Installation fortfahren:
./helm install stable/jenkins -n cd \ -f jenkins/values.yaml \ --version 1.2.2 --wait
Bestätigen
Sehen wir uns die Pods an:
kubectl get pods
Die Ausgabe sollte unseren Jenkins-Pod mit dem Status „RUNNING“ (LÄUFT) enthalten:
NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 1/1 Running 0 1m
Prüfen Sie, ob der Jenkins-Dienst richtig erstellt wurde:
kubectl get svc
Die Ausgabe sollte in etwa so aussehen:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins ClusterIP 10.35.241.170 <none> 8080/TCP 2m27s cd-jenkins-agent ClusterIP 10.35.250.57 <none> 50000/TCP 2m27s kubernetes ClusterIP 10.35.240.1 <none> 443/TCP 75m
Die Jenkins-Installation verwendet das Kubernetes-Plugin zum Erstellen von Builder-Agents. Sie werden bei Bedarf automatisch vom Jenkins-Master gestartet. Wenn deren Aufgabe abgeschlossen ist, werden sie automatisch beendet und ihre Ressourcen wieder dem Ressourcenpool des Clusters hinzugefügt.
Verbindung zu Jenkins herstellen
Jenkins wird in unserem Cluster ausgeführt. Für den Zugriff auf die Benutzeroberfläche richten wir jetzt eine Portweiterleitung über Cloud Shell ein:
export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") &&
kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &
Während der Installation wurde ein Administratorpasswort generiert. So rufen Sie sie ab:
printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo
Klicken Sie oben in Cloud Shell auf das Symbol für die Webvorschau 
und wählen Sie „Vorschau auf Port 8080“ aus.
Es sollte ein Anmeldebildschirm für Jenkins angezeigt werden, in dem wir admin als Nutzernamen und das im vorherigen Schritt zurückgegebene Passwort eingeben können:
Wenn wir auf Anmelden klicken, sollten wir zur Hauptseite von Jenkins weitergeleitet werden.
5. GKE-Plug-in installieren und konfigurieren
Mit dem Google Kubernetes Engine-Plug-in können wir Bereitstellungen, die in Jenkins erstellt wurden, in unseren Kubernetes-Clustern veröffentlichen, die in GKE ausgeführt werden. Es müssen einige Konfigurationen mit IAM-Berechtigungen für Ihr Projekt vorgenommen werden. Wir stellen diese Konfiguration mit Terraform bereit.
Laden Sie zuerst das GKE-Plug-in-Projekt herunter:
git clone https://github.com/jenkinsci/google-kubernetes-engine-plugin.git ~/google-kubernetes-engine-plugin
Automatische Konfiguration von IAM-Berechtigungen
Ändern Sie das aktuelle Arbeitsverzeichnis in das Verzeichnis „rbac“ des GKE-Projekts, das Sie zuvor geklont haben:
cd ~/google-kubernetes-engine-plugin/docs/rbac/
gcp-sa-setup.tf ist eine Terraform-Konfigurationsdatei, mit der eine benutzerdefinierte GCP-IAM-Rolle mit eingeschränkten Berechtigungen und ein GCP-Dienstkonto erstellt wird, dem diese Rolle gewährt wird. Die Datei erfordert Werte für die Variablen „project“, „region“ und „service_account_name“. Wir geben diese Werte an, indem wir zuerst die folgenden Umgebungsvariablen deklarieren:
export TF_VAR_project=${GOOGLE_CLOUD_PROJECT}
export TF_VAR_region=us-east1-d
export TF_VAR_sa_name=kaniko-role
Initialisieren Sie Terraform, generieren Sie einen Plan und wenden Sie ihn an:
terraform init terraform plan -out /tmp/tf.plan terraform apply /tmp/tf.plan && rm /tmp/tf.plan
Das Dienstkonto benötigt Berechtigungen für die Speicherverwaltung, um Daten in unserem Cloud Storage-Bucket zu speichern:
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
--member serviceAccount:kaniko-role@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com \
--role 'roles/storage.admin'
Außerdem sind Containerberechtigungen für die Bereitstellungsphasen unserer Pipeline erforderlich:
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} --member \
serviceAccount:kaniko-role@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com --role 'roles/container.developer'
Jetzt können wir mit Helm Clusterberechtigungen für das GKE-Plug-in mit dem gke-Robot-Bereitsteller einrichten. Ändern Sie das Arbeitsverzeichnis in das Helm-Verzeichnis des GKE-Projekts:
cd ~/google-kubernetes-engine-plugin/docs/helm/
Und installieren Sie es mit dem bereitgestellten Helm-Diagramm:
export TARGET_NAMESPACE=kube-system && \ envsubst < gke-robot-deployer/values.yaml | helm install ./gke-robot-deployer --name gke-robot-deployer -f -
6. Jenkins konfigurieren
Dienstkontoschlüssel
Damit das Dienstkonto ordnungsgemäß funktioniert, müssen wir eine private Schlüsseldatei generieren und sie als Kubernetes-Secret hinzufügen. Erstellen Sie zuerst die Datei mit dem folgenden gcloud-Befehl:
gcloud iam service-accounts keys create /tmp/kaniko-secret.json --iam-account kaniko-role@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
Wir erstellen mit dieser Datei einen geheimen Schlüssel im Kubernetes-Secret-Store:
kubectl create secret generic jenkins-int-samples-kaniko-secret --from-file=/tmp/kaniko-secret.json
Laden Sie die JSON-Datei auf Ihren lokalen Datenträger herunter. Klicken Sie dazu im Dreipunkt-Menü von Cloud Shell auf „Datei herunterladen“:
Geben Sie den Dateipfad /tmp/kaniko-secret.json ein und klicken Sie auf „Herunterladen“.
Klicken Sie auf der Jenkins-Seite im linken Bereich auf Anmeldedaten und dann auf System.
Klicken Sie auf der Seite im Bereich System links auf „Globale Anmeldedaten“ und dann auf „Anmeldedaten hinzufügen“:
Wählen Sie im Drop-down-Menü „Kind“ die Option Google-Dienstkonto von privatem Schlüssel aus. Geben Sie „kaniko-role“ als Namen ein, laden Sie den in den vorherigen Schritten erstellten JSON-Schlüssel hoch und klicken Sie auf „OK“.
Umgebungsvariablen
Es gibt einige Umgebungsvariablen, die wir in Jenkins definieren müssen, bevor wir die Pipeline mit mehreren Verzweigungen erstellen. Diese sind:
- JENK_INT_IT_ZONE: die Zone des Kubernetes-Clusters. In unserem Fall
us-east1-d - JENK_INT_IT_PROJECT_ID: die GCP-Projekt-ID, auf der diese Jenkins-Instanz gehostet wird
- JENK_INT_IT_STAGING: Name des Staging-Clusters, hier
staging - JENK_INT_IT_PROD – Name unseres Produktionsclusters Zu Demonstrationszwecken ist das
prod. - JENK_INT_IT_BUCKET: der im vorherigen Schritt erstellte Google Cloud Storage-Bucket
- JENK_INT_IT_CRED_ID: bezieht sich auf die Anmeldedaten, die im vorherigen Schritt mit der JSON-Datei erstellt wurden. Der Wert muss mit dem Namen übereinstimmen, den wir ihm gegeben haben:
kaniko-role.
Rufen Sie dazu Manage Jenkins (Jenkins verwalten) auf:
Klicken Sie dann auf System konfigurieren:
Es gibt einen Bereich namens Globale Eigenschaften. Wenn wir das Kästchen für Umgebungsvariablen anklicken, wird die Schaltfläche Hinzufügen angezeigt. Wenn wir darauf klicken, werden die oben genannten Variablen als Schlüssel/Wert-Paare hinzugefügt:
Klicken Sie unten auf der Seite auf die Schaltfläche Speichern, um die Änderungen anzuwenden.
7. Pipeline einrichten
Klicken Sie in Jenkins auf „Neues Element“:
Geben Sie „jenkins-integration-sample“ als Namen ein, wählen Sie „Multibranch Pipeline“ als Projekttyp aus und klicken Sie auf „OK“:
Sie werden zur Seite „Pipelinekonfiguration“ weitergeleitet. Geben Sie unter Branch Sources (Zweigquellen) https://github.com/GoogleCloudPlatform/jenkins-integration-samples.git als Project Repository (Projekt-Repository) ein. Geben Sie unter Build-Konfiguration „gke/Jenkinsfile“ als Script-Pfad ein.
Klicken Sie auf Speichern, um diese Einstellungen anzuwenden. Nach dem Speichern startet Jenkins einen Scan des Repositorys und einen anschließenden Build für jeden Branch. Im Laufe des Vorgangs werden auf der Seite „Kubernetes-Arbeitslasten“ Pods erstellt, ausgeführt und gelöscht.
Nach Abschluss der Builds finden Sie auf der Seite „Kubernetes-Arbeitslasten“ zwei Elemente mit dem Namen „jenkins-integration-samples-gke“, die jeweils dem Produktions- oder dem Testcluster entsprechen. Der Status ist „OK“:
Mit dem folgenden gcloud-Befehl sehen wir, dass wir ein Container-Image in die Google Container Registry hochgeladen haben, das unserer Pipeline entspricht:
gcloud container images list
Wenn Sie die Arbeitslast in Ihrem Browser sehen möchten, rufen Sie die Anmeldedaten für den Prod-Cluster ab:
gcloud container clusters get-credentials prod --zone us-east1-d --project ${GOOGLE_CLOUD_PROJECT}
Führen Sie Folgendes aus, um eine Portweiterleitung vom Port 8081 Ihrer Shell zum Port 8080 Ihrer Arbeitslast einzurichten:
export POD_NAME=$(kubectl get pods -o jsonpath="{.items[0].metadata.name}") &&
kubectl port-forward $POD_NAME 8081:8080 >> /dev/null &
Klicken Sie oben in Cloud Shell auf das Symbol für die Webvorschau und wählen Sie „Vorschau auf Port 8081“ aus.
8. Bereinigen
Wir haben gelernt, wie Sie eine Jenkins- und eine Beispiel-Pipeline mit mehreren Branches in Kubernetes bereitstellen. Jetzt ist es an der Zeit, unser Projekt von allen erstellten Ressourcen zu bereinigen.
Projekt löschen
Alternativ können Sie das gesamte Projekt löschen. Rufen Sie in der GCP Console die Seite Cloud Resource Manager auf:
Wählen Sie in der Projektliste das Projekt aus, an dem Sie gearbeitet haben, und klicken Sie auf Löschen. Sie werden aufgefordert, die Projekt-ID einzugeben. Geben Sie den Code ein und klicken Sie auf Herunterfahren.
Alternativ können Sie das gesamte Projekt direkt über Cloud Shell mit gcloud löschen:
gcloud projects delete $GOOGLE_CLOUD_PROJECT
Wenn Sie die verschiedenen abrechenbaren Komponenten lieber einzeln löschen möchten, fahren Sie mit dem nächsten Abschnitt fort.
Kubernetes-Cluster
Löschen Sie den gesamten Kubernetes-Cluster mit gcloud:
gcloud container clusters delete jenkins-cd --zone=us-east1-d
Speicher-Buckets
Entfernen Sie alle hochgeladenen Dateien und löschen Sie den Bucket mit gsutil:
gsutil rm -r gs://${GOOGLE_CLOUD_PROJECT}-jenkins-test-bucket
Google Container Registry-Images
Wir löschen die Google Container Registry-Images anhand der Image-Digests. Rufen Sie zuerst die Zusammenfassungen mit dem folgenden Befehl ab:
gcloud container images list-tags gcr.io/${GOOGLE_CLOUD_PROJECT}/jenkins-integration-samples-gke --format="value(digest)"
Führen Sie dann für jeden zurückgegebenen Digest die folgenden Schritte aus:
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/jenkins-integration-samples-gke@sha256:<DIGEST>
9. Glückwunsch!
Hurra! Du hast es geschafft. Sie haben gelernt, wie Sie Jenkins in GKE bereitstellen und Jobs an Kubernetes-Cluster weiterleiten.
Behandelte Themen
- Wir haben einen Kubernetes-Cluster bereitgestellt und Jenkins mit Helm installiert.
- Wir haben das GKE-Plug-in installiert und konfiguriert, damit Jenkins Build-Artefakte in Kubernetes-Clustern bereitstellen kann.
- Wir haben Jenkins so konfiguriert, dass eine Multibranch-Pipeline eingerichtet wird, die Aufgaben an GKE-Cluster sendet.