Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklung in Cloud Code for VS Code beschleunigen

Um Ihre lokale Entwicklung in Cloud Code for VS Code zu beschleunigen, nutzen Sie Synchronisierung und Hot Refresh, automatische Bereitstellung beim Speichern und Verwenden von Skaffold-Modulen um Teile einer Anwendung separat zu entwickeln.

Skaffold-Dateisynchronisierung und Hot Refresh aktivieren

Um die Effizienz Ihres lokalen Entwicklungs-Workflows zu verbessern und Ihre Pods neu erstellen, bereitstellen und neu starten müssen, unterstützt Skaffold Kopieren der geänderten Dateien in einen bereitgestellten Container Wenn Sie also Änderungen an statischen und Quellcodedateien arbeiten, können Sie sehen, dass Ihre Änderungen in Sekundenschnelle wirksam werden, was zu einer beschleunigten Feedback Loop ein.

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 Reload konfiguriert ist, erkennt Skaffold Änderungen an unterstützten Dateien und synchronisiert diese Änderungen mit dem ausgeführten Container in Ihrem Cluster. Änderungen an Dateitypen, die keine Hotline unterstützen neu erstellen und Pod-Neustart auslösen.

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 Datei skaffold.yaml einen sync-Abschnitt für das anzupassende Artefakt angeben.

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 laufenden Container angeben.

Der folgende Beispielabschnitt sync in einer skaffold.yaml-Datei gibt eine manual synchronisieren, um alle /static-html-HTML-Dateien mit static zu synchronisieren Ordner in einem Container:

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 bei der Entwicklung auf Kubernetes hinzufügen

Nachdem Sie die Dateisynchronisierung und das Hot Reloading eingerichtet haben, starten Sie einen Iterationszyklus und fügen Sie Ihrem Projekt weitere Funktionen hinzu. Ihre Änderungen werden in Ihrem Kubernetes-Cluster bereitgestellt, ohne dass dadurch das Deployment angehalten oder entfernt, das Image manuell erstellt und mit Tags versehen oder der Cluster aktualisiert werden muss.

Ein standardmäßiger Iterationszyklus sieht in etwa so aus:

Nehmen Sie eine Änderung an Ihrem Projekt vor. Wenn Sie z. B. die Methode Cloud Code Java Guestbook-Anwendung einen neuen Endpunkt zum FrontendController so:
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.
Speichern Sie die Änderungen (Ctrl/Cmd+S) oder erstellen Sie das Projekt.

Im Konsolenfenster können Sie Fortschritts- und Bereitstellungslogs aufrufen. Bestätigen Sie die Updates, nachdem die Änderungen bereitgestellt wurden.
Klicken Sie zum Beenden der kontinuierlichen Entwicklungssitzung auf das Symbol Beenden.

Cloud Code löscht alle für die Entwicklungssitzung verwendeten Kubernetes-Ressourcen.

Mikrodienstanwendungen mit Skaffold-Konfigurationen entwickeln

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

Sie können Teile Ihrer Anwendung unabhängig entwickeln und debuggen, indem Sie Skaffold-Module hinzufügen. Beispiel: Der Parameter Beispiel für Bank of Anthos ist eine Anwendung mit zehn Mikrodiensten. Das Beispiel skaffold.yaml diese Dienste in fünf Skaffold-Module namens 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 Ihre skaffold.yaml-Datei mehrere Konfigurationen hat, Konfigurieren Sie ein Skaffold-Modul, indem Sie die folgende Zeile angeben:

metadata:
  name: MODULE_NAME_1

In der Bank of Anthos-skaffold.yaml-Umgebung wird beispielsweise im db-Modul die Datenbankbereitstellung 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 auf einer anderen Konfiguration basieren, bevor die aktuelle Konfiguration bereitgestellt werden kann, müssen Sie die Konfiguration den Abhängigkeiten hinzufügen. Wenn Sie eine Konfigurationsabhängigkeit angeben möchten, fügen Sie dem Abschnitt requires der Datei skaffold.yaml eine Liste vom Typ configs hinzu.

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

Zum Definieren einer Abhängigkeit fügen Sie der Datei skaffold.yaml Folgendes hinzu: DEPENDENCY_NAME ist der Name der Abhängigkeit.
```
requires:
    - configs: DEPENDENCY_NAME
```
Auf diese Weise aufgelistete Konfigurationen können auf Abhängigkeiten verweisen, die in derselben Datei oder in anderen skaffold.yaml-Dateien im aktuellen Projekt definiert sind.
Testen Sie Ihre Konfigurationsabhängigkeiten, indem Sie jedes Skaffold-Modul separat erstellen. So können Sie prüfen, ob diese mit ihren Abhängigkeiten bereitgestellt werden. Führen Sie dazu die Schritte unter Bestimmte Skaffold-Module und ihre Abhängigkeiten erstellen aus.

Bestimmte Skaffold-Module und ihre Abhängigkeiten erstellen

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

Wenn für Ihr Projekt keine launch.json-Datei definiert ist, führen Sie 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: In Kubernetes ausführen
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 das Skaffold auszuwählen. zu erstellende Module:

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

Bearbeiten Sie die Startkonfiguration und fügen Sie die Option skaffoldFlags mit einem Durch Kommas getrennte Liste von modules, die erstellt werden sollen. 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 die Anwendung entweder regelmäßig ausführen oder einen Entwicklungsdurchlauf in Ihrer IDE starten, um eventuelle Änderungen an der Quelle und Abhängigkeiten in die Live-Anwendung zu übernehmen.

Das Ausführungsziel Auf Kubernetes ausführen startet den Entwicklungszyklus für einen Kubernetes-Cluster. Nachdem Sie den Entwicklungszyklus gestartet haben, erstellt Cloud Code mit Skaffold ein Image für das Projekt, fügt es dann hinzu, überträgt es per Push in das konfigurierte Repository und stellt mit kubectl die Kubernetes-Manifeste des Projekts bereit.

Passen Sie die Bereitstellung mit den verfügbaren Konfigurationsoptionen an.
Wenn Ihre Anwendung für die Verwendung von Skaffold-Module können Sie Sie können 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 ein Image aus Registry, in die die Images übertragen werden sollen. Wenn Sie Container Registry verwenden, können Sie eine vorhandene Registry aufrufen oder den Namen einer zu erstellenden Registry angeben. Wenn für Ihr Projekt die Artifact Registry API aktiviert ist und es mindestens ein Artifact Registry-Repository gibt, können Sie ein vorhandenes Artifact Registry-Repository aufrufen 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

Integrierte Cloud Code-Funktionen verwenden Minikube-Cluster für die lokale Entwicklung.
Fehler in der Anwendung in Cloud Code beheben
Lesen Sie die Details zu Skaffold-Funktion zur Dateisynchronisierung

Support anfragen

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