Diese Seite wurde von der Cloud Translation API übersetzt.

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 ganz einfach einen lokalen Entwicklungsarbeitsbereich konfigurieren, Ihre innere Entwicklungsschleife optimieren und andere Tools wie Kustomize und Helm einbinden, um Ihre Kubernetes-Manifeste zu verwalten.

In dieser Anleitung durcharbeiten Sie einige Kernkonzepte von Skaffold. Damit können Sie dann Ihre innere Entwicklungsschleife automatisieren und anschließend eine Anwendung bereitstellen.

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 wird vorbereitet

Ö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".

Falls noch nicht geschehen, klonen Sie im Terminalfenster die Anwendungsquelle mit dem folgenden Befehl:

git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git

Wechseln Sie in das geklonte Repository-Verzeichnis:

cd software-delivery-workshop/labs/understanding-skaffold/getting-started

Legen Sie mit dem folgenden Befehl das aktuelle Verzeichnis als Cloud Shell-Arbeitsbereich fest:

cloudshell workspace .

Projekt vorbereiten

Prüfen Sie, ob Ihr Google Cloud-Projekt korrekt festgelegt ist. Führen Sie dazu den folgenden Befehl aus:

gcloud config set project {{project-id}}

3. Erste Schritte mit Skaffold

Führen Sie den folgenden Befehl aus, um die übergeordnete Skaffold-Konfigurationsdatei 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

Öffnen Sie die Datei skaffold.yaml im IDE-Bereich. Dies ist die Konfigurationsdatei auf oberster Ebene, die die Skaffold-Pipeline definiert.

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. Außerdem werden Profile für die einzelnen Bereitstellungsziele definiert.

Weitere Informationen zur vollständigen Liste der Skaffold-Phasen finden Sie in der Dokumentation zu den Skaffold-Pipelinephasen.

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 werden, aus denen die Anwendung besteht.

Außerdem sehen Sie in diesem Abschnitt den Verweis auf das Dockerfile, das zum Erstellen der Images verwendet werden soll. Skaffold unterstützt außerdem andere Build-Tools wie Jib, Maven, Gradle, die cloudnativen Funktionen 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 Kustomize-Tools konfiguriert wird.

Das Kustomize-Tool 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 wird. die in der Regel einem oder mehreren Bereitstellungszielen entsprechen – in der Regel dev, test, staging und production oder Ähnliches.

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

6. Profile

Der Abschnitt profiles enthält die Konfiguration, die Build-, Test- und Bereitstellungskonfigurationen für verschiedene Kontexte definiert. Unterschiedliche Kontexte sind normalerweise unterschiedliche Umgebungen in Ihrer Anwendungsbereitstellungspipeline, wie in diesem Beispiel staging oder prod. 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.

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

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

Im Quellcode der Anwendung navigieren.

Ö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.
Beachten Sie, dass die Anwendung auch den Namen des Kubernetes-Pods ausgibt, in dem sie ausgeführt wird.

Dockerfile ansehen

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

7. Mit Skaffold entwickeln

Kubernetes-Umgebung konfigurieren

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

minikube start

Dies kann einige Minuten dauern. Wenn der Cluster erfolgreich gestartet wurde, sollten Sie die folgende Ausgabe sehen:

Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

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

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 des Anwendungscontainers wird nun ausgeführt. Dies kann eine Minute dauern. Anschließend wird die Anwendungsausgabe jede Sekunde wiederholt:

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

Beachten Sie, dass sich der genaue Pod-Name von der generischen Ausgabe oben unterscheidet.

Änderungen an der Anwendung vornehmen

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

Öffnen Sie die Datei app > main.go im IDE-Bereich und ändern Sie den Ausgabestring:

"Hello world from pod %s!\n"

"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.

In der Datei „app > main.go" Ändern Sie im IDE-Bereich die folgende Zeile:

time.Sleep(time.Second * 1)

time.Sleep(time.Second * 10)

Auch hier sollte die Anwendung neu erstellt und bereitgestellt werden, wobei die Ausgabezeile alle 10 Sekunden angezeigt wird.

Änderungen an der Kubernetes-Konfiguration vornehmen

Als Nächstes ändern Sie die Kubernetes-Konfiguration. Anschließend wird Skaffold automatisch neu bereitgestellt.

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

replicas: 1

replicas: 2

Nachdem die Anwendung wieder bereitgestellt wurde, sollten zwei Pods ausgeführt werden. Jeder hat einen anderen Namen.

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

replicas: 1

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

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

Release kürzen

Als Nächstes erstellen Sie einen Release. Dazu erstellen Sie ein Release-Image und stellen es in einem Cluster bereit.

Führen Sie den folgenden Befehl aus, um den Release zu erstellen:

skaffold build --file-output artifacts.json

Mit diesem Befehl wird bei Bedarf das endgültige Image erstellt und die Releasedetails in die Datei artifacts.json ausgegeben.

Wenn Sie ein Tool wie Cloud Deploy zum Bereitstellen in Ihren Clustern verwenden möchten, enthält diese Datei die Releaseinformationen. Dies bedeutet, dass die Artefakte auf der Route zur Live-Übertragung unveränderlich sind.

Führen Sie den folgenden Befehl aus, um den Inhalt der Datei artifacts.json anzusehen:

cat artifacts.json | jq

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

Für das Staging bereitstellen

Führen Sie den folgenden Befehl aus, um den Release mit dem Profil staging bereitzustellen:

skaffold deploy --profile staging --build-artifacts artifacts.json --tail

Wenn die Bereitstellung abgeschlossen ist, sollten Sie in etwa folgende Ausgabe von zwei Pods sehen:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-staging-xxxxxxxxxx-xxxxx!

Drücken Sie im Terminalfenster Strg + C, um die Skaffold-Ausgabe zu beenden.
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 unterschiedliche Pod-Namen sehen, da im Profil staging für die Anwendung angegeben ist, dass das Deployment zwei Replikate enthält.

In der Produktion bereitstellen

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

Wenn die Bereitstellung abgeschlossen ist, sollten Sie in etwa folgende Ausgabe von drei Pods sehen:

[skaffold-kustomize] Hello world from pod skaffold-kustomize-prod-xxxxxxxxxx-xxxxx!

Drücken Sie im Terminalfenster Strg + C, um die Skaffold-Ausgabe zu beenden.

Sie sollten drei unterschiedliche Pod-Namen sehen, da im Profil prod für die Anwendung angegeben ist, dass das Deployment drei Replikate enthält.

Führen Sie den folgenden Befehl aus, um zu beobachten, wie die Anwendung im Cluster ausgeführt wird:

kubectl get all --namespace prod

Die Ausgabe sollte Zeilen wie die folgende enthalten, die das Deployment "prod" 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 die Anwendungsbereitstellung konfigurieren und verwenden.

Nächste Schritte:

Weitere Informationen zu Skaffold:

Skaffold – Detailanalyse

Bereinigen

Führen Sie den folgenden Befehl aus, um den lokalen Cluster herunterzufahren:

minikube delete