Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Accélérer le développement dans Cloud Code pour VS Code

Pour accélérer votre développement local dans Cloud Code pour VS Code, profitez de la synchronisation des fichiers et du rechargement à chaud, du déploiement automatique à l'enregistrement et utilisez des modules pour développer des parties d'une application séparément.

Activer la synchronisation des fichiers et le rechargement à chaud

Pour améliorer l'efficacité de votre workflow de développement local et éviter d'avoir à reconstruire, redéployer et redémarrer vos pods, Cloud Code permet de copier les fichiers modifiés dans un conteneur déployé. Cela signifie que lorsque vous modifiez des fichiers de code source et statiques, vous pouvez voir vos modifications prendre effet en quelques secondes, ce qui accélère la boucle de rétroaction.

Pour les fichiers statiques (tels que les fichiers HTML et CSS), ce comportement de copie de fichiers est appelé synchronisation de fichiers.

Pour les fichiers de code source, ce comportement est appelé rechargement à chaud et est compatible avec les types de fichiers suivants :

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

Une fois le rechargement à chaud configuré, Cloud Code détecte les modifications apportées aux fichiers compatibles et les synchronise avec le conteneur en cours d'exécution sur votre cluster. Les modifications apportées aux types de fichiers qui ne sont pas compatibles avec le hot reload déclenchent une reconstruction de l'image et un redémarrage du pod.

La synchronisation automatique des fichiers et le rechargement à chaud sont activés par défaut lorsque vous utilisez Buildpacks comme compilateur préféré. Pour d'autres compilateurs tels que Docker, vous pouvez spécifier une section sync dans votre fichier skaffold.yaml pour l'artefact que vous personnalisez.

Vous pouvez choisir l'un des paramètres de synchronisation suivants (par ordre de préférence) :

auto : Cloud Code configure automatiquement la synchronisation. (uniquement pour les artefacts Jib et Buildpacks) Il s'agit de la valeur par défaut pour les buildpacks.
infer : Les destinations de chaque fichier modifié sont déduites du compilateur.
manual : vous devez spécifier les fichiers de votre espace de travail local et leur destination dans le conteneur en cours d'exécution.

La section sync suivante d'un fichier skaffold.yaml spécifie une synchronisation manual pour synchroniser tous les fichiers HTML /static-html avec le dossier static d'un conteneur :

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

Pour en savoir plus sur la synchronisation des fichiers et la spécification des règles de synchronisation, consultez le guide Skaffold sur la synchronisation des fichiers.

Ajouter de nouvelles fonctionnalités lors du développement sur Kubernetes

Après avoir configuré la synchronisation des fichiers et le hot reload, lancez un cycle d'itération et ajoutez d'autres fonctionnalités à votre projet. Vos modifications sont déployées sur votre cluster Kubernetes sans que vous ayez à arrêter ni supprimer le déploiement, à créer et taguer manuellement l'image, ni à mettre à jour le cluster.

Un cycle d'itération standard ressemble à ce qui suit :

Apportez une modification à votre projet. Par exemple, si vous utilisez l'application Cloud Code Java Guestbook, ajoutez un point de terminaison à la classe FrontendController comme suit :
1. Ouvrez le fichier FrontendController.java à partir de src/main/java/cloudcode/guestbook/frontend et ajoutez ce qui suit :
```
@RequestMapping("/greeting")
@ResponseBody
public String greeting(@RequestParam(value="name", defaultValue="World") String name) {
   return String.format("Hello from Kubernetes with IntelliJ, %s!", name);
}
```
2. Ajoutez les importations nécessaires pour les nouvelles annotations, RequestMapping et ResponseBody.
Enregistrez vos modifications (Ctrl/Cmd+S) ou compilez le projet.

Vous pouvez suivre les journaux de progression et de déploiement dans la fenêtre de la console. Une fois les modifications déployées, confirmez les mises à jour.
Pour mettre fin à la session de développement continu, cliquez sur l'icône Arrêter.

Cloud Code supprime toutes les ressources Kubernetes utilisées pour la session de développement.

Développer des applications de microservices à l'aide de configurations `skaffold.yaml`

Lorsque vous développez des applications de microservices, il peut être utile de travailler sur des sections distinctes de manière indépendante pour simplifier le débogage et le déploiement.

Vous pouvez développer et déboguer des parties de votre application de manière indépendante en la divisant en modules. Par exemple, l'exemple Bank of Anthos est une application contenant dix microservices. Le fichier skaffold.yaml de l'exemple regroupe ces services dans cinq modules nommés setup, db, frontend, backend et loadgenerator.

Définir des modules et des dépendances de configuration

Pour définir des modules et des dépendances de configuration :

Ouvrez le projet dans lequel vous souhaitez définir les modules.
Ouvrez le fichier skaffold.yaml.

Si votre fichier skaffold.yaml comporte plusieurs configurations, spécifiez la ligne suivante pour qu'une configuration devienne un module :

metadata:
  name: MODULE_NAME_1

Par exemple, dans skaffold.yaml Bank of Anthos, le module db définit les déploiements de base de données :

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: {}

Pour les configurations qui dépendent du déploiement d'une autre configuration avant de pouvoir être déployées, vous devez ajouter la configuration à vos dépendances. Pour spécifier une dépendance de configuration, ajoutez une liste configs à la section requires de votre fichier skaffold.yaml.

Par exemple, le fichier skaffold.yaml de la Banque d'Anthos inclut la dépendance de configuration setup.

Pour définir une dépendance, ajoutez ce qui suit à votre fichier skaffold.yaml, où DEPENDENCY_NAME est le nom de votre dépendance.
```
requires:
    - configs: DEPENDENCY_NAME
```
Les configurations listées de cette manière peuvent faire référence à des dépendances définies dans le même fichier ou dans d'autres fichiers skaffold.yaml du projet actuel.
Testez vos dépendances de configuration en compilant chacun des modules séparément pour vous assurer qu'ils sont déployés avec leurs dépendances. Pour ce faire, suivez les étapes décrites dans Compiler des modules spécifiques et leurs dépendances.

Compiler des modules spécifiques et leurs dépendances

Une fois que vous avez défini vos modules et leurs dépendances, vous pouvez spécifier les modules que vous souhaitez exécuter avec le code cloud dans votre fichier launch.json.

Si votre projet ne comporte pas de fichier launch.json défini, lorsque vous exécutez Cloud Code : Exécuter sur Kubernetes ou Cloud Code : Déboguer sur Kubernetes, vous êtes invité à sélectionner les modules à compiler :

Ouvrez la palette de commandes (Ctrl/Cmd+Shift+P), puis exécutez Cloud Code : Exécuter sur Kubernetes.
Cliquez sur Sélectionner des modules.
Choisissez les modules que vous souhaitez déployer, puis cliquez sur OK. Chaque module est créé avec ses dépendances.
Lorsque vous y êtes invité, choisissez un registre d'images puis appuyez sur Enter.

Si votre projet comporte un launch.json, procédez comme suit pour choisir les modules à compiler :

Ouvrez le fichier launch.json de votre projet.

Modifiez la configuration de lancement pour ajouter l'option skaffoldFlags avec une liste de modules à compiler, séparée par des virgules. Si skaffoldFlags est omis, tous les modules sont créés.

  {
    "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,
    }
  }

Exécutez la configuration de lancement que vous avez modifiée.

Développement continu sur Kubernetes

Une fois que vous avez configuré votre cible d'exécution avec les options souhaitées, vous pouvez choisir d'exécuter votre application de manière régulière ou de démarrer un cycle d'itération de développement sur votre IDE pour propager les modifications apportées à votre source et à vos dépendances à votre application en direct.

La cible d'exécution Run on Kubernetes (Exécuter sur Kubernetes) lance le cycle de développement sur votre cluster Kubernetes. Une fois le cycle de développement lancé, Cloud Code crée une image pour le projet, puis la taggue, la transfère vers le dépôt configuré et utilise kubectl pour déployer les fichiers manifestes Kubernetes du projet.

Personnalisez votre déploiement à l'aide des options de configuration disponibles.
Si votre application est configurée pour utiliser des modules, vous pouvez sélectionner des modules spécifiques à compiler ou à déployer.
Ouvrez la palette de commandes (Ctrl/Cmd+Shift+P), puis exécutez la commande Cloud Code : Run on Kubernetes (Cloud Code : Exécuter sur Kubernetes).
Confirmez que vous souhaitez utiliser le contexte Kubernetes actuel pour exécuter l'application (ou basculez vers le contexte de votre choix). Pour en savoir plus sur la définition d'un contexte Kubernetes, consultez la section Définir la configuration.
Si vous avez choisi un cluster distant comme contexte, sélectionnez un registre d'images vers lequel transférer les images lorsque vous y êtes invité. Si l'API Artifact Registry est activée dans votre projet et qu'il comporte au moins un dépôt Artifact Registry, vous pouvez accéder à un dépôt Artifact Registry existant et le sélectionner.

Cloud Code crée ensuite vos conteneurs, les transfère dans le registre, applique les configurations Kubernetes au cluster et attend le déploiement.

Étapes suivantes

Utilisez le cluster Minikube intégré à Cloud Code pour le développement local.
Déboguer votre application dans Cloud Code
En savoir plus sur la fonctionnalité de synchronisation des fichiers

Obtenir de l'aide

Pour envoyer des commentaires, posez une question sur Stack Overflow. Si vous êtes un client Google Cloud, vous pouvez envoyer des demandes via les canaux d'assistance Google Cloud standards.

Accélérer le développement dans Cloud Code pour VS Code Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.