Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Entwicklung in Cloud Code for VS Code beschleunigen

Um die lokale Entwicklung in Cloud Code für VS Code zu beschleunigen, können Sie die Dateisynchronisierung und das Hot Reloading nutzen, die automatische Bereitstellung beim Speichern aktivieren und Module verwenden, um Teile einer Anwendung separat zu entwickeln.

Dateisynchronisierung und Hot Reload aktivieren

Um die Effizienz Ihres lokalen Entwicklungs-Workflows zu verbessern und zu vermeiden, dass Sie Ihre Pods neu erstellen, neu bereitstellen und neu starten müssen, unterstützt Cloud Code das Kopieren geänderter Dateien in einen bereitgestellten Container. Wenn Sie Änderungen an statischen Dateien und Quellcodedateien vornehmen, können Sie die Auswirkungen der Änderungen innerhalb von Sekunden sehen. Das beschleunigt den Feedbackzyklus.

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 Hot Reloading konfiguriert ist, erkennt Cloud Code Änderungen an unterstützten Dateien und synchronisiert diese Änderungen mit dem laufenden Container in Ihrem Cluster. Änderungen an Dateitypen, die kein Hot Reloading unterstützen, lösen einen Image-Neubau und einen 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 in der skaffold.yaml-Datei einen sync-Abschnitt für das anzupassende Artefakt angeben.

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

auto: Cloud Code 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 laufenden Container angeben.

Im folgenden Beispiel für den Abschnitt sync in einer skaffold.yaml-Datei wird eine manual-Synchronisierung angegeben, um alle /static-html-HTML-Dateien 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 Funktionen beim Entwickeln auf Kubernetes hinzufügen

Nachdem Sie die Dateisynchronisierung und das Hot Reloading eingerichtet haben, können Sie mit dem Iterationszyklus beginnen und Ihrem Projekt weitere Funktionen hinzufügen. Ihre Änderungen werden in Ihrem Kubernetes-Cluster bereitgestellt, ohne dass das Deployment beendet und entfernt, das Image manuell erstellt und getaggt oder der Cluster aktualisiert werden muss.

Ein standardmäßiger Iterationszyklus sieht so aus:

Nehmen Sie eine Änderung an Ihrem Projekt vor. Wenn Sie beispielsweise die Cloud Code-Java-Gästebuch-App verwenden, fügen Sie der Klasse FrontendController einen neuen Endpunkt hinzu:
1. Öffnen Sie die Datei FrontendController.java aus 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 Ihre Änderungen (Ctrl/Cmd+S) oder erstellen Sie das Projekt.

Sie können den Fortschritt und die Bereitstellungslogs im Konsolenfenster verfolgen. Bestätigen Sie die Aktualisierungen, nachdem die Änderungen bereitgestellt wurden.
Klicken Sie zum Beenden der kontinuierlichen Entwicklungssitzung auf das Symbol Beenden.

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

Mikrodienstanwendungen mit `skaffold.yaml`-Konfigurationen entwickeln

Bei der Entwicklung von Mikrodienstanwendungen kann es hilfreich sein, unabhängig an einzelnen Abschnitten zu arbeiten, um die Fehlerbehebung und Bereitstellung zu vereinfachen.

Wenn Sie Ihre Anwendung in Module aufteilen, können Sie Teile der Anwendung unabhängig voneinander entwickeln und debuggen. Die Bank of Anthos-Beispielanwendung enthält beispielsweise zehn Mikrodienste. In der Datei skaffold.yaml des Beispiels werden diese Dienste in fünf Module mit den Namen setup, db, frontend, backend und loadgenerator gruppiert.

Module und Konfigurationsabhängigkeiten definieren

So definieren Sie Module und Konfigurationsabhängigkeiten:

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

Wenn Ihre skaffold.yaml-Datei mehrere Konfigurationen enthält und Sie eine Konfiguration zu einem Modul machen möchten, geben Sie die folgende Zeile an:

metadata:
  name: MODULE_NAME_1

Im skaffold.yaml der Bank of Anthos werden beispielsweise mit dem Modul db Datenbankbereitstellungen definiert:

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 Ihren Abhängigkeiten hinzufügen. Wenn Sie eine Konfigurationsabhängigkeit angeben möchten, fügen Sie der Datei skaffold.yaml im Abschnitt requires eine configs-Liste hinzu.

Die Datei skaffold.yaml 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
```
Konfigurationen, die auf diese Weise aufgeführt werden, 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, indem Sie jedes der Module separat erstellen, um sicherzustellen, dass sie mit ihren Abhängigkeiten bereitgestellt werden. Folgen Sie dazu der Anleitung unter Bestimmte Module und ihre Abhängigkeiten erstellen.

Bestimmte Module und ihre Abhängigkeiten erstellen

Nachdem Sie Ihre Module und ihre Abhängigkeiten definiert haben, können Sie in Ihrer launch.json-Datei angeben, welche Module Sie mit Cloud-Code ausführen möchten.

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

Öffnen Sie die Befehlspalette (Ctrl/Cmd + Shift + P) und führen Sie dann Cloud Code: Auf Kubernetes ausführen 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 ein launch.json hat, gehen Sie so vor, um die zu erstellenden Module auszuwählen:

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

Bearbeiten Sie die Startkonfiguration, um die Option skaffoldFlags mit einer kommagetrennten Liste der zu erstellenden modules hinzuzufügen. 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 einen regulären Lauf Ihrer Anwendung ausführen oder einen Entwicklungszyklus in Ihrer IDE starten, um alle Änderungen, die Sie an Ihrem Quellcode und Ihren Abhängigkeiten vorgenommen haben, in Ihre Live-Anwendung zu übertragen.

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

Passen Sie die Bereitstellung mit den verfügbaren Konfigurationsoptionen an.
Wenn Ihre Anwendung für die Verwendung von 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 Aufforderung eine Bildregistrierung aus, in die die Bilder übertragen werden sollen. Wenn in Ihrem Projekt die Artifact Registry API aktiviert ist und mindestens ein Artifact Registry-Repository vorhanden ist, können Sie ein vorhandenes Artifact Registry-Repository 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.
Anwendung in Cloud Code debuggen
Weitere Informationen zur Dateisynchronisierung

Support anfragen

Wenn Sie Feedback geben möchten, stellen Sie eine Frage in Stack Overflow. Wenn Sie Google Cloud-Kunde sind, können Sie Tickets über die Standard-Supportkanäle von Google Cloud einreichen.

Entwicklung in Cloud Code for VS Code beschleunigen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.