Pour accélérer votre développement local dans Cloud Code pour VS Code, profitez de la synchronisation de fichiers et du rechargement à chaud, du déploiement automatique à l'enregistrement et des modules Skaffold pour développer des parties d'une application séparément.
Activer la synchronisation des fichiers et le hot reload Skaffold
Pour améliorer l'efficacité de votre workflow de développement local et éviter de devoir recréer, redéployer et redémarrer vos pods, Skaffold permet de copier des fichiers modifiés vers un conteneur déployé. Ainsi, lorsque vous modifiez des données statiques et les fichiers de code source, les modifications sont appliquées en quelques secondes 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é, Skaffold détecte les modifications apportées aux fichiers compatibles et les synchronise avec le conteneur en cours d'exécution sur votre cluster. Modifications apportées aux types de fichiers non compatibles avec la version à chaud et l'actualisation déclenche 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 d'autres constructeurs tels que
Docker, vous pouvez spécifier une section sync
dans votre fichier skaffold.yaml
pour l'élément
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 Jib et Buildpacks) artifacts.) Il s'agit du paramètre 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.
L'exemple de section sync
suivant tiré d'un fichier skaffold.yaml
spécifie une synchronisation manual
afin de 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 le rechargement à chaud, 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 arrêter ni supprimer le déploiement, sans créer d'image ni ajouter de tags manuellement, et sans mettre à jour le cluster.
Un cycle d'itération standard se présente comme suit:
Apportez une modification à votre projet. Par exemple, si vous utilisez l'application de livre d'or Java Cloud Code, ajoutez un point de terminaison au
FrontendController
comme suit:Ouvrez le fichier
FrontendController.java
depuissrc/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); }
Ajoutez les importations nécessaires pour les nouvelles annotations,
RequestMapping
etResponseBody
.
Enregistrez les 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
Lors du développement d'applications de microservices, il peut être utile de travailler sur des de façon indépendante pour simplifier le débogage et le déploiement.
Vous pouvez développer et déboguer indépendamment différentes parties de votre application en la divisant en plusieurs 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 en 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 :
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 créer un module Skaffold à partir d'une configuration :metadata: name: MODULE_NAME_1
Par exemple, dans le
skaffold.yaml
de Bank of Anthos, le moduledb
définit les déploiements de base de données :Pour les configurations qui reposent sur une autre configuration déployée avant la configuration actuelle peut être déployée, vous devez ajouter la configuration les dépendances. Pour spécifier une dépendance de configuration, ajoutez une liste
configs
aurequires
de votre fichierskaffold.yaml
.Par exemple, le fichier
skaffold.yaml
de la banque d'Anthos inclut la dépendance de configurationsetup
.Pour définir une dépendance, ajoutez ce qui suit à votre fichier
skaffold.yaml
, où DEPENDENCY_NAME correspond au nom de votre dépendance.requires: - configs: DEPENDENCY_NAME
Les configurations répertoriées de cette façon peuvent faire référence aux dépendances définies dans le même fichier ou d'autres fichiers
skaffold.yaml
dans le projet actuel.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. Pour ce faire, suivez la procédure décrite sur la page Compiler des modules Skaffold spécifiques et leurs dépendances.
Créer des modules Skaffold 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 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: 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. Les dépendances correspondantes sont intégrées dans chaque module.
- 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 le Skaffold
modules à créer:
Ouvrez le fichier
launch.json
de votre projet.Modifiez la configuration de lancement pour ajouter l'option
skaffoldFlags
avec une liste demodules
séparés par une virgule à créer. SiskaffoldFlags
est omis, tous les modules sont compilé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 de votre choix, vous pouvez opter pour une exécution régulière de votre application ou lancer une phase de développement d'itération sur votre IDE pour propager les modifications apportées à votre source les dépendances à votre application active.
La cible d'exécution Run on Kubernetes (Exécuter sur Kubernetes) démarre le cycle de développement de votre cluster Kubernetes. Une fois le cycle de développement lancé, À l'aide de Skaffold, Cloud Code crée une image pour la du projet, lui ajoute un tag, le transfère dans le dépôt configuré et l'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 modules Skaffold, vous pouvez sélectionner des modules spécifiques à créer 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, choisissez une image lorsque vous y êtes invité 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 votre projet a API Artifact Registry activée et au minimum un dépôt Artifact Registry, peut 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.
Étape suivante
- Utilisez le cluster Minikube intégré de Cloud Code pour le développement local.
- Déboguer votre application dans Cloud Code
- En savoir plus sur la fonctionnalité de synchronisation de fichiers de Skaffold