Entwicklung in Cloud Code for VS Code beschleunigen

Sie können die lokale Entwicklung in Cloud Code für VS Code beschleunigen, indem Sie Dateisynchronisierung und Hot Refresh, die automatische Bereitstellung beim Speichern und Skaffold-Module nutzen, um Teile einer Anwendung separat zu entwickeln.

Skaffold-Dateisynchronisierung und Hot Refresh aktivieren

Skaffold unterstützt das Kopieren geänderter Dateien in einen bereitgestellten Container, um die Effizienz Ihres lokalen Entwicklungsworkflows zu verbessern und zu vermeiden, dass Pods neu erstellt, noch einmal bereitgestellt oder neu gestartet werden müssen. Wenn Sie also Änderungen an statischen Dateien und Quellcodedateien vornehmen, werden diese innerhalb weniger Sekunden wirksam, was zu einer beschleunigten Feedbackschleife führt.

Bei statischen Dateien (z. B. HTML- und CSS-Dateien) wird dieses Kopierverhalten als Dateisynchronisierung bezeichnet.

Bei Quellcodedateien wird dieses Verhalten als Hot Reload bezeichnet und unterstützt die folgenden Dateitypen:

Go: *.go
Java: *.java, *.kt, *.scala, *.groovy, *.clj
NodeJS: *.js, *.mjs, *.coffee, *.litcoffee, *.json

Wenn das Hot-Update konfiguriert ist, erkennt Skaffold Änderungen an unterstützten Dateien und synchronisiert diese mit dem laufenden Container in Ihrem Cluster. Änderungen an Dateitypen, die kein Hot-Neu laden unterstützen, lösen eine Neuerstellung des Images und den Pod-Neustart aus.

Die automatische Dateisynchronisierung und Hot Reload sind standardmäßig aktiviert, wenn Sie mit Buildpacks als Ihrem bevorzugten Builder arbeiten. Für andere Builder wie Docker können Sie einen sync-Abschnitt in der skaffold.yaml-Datei für das Artefakt angeben, das Sie anpassen.

Folgende Synchronisierungseinstellungen können festgelegt werden (in der Reihenfolge ihrer Präferenz):

auto: Skaffold konfiguriert die Synchronisierung automatisch. (nur für Jib- und Buildpacks-Artefakte.) Dies ist die Standardeinstellung für Buildpacks.
infer: Die Ziele für jede geänderte Datei werden vom Builder abgeleitet.
manual: Sie müssen die Dateien in Ihrem lokalen Arbeitsbereich und ihr Ziel im ausgeführten Container angeben.

Im folgenden Beispielabschnitt sync in einer skaffold.yaml-Datei wird eine manual-Synchronisierung angegeben, um alle HTML-Dateien vom Typ /static-html mit dem Ordner static in einem Container zu synchronisieren:

build:
  artifacts:
    - image: gcr.io/k8s-skaffold/node-example
      context: node
      sync:
        manual:
          - src: 'static-html/*.html'
            dest: static

Einen detaillierten Blick auf die Dateisynchronisierung und die Angabe von Synchronisierungsregeln finden Sie im Skaffold-Leitfaden zur Dateisynchronisierung.

Neue Features bei der Entwicklung in Kubernetes hinzufügen

Starten Sie nach dem Einrichten der Dateisynchronisierung und des Hot-Neuladevorgangs einen Iterationszyklus und fügen Sie Ihrem Projekt weitere Features hinzu. Ihre Änderungen werden in Ihrem Kubernetes-Cluster bereitgestellt, ohne dass die Bereitstellung beendet und entfernt, das Image manuell erstellt und getaggt oder der Cluster aktualisiert wird.

Ein Standard-Iterationszyklus sieht in etwa so aus:

Nehmen Sie eine Änderung an Ihrem Projekt vor. Wenn Sie beispielsweise die Cloud Code Java-Gästebuchanwendung verwenden, fügen Sie der Klasse FrontendController so einen neuen Endpunkt hinzu:
1. Öffnen Sie die Datei FrontendController.java in src/main/java/cloudcode/guestbook/frontend und fügen Sie Folgendes hinzu:
```
@RequestMapping("/greeting")
@ResponseBody
public String greeting(@RequestParam(value="name", defaultValue="World") String name) {
   return String.format("Hello from Kubernetes with IntelliJ, %s!", name);
}
```
2. Fügen Sie die erforderlichen Importe für die neuen Annotationen RequestMapping und ResponseBody hinzu.
Speichern Sie die Änderungen (Ctrl/Cmd+S) oder erstellen Sie das Projekt.

Im Konsolenfenster können Sie Fortschritts- und Bereitstellungslogs aufrufen. Nachdem die Änderungen bereitgestellt wurden, bestätigen Sie die Aktualisierungen.
Klicken Sie auf das Symbol Beenden, um die Sitzung der kontinuierlichen Entwicklung zu beenden.

Cloud Code löscht alle Kubernetes-Ressourcen, die für die Entwicklungssitzung verwendet wurden.

Mikrodienstanwendungen mit Skaffold-Konfigurationen entwickeln

Bei der Entwicklung von Mikrodienstanwendungen kann es nützlich sein, unabhängig an separaten Abschnitten zu arbeiten, um die Fehlerbehebung und Bereitstellung zu vereinfachen.

Sie können Teile Ihrer Anwendung unabhängig entwickeln und debuggen, indem Sie sie in Skaffold-Module aufteilen. Das Beispiel Bank of Anthos ist beispielsweise eine Anwendung mit zehn Mikrodiensten. Die Datei skaffold.yaml des Beispiels gruppiert diese Dienste in fünf Skaffold-Module mit den Namen setup, db, frontend, backend und loadgenerator.

Skaffold-Module und Konfigurationsabhängigkeiten definieren

So definieren Sie Skaffold-Module und Konfigurationsabhängigkeiten:

Öffnen Sie das Projekt, in dem Sie die Module definieren möchten.
Öffnen Sie die Datei skaffold.yaml.

Wenn die Datei skaffold.yaml mehrere Konfigurationen hat, geben Sie die folgende Zeile an, um eine Konfiguration zu einem Skaffold-Modul zu machen:

metadata:
  name: MODULE_NAME_1

In der Bank of Anthos skaffold.yaml definiert das Modul db beispielsweise Datenbankbereitstellungen:

apiVersion: skaffold/v3
kind: Config
metadata:
  name: db # module defining database deployments
requires:
- configs:
  - setup
build:
  artifacts:
  - image: accounts-db
    context: src/accounts-db
  - image: ledger-db
    context: src/ledger-db
manifests:
  rawYaml:
  - dev-kubernetes-manifests/accounts-db.yaml
  - dev-kubernetes-manifests/ledger-db.yaml
deploy:
  kubectl: {}

Bei Konfigurationen, die darauf angewiesen sind, dass eine andere Konfiguration bereitgestellt wird, bevor die aktuelle Konfiguration bereitgestellt werden kann, müssen Sie die Konfiguration zu Ihren Abhängigkeiten hinzufügen. Wenn Sie eine Konfigurationsabhängigkeit angeben möchten, fügen Sie dem Abschnitt requires der Datei skaffold.yaml eine configs-Liste hinzu.

Die skaffold.yaml-Datei der Bank of Anthos enthält beispielsweise die Konfigurationsabhängigkeit setup.

Um eine Abhängigkeit zu definieren, fügen Sie der Datei skaffold.yaml Folgendes hinzu, wobei DEPENDENCY_NAME der Name der Abhängigkeit ist.
```
requires:
    - configs: DEPENDENCY_NAME
```
Auf diese Weise aufgeführte Konfigurationen können auf Abhängigkeiten verweisen, die in derselben Datei oder in anderen skaffold.yaml-Dateien im aktuellen Projekt definiert sind.
Testen Sie die Konfigurationsabhängigkeiten. Erstellen Sie dazu jedes Skaffold-Modul separat und prüfen Sie, ob sie mit ihren Abhängigkeiten bereitgestellt werden. Folgen Sie dazu der Anleitung unter Bestimmte Skaffold-Module und deren Abhängigkeiten erstellen.

Spezifische Skaffold-Module und ihre Abhängigkeiten erstellen

Nachdem Sie Ihre Module und ihre Abhängigkeiten definiert haben, können Sie in der Datei launch.json angeben, welche Module mit Cloud-Code ausgeführt werden sollen.

Wenn für Ihr Projekt keine launch.json-Datei definiert ist, werden Sie beim Ausführen von Cloud Code: Run on Kubernetes oder Cloud Code: Debug on Kubernetes aufgefordert, die zu erstellenden Module auszuwählen:

Öffnen Sie die Befehlspalette (Ctrl/Cmd + Shift + P) und führen Sie dann Cloud Code: Run on Kubernetes aus.
Klicken Sie auf Module auswählen.
Wählen Sie die Module aus, die Sie bereitstellen möchten, und klicken Sie dann auf OK. Jedes Modul wird mit seinen Abhängigkeiten erstellt.
Wenn Sie dazu aufgefordert werden, wählen Sie eine Image-Registry aus und drücken Sie dann Enter.

Wenn Ihr Projekt eine launch.json hat, gehen Sie so vor, um die zu erstellenden Skaffold-Module auszuwählen:

Öffnen Sie die launch.json-Datei Ihres Projekts.

Bearbeiten Sie die Startkonfiguration und fügen Sie die Option skaffoldFlags mit einer durch Kommas getrennten Liste der zu erstellenden modules hinzu. Wenn skaffoldFlags weggelassen wird, werden alle Module erstellt.

  {
    "name": "Run on Kubernetes",
    "type": "cloudcode.kubernetes",
    "request": "launch",
    "skaffoldConfig": "${workspaceFolder}/skaffold.yaml",
    "skaffoldFlags": {
       "modules": ["MODULE_NAME_2,MODULE_NAME_2"],
    "watch": true,
    "cleanUp": true,
    }
  }

Führen Sie die bearbeitete Startkonfiguration aus.

Kontinuierliche Entwicklung in Kubernetes

Nachdem Sie das Ausführungsziel mit den gewünschten Optionen konfiguriert haben, können Sie entweder die Anwendung regelmäßig ausführen oder einen Entwicklungsiterationsprozess in Ihrer IDE starten, um alle an der Quelle und Abhängigkeiten vorgenommenen Änderungen an Ihre Live-Anwendung weiterzugeben.

Das Ausführungsziel Run on Kubernetes startet den Entwicklungszyklus auf Ihrem Kubernetes-Cluster. Nachdem Sie den Entwicklungszyklus gestartet haben, erstellt Cloud Code mit Skaffold ein Image für das Projekt, taggt es, überträgt es per Push in das konfigurierte Repository und stellt mithilfe von kubectl die Kubernetes-Manifeste des Projekts bereit.

Passen Sie Ihre Bereitstellung mit den verfügbaren Konfigurationsoptionen an.
Wenn Ihre Anwendung für die Verwendung von Skaffold-Modulen konfiguriert ist, können Sie bestimmte Module zum Erstellen oder Bereitstellen auswählen.
Öffnen Sie die Befehlspalette (drücken Sie Ctrl/Cmd+Shift + P) und führen Sie dann den Befehl Cloud Code: Auf Kubernetes ausführen aus.
Geben Sie an, ob Sie den aktuellen Kubernetes-Kontext zum Ausführen der Anwendung verwenden oder ob Sie zu einem bevorzugten Kontext wechseln möchten. Weitere Informationen zum Einrichten eines Kubernetes-Kontexts finden Sie unter Konfiguration einrichten.
Wenn Sie einen Remote-Cluster als Kontext ausgewählt haben, wählen Sie bei entsprechender Aufforderung eine Image-Registry aus, in die die Images übertragen werden sollen. Wenn Sie Container Registry verwenden, können Sie zu einer vorhandenen Registry suchen oder den Namen einer zu erstellenden Registry angeben. Wenn für Ihr Projekt die Artifact Registry API aktiviert und mindestens ein Artifact Registry-Repository aktiviert ist, können Sie ein vorhandenes Artifact Registry-Repository suchen und auswählen.

Anschließend erstellt Cloud Code Ihre Container, überträgt sie in die Registry, wendet Kubernetes-Konfigurationen auf den Cluster an und wartet auf den Rollout.

Nächste Schritte

Verwenden Sie den integrierten Minikube-Cluster von Cloud Code für die lokale Entwicklung.
Fehler in der Anwendung in Cloud Code beheben
Lesen Sie die Informationen zur Dateisynchronisierungsfunktion von Skafold.

Support anfragen

Wenn Sie Feedback geben möchten, können Sie Probleme auf GitHub melden oder eine Frage in Stack Overflow stellen.