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

Premiers pas avec Skaffold dans Cloud Deploy

Ce document explique comment commencer à utiliser Skaffold. dans le cadre de Cloud Deploy, y compris les éléments suivants:

Configurer Skaffold pour une utilisation avec un pipeline de livraison Cloud Deploy
Utilisation de Skaffold et de Cloud Deploy avec des outils de rendu tiers, tels que Helm et Kustomize
Si vous le souhaitez, utiliser Skaffold pour le développement local
Éventuellement, en utilisant Skaffold pour l'intégration et le déploiement continus (CI/CD)

Pourquoi utiliser Skaffold ?

Vous voulez savoir pourquoi Cloud Deploy utilise Skaffold et pourquoi vous devez gérer une configuration Skaffold ? Lisez la suite.

J'ai de l'expérience en CI/CD, mais je n'utilise pas Skaffold actuellement

Skaffold est un outil de ligne de commande Open Source qui améliore la productivité des développeurs. Il orchestre le développement continu, l'intégration continue (CI) et la livraison continue (CD).

Skaffold fournit une configuration déclarative et portable, à l'aide d'un plug-in ce qui vous permet d'utiliser différents outils pour la phase de rendu.

Lorsqu'une version est créée, Cloud Deploy appelle Skaffold pour afficher vos fichiers manifestes. Au moment du déploiement, Cloud Deploy appelle à nouveau Skaffold pour appliquer ces fichiers manifestes afin de déployer votre application sur chaque cible de votre progression. Après le déploiement, Skaffold effectue des vérifications de l'état pour surveiller l'exécution de la cible le déploiement.

Skaffold pour le développement continu

Lorsque vous utilisez Skaffold pour le développement continu, les images sont créées, testées et déployées sur un cluster (ou Minikube) à mesure que vous modifiez votre code. Les extensions d'IDE Cloud Code for VS Code et Cloud Code for IntelliJ intègrent Skaffold aux IDE Visual Studio Code et JetBrains pour le développement continu.

Skaffold pour la livraison continue

Vous pouvez également utiliser Skaffold pour la livraison continue, avec les étapes de compilation, de déploiement, de rendu et d'application. Cloud Deploy utilise Effectuer le rendu et l'application de Skaffold des fonctionnalités. Pour utiliser Cloud Deploy, vous devez disposer d'au moins un fichier de configuration skaffold.yaml valide.

Avec Skaffold, vous pouvez également intégrer des outils de gestion de fichiers manifestes tiers, tels que Helm et Kustomize. Utiliser Skaffold de cette manière vous permet d'utiliser les fonctionnalités de ces outils pour afficher des fichiers manifestes. kubectl reste le déploieur de ces fichiers manifestes.

Je ne sais pas comment déployer sur Kubernetes

Avec Skaffold, vous pouvez configurer un ensemble de fichiers manifestes de base pour tous vos déploiements. Vous pouvez ensuite utiliser le moteur de rendu de Skaffold via Cloud Deploy, afficher, puis déployer chaque fichier manifeste spécifique au déploiement à partir de l'un de ces des fichiers manifestes de base.

Découvrez comment gérer les fichiers manifestes, y compris des exemples d'utilisation de Skaffold et de Cloud Deploy avec des outils de création de modèles de fichiers manifestes courants, tels que Helm et Kustomize.

Quels sont les éléments requis pour que Cloud Deploy fonctionne ?

Pour utiliser un pipeline de livraison Cloud Deploy de base, Fichier de configuration skaffold.yaml requiert au moins la configuration suivante:

Informations d'en-tête dont toutes les configurations skaffold.yaml ont besoin:
```
apiVersion: skaffold/v4beta7
kind: Config
```
Un bloc manifests, pour GKE, GKE Enterprise ou Cloud Run listant tous les fichiers manifestes Kubernetes bruts (sauf si vous utilisez un de gestion des fichiers manifestes, comme Helm ou Kustomize).

Voici un exemple utilisant un fichier manifeste Kubernetes brut :
```
manifests:
  rawYaml:
  - deployment.yaml
```
Si vous prévoyez d'utiliser un moteur de rendu (comme Helm ou Kustomize) pour afficher les fichiers manifestes, Voir la page Ajouter la compatibilité avec Helm à votre fichier skaffold.yaml et ajouter la prise en charge de Kustomize à votre fichier skaffold.yaml. pour savoir comment configurer Skaffold pour utiliser ces outils.

Pour obtenir des exemples Helm et Kustomize, consultez Gérer les fichiers manifestes
Un bloc deploy, avec deploy.kubectl, pour le déploiement sur GKE ou GKE Enterprise, ou deploy.cloudrun pour le déploiement à Cloud Run.

Pour les cibles GKE et GKE Enterprise:
```
deploy:
  kubectl: {}
```
Le bloc de déploiement déploie les fichiers manifestes d'application fournis dans le les fichiers manifestes.

Pour les cibles Cloud Run :
```
deploy:
  cloudrun: {}
```
La section "déploiement" déploie les fichiers manifestes d'application fournis dans la section "fichiers manifestes".

Si vous utilisez des cibles personnalisées, vos skaffold.yaml doit comporter l'en-tête (apiVersion et kind:), ainsi que les actions personnalisées que la cible personnalisée utilisera si le type de cible personnalisée ne dispose pas déjà référencer une configuration Skaffold distante.

Créez un fichier `skaffold.yaml`.

Cloud Deploy utilise Skaffold pour le rendu et le déploiement de vos applications.

Pour chaque version, vous devez fournir au moins un fichier skaffold.yaml qui identifie les fichiers manifestes à utiliser. Consultez le section précédente pour savoir ce qui doit figurer dans ce fichier.

Laisser Cloud Deploy générer votre `skaffold.yaml`

Si vous n'avez pas de fichier skaffold.yaml, mais que vous n'avez qu'un seul fichier Kubernetes ou un fichier de définition de service Cloud Run, Cloud Deploy peut générer un fichier skaffold.yaml pour vous.

Le fichier Skaffold généré sera disponible dans le répertoire de préproduction de la source Cloud Storage une fois la publication terminée.

La commande suivante inclut l'option --from-k8s-manifest, qui transmet Fichier manifeste Kubernetes. Cloud Deploy utilise les informations du fichier manifeste pour générer le skaffold.yaml, qui est ensuite utilisé pour la publication.

gcloud deploy releases create  RELEASE_NAME --delivery-pipeline=PIPELINE_NAME --from-k8s-manifest=MANIFEST --region=REGION

Pour générer le fichier skaffold.yaml à partir d'un fichier YAML de service Cloud Run, procédez comme suit : utilisez la même commande, mais avec --from-run-manifest au lieu de --from-k8s-manifest

En utilisant l'un de ces indicateurs avec l'option --skaffold-file ou L'option --source génère une erreur.

Utiliser le fichier `skaffold.yaml` généré

Le skaffold.yaml généré est adapté à l'intégration, à l'apprentissage et à la démonstration de Cloud Deploy. Une fois que vous vous êtes familiarisé avec Cloud Deploy, et pour les charges de travail de production, vous pouvez envisager une configuration Skaffold qui différencie vos cibles (à l'aide de profils Skaffold).

Lorsque vous utilisez le fichier skaffold.yaml généré comme point de départ pour créer votre propre configuration Skaffold différenciée, assurez-vous d'utiliser le fichier dans l'archive source de rendu, et non le fichier rendu. La source de rendu est téléchargeables depuis l'onglet Artefacts de la page **Détails de la version **. .

Ce skaffold.yaml généré est inclus dans la source de rendu stockée dans un bucket Cloud Storage.

Pour afficher ce fichier, téléchargez le fichier .tar.gz et extrayez-le.
Le skaffold.yaml affiché est disponible dans Artefacts cibles.

Dans la section Artefacts cibles, cliquez sur Afficher les artefacts.

Utiliser Skaffold pour le développement local

L'un des points forts de Skaffold est que vous pouvez l'utiliser pour des informations le développement et la CI/CD. En mode dev, Skaffold surveille vos fichiers sources. Lorsqu'il détecte une modification, Skaffold recompile les images, reteste et redéploie les conteneurs dans un minikube (par exemple) sur votre machine locale.

Lorsque vous utilisez Skaffold de cette manière, vous pouvez utiliser les mêmes commandes localement que pour le déploiement à distance.

Si vous utilisez Skaffold pour le développement local, vous pouvez définir des Skaffold distincts des profils pour vos cibles et un bloc de déploiement par défaut pour le développement local.

Lorsque vous arrêtez le mode dev, Skaffold nettoie les artefacts déployés du cluster.

Utiliser Skaffold pour l'intégration et la livraison continues

En plus d'utiliser Skaffold pour la compilation et le déploiement locaux continus, vous pouvez l'utiliser pour l'intégration/le déploiement continus. Cloud Deploy utilise les fonctionnalités CI/CD de Skaffold pour afficher et appliquer vos fichiers manifestes, et déployer votre application dans l'environnement à partir d'images de conteneurs compilées à l'aide d'un outil d'intégration continue tel que Cloud Build et un registre d'images comme Artifact Registry.

Afficher, déployer et appliquer

Skaffold sépare le processus de rendu du fichier manifeste du déploiement. Cloud Deploy appelle skaffold render pour afficher les fichiers manifestes et skaffold apply pour les appliquer à la cible.

Cette séparation entre le rendu et l'application vous permet de capturer l'état déclaratif complet de votre application en configuration, afin qu'elle puisse être appliquée de manière sûre et répétitive (par exemple, pour les rollbacks). Cette technique facilite également les approbations. Comme les fichiers manifestes sont affichés pour toutes les cibles avant le premier déploiement, vous pouvez voir le fichier YAML affiché qui sera appliqué à chaque cible.

Cloud Deploy n'est pas compatible avec l'utilisation d'autres outils de déploiement pour déployer votre application. Vous pouvez toutefois utiliser des outils tels que Helm ou Kustomize pour le rendu.

Pour en savoir plus sur le déploiement de Cloud Deploy avec kubectl en tant que consultez la page Architecture du service Cloud Deploy.

À propos des profils Skaffold

Vous pouvez créer des buckets Skaffold distincts profils, qui sont identifiés skaffold.yaml, dans une stanza profiles:.

Lorsque vous utilisez des profils Skaffold avec Cloud Deploy, vous pouvez créer des profils distincts pour toutes ou certaines de vos cibles. Par exemple, différents profils pour dev, staging et prod.

Les profils ne sont pas nécessaires pour utiliser Skaffold dans Cloud Deploy. mais sont utiles pour définir des personnalisations de manifeste parmi vos cibles, par exemple exemple avec différents fichiers kustomization.yaml Kustomize par cible.

Ajouter la compatibilité avec Kustomize à votre `skaffold.yaml`

Pour intégrer votre configuration Kustomize à votre configuration Cloud Deploy/Skaffold, procédez comme suit :

Incluez un fichier kustomization.yaml parmi vos fichiers de configuration.

Vous pouvez stocker vos fichiers de configuration dans un répertoire local ou dans un bucket Cloud Storage.

Dans votre fichier skaffold.yaml, créez une strophe deploy pour chaque profil.

Vous pouvez également avoir un stanza deploy en dehors des profils définis, si vous n'utilisez pas de profils ou pour une configuration de déploiement par défaut qui n'est pas liée profil.

Voici un exemple de configuration Skaffold qui affiche deploy strophes par et utilise un exemple d'application fictif appelé my-app:

apiVersion: skaffold/v4beta7
kind: Config
build:
  artifacts:
    - image: my-app-web-profiles
      context: my-app-web-profiles
    - image: my-app-application-profiles
      context: my-app-application-profiles
  googleCloudBuild:
    projectId: ${PROJECT_ID}
profiles:
- name: local
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/local
- name: test
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/test
- name: staging
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/staging
- name: prod
  manifests:
    kustomize:
      paths:
        - my-app-application-profiles/kubernetes/prod
deploy:
  kubectl: {}

La configuration Skaffold présentée ici comporte des profils distincts pour test, Cibles : staging et prod. Il affiche également un profil pour le développement local. Dans chaque profil, il existe une strophe deploy.kustomize avec un chemin d'accès qui pointe vers l'emplacement de la kustomization à utiliser pour cette cible.

Ajouter la compatibilité avec Helm à votre `skaffold.yaml`

Vous pouvez utiliser Helm pour afficher vos fichiers manifestes. Cloud Deploy n'utilise pas Helm pour déployer vos applications et n'accepte que kubectl en tant que déployeur.

Pour utiliser Helm, vous avez besoin de votre ou vos graphiques Helm, stockés dans n'importe quel emplacement que vous pouvez référencer depuis votre skaffold.yaml. Cet emplacement peut se trouver dans un système de fichiers, un dépôt, éventuellement avec votre skaffold.yaml ou un dépôt Open Container Initiative (OCI).

Pour utiliser un chart Helm, vous devez ajouter une strophe helm à votre skaffold.yaml.

apiVersion: skaffold/v4beta7
kind: Config
build:
  artifacts:
  - image: skaffold-helm-image
manifests:
  helm:
    releases:
    - name: skaffold-helm-image
      chartPath: charts
deploy:
  kubectl: {}

La référence skaffold.yaml indique ce qui est requis dans cette strophe helm.

Fonctionnalités Skaffold non compatibles

Les fonctionnalités suivantes de Skaffold ne peuvent pas être utilisées dans Cloud Deploy :

Hooks de cycle de vie
Modules Dynamic Skaffold

L'utilisation de --module= pour sélectionner des modules spécifiques pour build, render, apply, etc. n'est pas prise en charge. Les modules statiques sont acceptés.
Dans Helm, la possibilité de créer un espace de noms s'il n'en existe pas.

Étape suivante

Consultez le site Web de Skaffold pour découvrir son fonctionnement et ce qu'il peut vous apporter.
S'entraîner à l'aide de Cloud Deploy avec des profils Kustomize et Skaffold.
Découvrez comment Cloud Deploy sélectionne la version de Skaffold à utiliser, quand la version de Skaffold change et comment déterminer la version utilisée.
Découvrez comment utiliser des profils Skaffold avec des outils de gestion de fichiers manifestes avancés tels que Helm, Kustomize et kpt.