Cette page a été traduite par l'API Cloud Translation.

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

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

Activer la synchronisation des fichiers Skaffold et le rechargement à chaud

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 apportez des modifications aux fichiers statiques et aux fichiers de code source, ces modifications prennent effet en quelques secondes, ce qui permet d'accélérer les boucles 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. Les modifications apportées aux types de fichiers non compatibles avec le rechargement à chaud déclenchent une recréation d'images et un redémarrage de 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 comme 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: Skaffold configure automatiquement la synchronisation. (uniquement pour les artefacts Jib et Buildpacks) Il s'agit de la valeur par défaut pour 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 Java Guestbook de Cloud Code, 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 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

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 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 des modules Skaffold et des 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 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 d'une autre configuration déployée avant le déploiement de la configuration actuelle, 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 correspond au 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 en cours.
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.

Compiler 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 dans l'onglet Build/Deploy (Compilation/Déploiement) lorsque vous sélectionnez Run > Edit configurations (Exécuter > Modifier les configurations).

Installez les derniers builds Insiders.
Accédez à Run > Edit configurations (Exécuter > Modifier les configurations) et ouvrez l'onglet Build/Deploy (Compilation/Déploiement).
Pour Configuration Skaffold, sélectionnez skaffold.yaml.

Choisissez l'une des options suivantes :
- Créer et déployer avec tous les modules et dépendances
- Compiler et déployer avec (si des modules sont disponibles) et sélectionnez les modules que vous souhaitez compiler et déployer.

Votre sélection est conservée pour les déploiements ultérieurs. Si vous sélectionnez un sous-ensemble de modules, Cloud Code affiche un avertissement sur le déploiement d'un sous-ensemble de modules plutôt que l'ensemble du système.

Développement continu sur Kubernetes

Une fois que vous avez configuré votre cible d'exécution avec les options souhaitées, vous pouvez opter pour une exécution régulière de votre application ou lancer un cycle d'itération de développement sur votre IDE pour propager à votre application active toute modification apportée à votre source et à vos dépendances.

La cible d'exécution Développer sur Kubernetes démarre le cycle de développement de votre cluster Kubernetes. Une fois le cycle de développement lancé, Cloud Code, à l'aide de Skaffold, crée une image pour le projet, lui ajoute un tag, la transmet au dépôt configuré et utilise kubectl pour déployer les manifestes Kubernetes du projet.

Cliquez sur l'icône Développer sur Kubernetes, puis sur Modifier les configurations pour ouvrir la boîte de dialogue Run/Debug Configurations (Configurations d'exécution/de débogage).
Personnalisez votre déploiement à l'aide des options de configuration disponibles.
Si vous souhaitez que Cloud Code redéploie automatiquement votre application après l'enregistrement de vos modifications, sous Mode de surveillance - recompilation et redéploiement, sélectionnez Lors de l'enregistrement du fichier. L'option À la demande est sélectionnée par défaut pour les nouvelles applications Kubernetes. Pour en savoir plus sur les modes de surveillance, consultez la section Modes de surveillance.
Si votre application est configurée pour utiliser des modules Skaffold, vous pouvez choisir de ne créer ou déployer que certains modules.
Une fois que vous êtes satisfait de votre configuration, cliquez sur OK, puis sur l'icône Run (Exécuter).

É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

Obtenir de l'aide

Pour envoyer des commentaires ou signaler un problème dans votre IDE IntelliJ, accédez à Outils > Cloud Code > Aide / À propos > Envoyer des commentaires ou signaler un problème pour signaler un problème sur GitHub.