Informationen zu Skaffold

1. Ziele

Skaffold ist ein Tool, das den Workflow zum Erstellen, Übertragen und Bereitstellen Ihrer Anwendung übernimmt. Mit Skaffold können Sie problemlos einen lokalen Entwicklungsarbeitsbereich konfigurieren, Ihren inneren Entwicklungszyklus optimieren und in andere Tools wie Kustomize und Helm einbinden, um Ihre Kubernetes-Manifeste zu verwalten.

In dieser Anleitung werden einige der wichtigsten Konzepte von Skaffold behandelt. Sie verwenden Skaffold, um die Entwicklungsschleife zu automatisieren, und stellen dann eine Anwendung bereit.

Sie werden Folgendes tun:

  • Skaffold für die lokale Entwicklung konfigurieren und aktivieren
  • Einfache Go-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 über die folgende URL:
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 noch nicht geschehen, klonen Sie den Anwendungsquellcode im Terminalfenster mit dem folgenden Befehl:
git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git
  1. Wechseln Sie in das geklonte Repository-Verzeichnis:
cd software-delivery-workshop/labs/understanding-skaffold/getting-started
  1. Legen Sie das aktuelle Verzeichnis als Cloud Shell-Arbeitsbereich fest, indem Sie den folgenden Befehl ausführen:
cloudshell workspace .

Projekt vorbereiten

  1. Prüfen Sie mit dem folgenden Befehl, ob Ihr Google Cloud-Projekt richtig festgelegt 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, die die Skaffold-Pipeline definiert.

Beachten Sie das Kubernetes-ähnliche YAML-Format und die folgenden Abschnitte im YAML:

  • 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 definiert, wie die Anwendung erstellt werden soll. In diesem Fall sehen Sie die Konfiguration für die Verarbeitung von git-Tags sowie einen artifacts-Abschnitt, in dem die Container-Images definiert sind, aus denen die Anwendung besteht.

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

5. Bereitstellen

Der Abschnitt deploy enthält die Konfiguration, die definiert, 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 Tool Kustomize bietet Funktionen zum Generieren von Kubernetes-Manifesten, indem eine Reihe von allgemeinen YAML-Dateien für Komponenten (im Verzeichnis base) mit einem oder mehreren „Overlays“ kombiniert werden, die in der Regel einem oder mehreren Bereitstellungszielen 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 dev-Overlay wird bei der lokalen Entwicklung verwendet, die Overlays staging und prod bei der Bereitstellung mit Skaffold.

6. Profile

Der Abschnitt profiles enthält die Konfiguration, mit der Build-, Test- und Deployment-Konfigurationen für verschiedene Kontexte definiert werden. Verschiedene Kontexte sind in der Regel unterschiedliche Umgebungen in Ihrer Anwendungsbereitstellungspipeline, wie staging oder prod in diesem Beispiel. So können Sie Manifeste, deren Inhalt sich für verschiedene Zielumgebungen unterscheiden muss, ganz einfach verwalten, ohne Boilerplate-Konfigurationen zu wiederholen.

Die Konfiguration im Abschnitt profiles kann alle Elemente aus der Hauptkonfiguration (z.B. die Abschnitte build, test oder deploy) ersetzen oder patchen.

Öffnen Sie zum Beispiel die Datei overlays > prod > deployment.yaml. Die Anzahl der Replikate für die Anwendung ist hier auf drei konfiguriert und überschreibt damit die Basiskonfiguration.

  1. Öffnen Sie die folgende Datei app > main.go im IDE-Bereich. Dies ist eine einfache Golang-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 ansehen

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

7. Mit Skaffold entwickeln

Kubernetes-Umgebung konfigurieren

  1. Führen Sie den folgenden Befehl aus, um sicherzustellen, dass Ihr lokaler 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 Build-Prozess für den Anwendungscontainer sollte ausgeführt werden. Das kann eine Minute dauern. Danach wird die Anwendungsausgabe jede Sekunde wiederholt:

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

Der genaue Pod-Name kann von der oben angegebenen generischen Ausgabe abweichen.

Änderungen an der Anwendung vornehmen

Nachdem die Anwendung 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 noch einmal im Cluster 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"

Nachdem Sie die Änderung vorgenommen haben, sollte Skaffold das Image neu erstellen und im Cluster bereitstellen. Die Änderung der Ausgabe ist im Terminalfenster zu sehen.

  1. Ändern Sie nun 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 wird alle 10 Sekunden angezeigt.

Kubernetes-Konfiguration ändern

Als Nächstes nehmen Sie eine Änderung an der Kubernetes-Konfiguration vor. Skaffold stellt die Anwendung dann automatisch noch einmal bereit.

  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 zwei Pods ausgeführt werden, 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 nicht mehr in Betrieb sein, sodass nur noch einer übrig ist.

  1. Drücken Sie schließlich im Terminalfenster Ctrl-C, um die lokale Entwicklung mit 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 erstellt (falls erforderlich) und die Release-Details werden in die Datei artifacts.json ausgegeben.

Wenn Sie ein Tool wie Cloud Deploy für die Bereitstellung 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 sich den Inhalt der Datei artifacts.json anzeigen zu lassen:
cat artifacts.json | jq

Die Datei enthält die Referenz auf das Bild, das in der endgültigen Bereitstellung verwendet wird.

Bereitstellung für das 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 der folgenden ähnelt:

[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 sehen, dass Ihre Anwendung im Cluster ausgeführt wird:
kubectl get all --namespace staging

Sie sollten zwei unterschiedliche Pod-Namen sehen, da im staging-Profil für die Anwendung zwei Replikate in der Bereitstellung angegeben sind.

In der Produktion bereitstellen

  1. Führen Sie nun den folgenden Befehl aus, um den Release 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 unterschiedliche Pod-Namen angezeigt werden, da im prod-Profil für die Anwendung drei Replikate im Deployment angegeben sind.

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

Die Ausgabe sollte Zeilen wie die folgenden enthalten, die die Bereitstellung in der Produktionsumgebung zeigen:

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

Außerdem sollten drei Anwendungspods ausgeführt werden.

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 die Bereitstellung von Anwendungen 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