Informationen zu Skaffold

1. Zielsetzungen

Skaffold ist ein Tool, das den Workflow zum Erstellen, Übertragen und Bereitstellen einer Anwendung verwaltet. Mit Skaffold können Sie einen lokalen Entwicklungsarbeitsbereich ganz einfach konfigurieren, Ihren internen Entwicklungszyklus optimieren und andere Tools wie Kustomize und Helm einbinden, um Ihre Kubernetes-Manifeste zu verwalten.

In dieser Anleitung lernen Sie einige der wichtigsten Konzepte von Skaffold kennen, verwenden es, um Ihren internen Entwicklungszyklus zu automatisieren, und stellen dann eine Anwendung bereit.

Sie werden Folgendes tun:

  • Skaffold für die lokale Entwicklung konfigurieren und aktivieren
  • Einfache Golang-Anwendung erstellen und ausführen
  • Lokale Anwendungsbereitstellung mit Skaffold verwalten
  • Manifeste rendern und Anwendung bereitstellen

2. Vorbereitung

Arbeitsbereich vorbereiten

  1. Öffnen Sie den Cloud Shell-Editor. Rufen Sie dazu die folgende URL auf:
https://shell.cloud.google.com

Drittanbieter-Cookies zulassen Klicken Sie auf „Website funktioniert nicht“ und dann auf „Cookies zulassen“.

7b702066a2135a3d.png

3394f82132eb4fd4.png

  1. Falls Sie dies noch nicht getan haben, klonen Sie die Anwendungsquelle im Terminalfenster mit dem folgenden Befehl:
git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git
  1. Wechseln Sie in das Verzeichnis des geklonten Repositorys:
cd software-delivery-workshop/labs/understanding-skaffold/getting-started
  1. Legen Sie mit dem folgenden Befehl das aktuelle Verzeichnis als Cloud Shell-Arbeitsbereich fest:
cloudshell workspace .

Projekt vorbereiten

  1. Prüfen Sie mit dem folgenden Befehl, ob Ihr Google Cloud-Projekt richtig eingerichtet ist:
gcloud config set project {{project-id}}

3. Erste Schritte mit Skaffold

  1. Führen Sie den folgenden Befehl aus, um die Skaffold-Konfigurationsdatei der obersten Ebene skaffold.yaml zu erstellen:
cat <<EOF > skaffold.yaml
apiVersion: skaffold/v2beta21
kind: Config
metadata:
  name: getting-started-kustomize
build:
  tagPolicy:
    gitCommit:
      ignoreChanges: true
  artifacts:
  - image: skaffold-kustomize
    context: app
    docker:
      dockerfile: Dockerfile
deploy:
  kustomize:
    paths:
    - overlays/dev
profiles:
- name: staging
  deploy:
    kustomize:
      paths:
      - overlays/staging
- name: prod
  deploy:
    kustomize:
      paths:
      - overlays/prod
EOF
  1. Öffnen Sie die Datei skaffold.yaml im IDE-Bereich. Dies ist die Konfigurationsdatei der obersten Ebene, in der die Skaffold-Pipeline definiert wird.

Beachten Sie das Kubernetes-ähnliche YAML-Format und die folgenden Abschnitte in der YAML-Datei:

  • build
  • deploy
  • profiles

In diesen Abschnitten wird definiert, wie die Anwendung erstellt und bereitgestellt werden soll, sowie Profile für jedes Bereitstellungsziel.

Eine vollständige Liste der Skaffold-Phasen finden Sie in der Dokumentation zu Skaffold-Pipeline-Phasen.

4. Build

Der Abschnitt build enthält die Konfiguration, die festlegt, wie die Anwendung erstellt werden soll. In diesem Fall sehen Sie die Konfiguration für die Verarbeitung von git-Tags sowie einen Abschnitt artifacts, in dem die Container-Images definiert sind, aus denen die Anwendung besteht.

Außerdem sehen Sie in diesem Abschnitt die Referenz auf die Dockerfile, die zum Erstellen der Bilder verwendet werden soll. Skaffold unterstützt außerdem andere Build-Tools wie Jib, Maven, Gradle, cloudnative Buildpacks, Bazel und benutzerdefinierte Scripts. Weitere Informationen zu dieser Konfiguration finden Sie in der Skaffold Build-Dokumentation.

5. Bereitstellen

Der Abschnitt deploy enthält die Konfiguration, die festlegt, wie die Anwendung bereitgestellt werden soll. In diesem Fall sehen Sie ein Beispiel für eine Standardbereitstellung, bei der Skaffold für die Verwendung des Tools Kustomize konfiguriert wird.

Das Kustomize-Tool bietet Funktionen zum Generieren von Kubernetes-Manifesten, indem eine Reihe von YAML-Dateien für gemeinsame Komponenten (im Verzeichnis base) mit einem oder mehreren „Overlays“ kombiniert wird, die in der Regel einem oder mehreren Bereitstellungzielen entsprechen – in der Regel dev, test, staging und production oder ähnlich.

In diesem Beispiel sehen Sie zwei Overlays für drei Ziele: dev, staging und prod. Das Overlay dev wird bei der lokalen Entwicklung verwendet, die Overlays staging und prod bei der Bereitstellung mit Skaffold.

6. Profile

Der Abschnitt profiles enthält eine Konfiguration, mit der Build-, Test- und Bereitstellungskonfigurationen für verschiedene Kontexte definiert werden. Unterschiedliche Kontexte sind in der Regel unterschiedliche Umgebungen in Ihrer Pipeline für die Anwendungsbereitstellung, z. B. staging oder prod in diesem Beispiel. Das bedeutet, dass Sie Manifeste, deren Inhalt für verschiedene Zielumgebungen unterschiedlich sein muss, ganz einfach verwalten können, ohne die Standardkonfiguration wiederholen zu müssen.

Mit der Konfiguration im Abschnitt profiles können Elemente aus der Hauptkonfiguration (z.B. die Abschnitte build, test oder deploy) ersetzt oder gepatcht werden.

Öffnen Sie dazu beispielsweise die Datei overlays > prod > deployment.yaml. Beachten Sie, dass die Anzahl der Replikate für die Anwendung hier auf drei festgelegt ist, wodurch die Basiskonfiguration überschrieben wird.

  1. Öffnen Sie die folgende Datei app > main.go im IDE-Bereich. Dies ist eine einfache Go-Anwendung, die jede Sekunde einen String in stdout schreibt.
  2. Beachten Sie, dass die Anwendung auch den Namen des Kubernetes-Pods ausgibt, in dem sie ausgeführt wird.

Dockerfile aufrufen

  1. Öffnen Sie die Datei app > Dockerfile im IDE-Bereich. Diese Datei enthält eine Sequenz von Anweisungen zum Erstellen des Anwendungs-Container-Images für die Datei main.go. Sie wird in der obersten Datei skaffold.yaml referenziert.

7. Mit Skaffold entwickeln

Kubernetes-Umgebung konfigurieren

  1. Führen Sie den folgenden Befehl aus, um sicherzustellen, dass der lokale Kubernetes-Cluster ausgeführt und konfiguriert wird:
minikube start

Das kann einige Minuten dauern. Wenn der Cluster erfolgreich gestartet wurde, sollte die folgende Ausgabe angezeigt werden:

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default
  1. Führen Sie den folgenden Befehl aus, um Kubernetes-Namespaces für dev, staging und prod zu erstellen:
kubectl apply -f namespaces.yaml

Es sollte folgende Ausgabe angezeigt werden:

namespace/dev created
namespace/staging created
namespace/prod created

Skaffold für die lokale Entwicklung verwenden

  1. Führen Sie den folgenden Befehl aus, um die Anwendung zu erstellen und in einem lokalen Kubernetes-Cluster bereitzustellen, der in Cloud Shell ausgeführt wird:
skaffold dev

Der Buildvorgang für den Anwendungscontainer sollte gestartet werden. Das kann eine Minute dauern. Anschließend wird die Anwendungsausgabe jede Sekunde wiederholt:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-dev-xxxxxxxxx-xxxxx

Der genaue Pod-Name unterscheidet sich von der generischen Ausgabe oben.

Änderungen an der Anwendung vornehmen

Da die Anwendung jetzt in Ihrem lokalen Kubernetes-Cluster ausgeführt wird, können Sie Änderungen am Code vornehmen. Skaffold erstellt die Anwendung dann automatisch neu und stellt sie im Cluster wieder bereit.

  1. Öffnen Sie die Datei app > main.go im IDE-Bereich und ändern Sie den Ausgabestring:
"Hello world from pod %s!\n"

in

"Hello Skaffold world from pod %s!\n"

Wenn Sie die Änderung vorgenommen haben, sollte Skaffold das Image neu erstellen und im Cluster noch einmal bereitstellen. Die Ausgabeänderung wird im Terminalfenster angezeigt.

  1. Ändern Sie jetzt auch in der Datei „app > main.go“ im IDE-Bereich die Zeile:
time.Sleep(time.Second * 1)

zu

time.Sleep(time.Second * 10)

Die Anwendung sollte wieder neu erstellt und bereitgestellt werden. Die Ausgabezeile sollte alle 10 Sekunden erscheinen.

Änderungen an der Kubernetes-Konfiguration vornehmen

Als Nächstes nehmen Sie eine Änderung an der Kubernetes-Konfiguration vor. Skaffold führt dann noch einmal eine automatische Neubereitstellung durch.

  1. Öffnen Sie die Datei base > deployment.yaml in der IDE und ändern Sie die Zeile:
replicas: 1

zu

replicas: 2

Nachdem die Anwendung neu bereitgestellt wurde, sollten Sie zwei Pods sehen, die jeweils einen anderen Namen haben.

  1. Ändern Sie nun dieselbe Zeile in der Datei base > deployment.yaml zurück zu:
replicas: 1

Einer der Pods sollte aus dem Dienst entfernt worden sein, sodass nur noch einer übrig ist.

  1. Drücken Sie abschließend im Terminalfenster Ctrl-C, um die lokale Entwicklung von Skaffold zu beenden.

Release erstellen

Als Nächstes erstellen Sie einen Release, indem Sie ein Release-Image erstellen und in einem Cluster bereitstellen.

  1. Führen Sie den folgenden Befehl aus, um den Release zu erstellen:
skaffold build --file-output artifacts.json

Mit diesem Befehl wird das endgültige Image (falls erforderlich) erstellt und die Release-Details in der artifacts.json-Datei ausgegeben.

Wenn Sie ein Tool wie Cloud Deploy zum Bereitstellen in Ihren Clustern verwenden möchten, enthält diese Datei die Release-Informationen. Das bedeutet, dass die Artefakte auf dem Weg zur Veröffentlichung unveränderlich sind.

  1. Führen Sie den folgenden Befehl aus, um den Inhalt der artifacts.json-Datei aufzurufen:
cat artifacts.json | jq

Beachten Sie, dass die Datei einen Verweis auf das Image enthält, das bei der endgültigen Bereitstellung verwendet wird.

Bereitstellung im Staging

  1. Führen Sie den folgenden Befehl aus, um den Release mit dem Profil staging bereitzustellen:
skaffold deploy --profile staging --build-artifacts artifacts.json --tail

Nach Abschluss der Bereitstellung sollten Sie eine Ausgabe von zwei Pods sehen, die in etwa so aussieht:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!
  1. Drücken Sie im Terminalfenster Strg + C, um die Skaffold-Ausgabe zu beenden.
  2. Führen Sie den folgenden Befehl aus, um zu beobachten, wie die Anwendung im Cluster ausgeführt wird:
kubectl get all --namespace staging

Sie sollten zwei verschiedene Podnamen sehen, da im staging-Profil für die Anwendung angegeben ist, dass es zwei Replikate in der Bereitstellung geben soll.

In der Produktion bereitstellen

  1. Führen Sie nun den folgenden Befehl aus, um die Version mit dem Profil prod bereitzustellen:
skaffold deploy --profile prod --build-artifacts artifacts.json --tail

Nach Abschluss der Bereitstellung sollten Sie eine Ausgabe von drei Pods sehen, die in etwa so aussieht:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!
  1. Drücken Sie im Terminalfenster Strg + C, um die Skaffold-Ausgabe zu beenden.

Es sollten drei verschiedene Podnamen angezeigt werden, da im prod-Profil für die Anwendung angegeben ist, dass es drei Replikate im Deployment geben soll.

  1. Führen Sie den folgenden Befehl aus, um zu prüfen, ob Ihre Anwendung im Cluster ausgeführt wird:
kubectl get all --namespace prod

Die Ausgabe sollte Zeilen wie die folgenden enthalten, die die Produktionsbereitstellung zeigen:

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/skaffold-kustomize-prod   3/3     3            3           16m

Außerdem sollten Sie drei Anwendungs-Pods sehen.

NAME                                           READY   STATUS    RESTARTS   AGE
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m
pod/skaffold-kustomize-prod-xxxxxxxxxx-xxxxx   1/1     Running   0          10m

8. Glückwunsch!

Glückwunsch! Sie haben das Lab Understanding Skaffold abgeschlossen und gelernt, wie Sie Skaffold für die lokale Entwicklung und Anwendungsbereitstellung konfigurieren und verwenden.

Nächste Schritte:

Weitere Informationen zu Skaffold:

Bereinigen

  1. Führen Sie den folgenden Befehl aus, um den lokalen Cluster herunterzufahren:
minikube delete