Accélérez le développement dans Cloud Code pour Cloud Shell

Pour accélérer votre développement local dans Cloud Code pour Cloud Shell, utilisez la synchronisation de fichiers et l'actualisation à chaud, utilisez le déploiement automatique lors de l'enregistrement et développez des parties d'une application séparément à l'aide de modules Skaffold.

Activer la synchronisation des fichiers Skaffold et l'actualisation à chaud

Pour améliorer l'efficacité de votre workflow de développement local et éviter de devoir recompiler, redéployer et redémarrer vos pods, Skaffold vous permet de copier les fichiers modifiés dans un conteneur déployé. Cela signifie que lorsque vous apportez des modifications aux fichiers de code statique et source, vous pouvez voir que vos modifications prennent 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 l'actualisation à chaud configurée, Skaffold 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 l'actualisation à chaud déclenchent une recompilation 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 les autres compilateurs tels que Docker, vous pouvez spécifier une section sync dans le 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: Skaffold configure automatiquement la synchronisation. (uniquement pour les artefacts Jib et Buildpacks). Il s'agit de l'option par défaut pour Buildpacks.
  • infer: les destinations de chaque fichier modifié sont déduites de l'outil de création.
  • manual: vous devez spécifier les fichiers de votre espace de travail local et leur destination dans le conteneur en cours d'exécution.

L'exemple de section sync 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 des fonctionnalités lors du développement sur Kubernetes

Après avoir configuré la synchronisation des fichiers et l'actualisation à chaud, démarrez un cycle d'itérations et ajoutez des fonctionnalités à votre projet. Vos modifications sont déployées sur votre cluster Kubernetes sans arrêter ni supprimer le déploiement, sans créer ni taguer manuellement l'image.

Un cycle d'itération standard se présente comme suit:

  1. Effectuez une modification dans votre projet. Par exemple, si vous utilisez l'application de livre d'or Java Cloud Code, ajoutez un nouveau point de terminaison à la classe FrontendController comme suit:

    1. Ouvrez le fichier FrontendController.java à partir de src/main/java/cloudcode/guestbook/frontend et ajoutez le code suivant:

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

  2. Enregistrez vos modifications (Ctrl/Cmd+S) ou créez 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.

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

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

Vous pouvez développer et déboguer des parties de votre application indépendamment en la divisant en modules Skaffold. 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 skaffold nommés setup, db, frontend, backend et loadgenerator.

Définir les modules Skaffold et les dépendances de configuration

Pour définir des modules Skaffold et des dépendances de configuration, procédez comme suit :

  1. Ouvrez le projet dans lequel vous souhaitez définir les modules.

  2. Ouvrez le fichier skaffold.yaml.

  3. Si votre fichier skaffold.yaml comporte plusieurs configurations, spécifiez la ligne suivante pour en faire un module Skaffold:

    metadata:
      name: MODULE_NAME_1
    

    Par exemple, dans la skaffold.yaml de la banque d'Anthos, le module db définit des déploiements de bases 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: {}
  4. Pour les configurations qui reposent sur le déploiement d'une autre configuration avant que la configuration actuelle ne puisse être déployée, 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 le code suivant à votre fichier skaffold.yaml, où DEPENDENCY_NAME correspond au nom de la 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.

  5. Testez vos dépendances de configuration en créant chacun des modules Skaffold séparément pour vous assurer qu'ils sont déployés avec leurs dépendances en suivant la procédure décrite dans Créer des modules Skaffold spécifiques et leurs dépendances.

Créer des modules Skaffold spécifiques et leurs dépendances

Après avoir défini vos modules et leurs dépendances, vous pouvez spécifier les modules que vous souhaitez exécuter avec du code cloud dans votre fichier launch.json.

Si aucun fichier launch.json n'est défini pour votre projet, lorsque vous exécutez Cloud Code: Run on Kubernetes ou Cloud Code: Debug on Kubernetes, vous êtes invité à sélectionner les modules à compiler:

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

Si votre projet dispose d'un launch.json, procédez comme suit pour choisir les modules Skaffold à créer:

  1. Ouvrez le fichier launch.json de votre projet.

  2. Modifiez la configuration de lancement pour ajouter l'option skaffoldFlags avec une liste de modules séparés par une virgule. 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,
        }
      }
    
  3. 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 soit exécuter une exécution régulière de votre application, soit lancer un cycle de développement sur votre IDE pour propager les modifications apportées à votre source et aux dépendances de votre application active.

La cible d'exécution Run on Kubernetes (Exécuter sur Kubernetes) démarre le cycle de développement sur votre cluster Kubernetes. Une fois que vous avez démarré le cycle de développement, Cloud Code utilise Skaffold, crée une image pour le projet, le tague, la transfère dans le dépôt configuré et utilise kubectl pour déployer les fichiers manifestes Kubernetes du projet.

  1. Personnalisez votre déploiement à l'aide des options de configuration disponibles.
  2. Si votre application est configurée pour utiliser des modules Skaffold, vous pouvez sélectionner des modules spécifiques à compiler ou à déployer.
  3. 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).
  4. 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.
  5. Si vous avez choisi un cluster distant comme contexte, lorsque vous y êtes invité, choisissez un registre d'images vers lequel transférer les images. Si vous utilisez Container Registry, vous pouvez accéder à un registre existant ou spécifier le nom d'un registre à créer. Si l'API Artifact Registry est activée dans votre projet et que vous disposez d'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