Test Google Cloud Deploy et Cloud Run

Ce document est un tutoriel de test qui vous permet d'être opérationnel avec un pipeline de livraison dans Google Cloud Deploy qui déploie des conteneurs sur Cloud Run. À la fin de ce tutoriel, vous disposerez d'un pipeline CD ciblant Cloud Run avec deux environnements : dev et prod. Vous pouvez déployer et promouvoir de nouvelles images de conteneurs via les étapes du pipeline, et observer le processus sur Google Cloud Console.

Ce tutoriel repose sur plusieurs services Google Cloud, notamment Config Controller, ainsi que sur des services pré-DG qui sont toujours disponibles en version bêta et ne sont pas accessibles à tous (API Cloud Run Admin v2). Config Controller vous permet de provisionner des ressources GCP de manière déclarative à l'aide du modèle de ressource Kubernetes (KRM). Google Cloud Deploy crée et gère des services Cloud Run dans le cadre de son pipeline de livraison à l'aide de Config Controller.

Si vous avez des questions, des bugs ou des commentaires, contactez-nous à l'adresse clouddeploy-feedback-external@google.com.

Tutoriel sur Cloud Shell

Les instructions de ce document sont également incluses dans un tutoriel facile à suivre, basé sur Cloud Shell. Vous pouvez suivre ce tutoriel tout en utilisant ce document pour obtenir des conseils et du contexte.

Configurer votre environnement

Créez un projet et définissez le projet par défaut pour Google Cloud CLI.

Nous vous recommandons de commencer avec un nouveau projet.
```
gcloud config set project PROJECT_ID
```
Dans la commande ci-dessus, remplacez PROJECT_ID par l'ID de votre projet. Dans ce document, le code (commandes et fichiers) contient {PROJECT_ID} en tant qu'espace réservé. Si vous le remplacez ici, toutes les instances de ce document seront insérées, sauf si vous actualisez la page.
Activez les API requises :
```
gcloud services enable \
    krmapihosting.googleapis.com \
    clouddeploy.googleapis.com \
    compute.googleapis.com \
    run.googleapis.com
```
Cette commande active les API suivantes, dont vous avez besoin pour effectuer ce test:
- Compute Engine
- Config Controller
- Google Cloud Deploy
- Cloud Build (activé via Google Cloud Deploy)
- Cloud Storage (activé via Google Cloud Deploy)
- Resource Manager
- Cloud Run
- Google Kubernetes Engine (activé via Config Controller)
Assurez-vous d'avoir installé et configuré Google Cloud CLI.

En outre, vous devez vous assurer que kubectl est installé:
```
which kubectl || gcloud components install kubectl
```
Si vous exécutez des commandes à partir de Cloud Shell, ces composants sont déjà installés pour vous.

Configurer le compte de service Compute Engine par défaut

Par défaut, Google Cloud Deploy utilise le compte de service Compute Engine par défaut. Le compte de service dispose peut-être déjà des autorisations nécessaires. Cette étape est incluse pour les organisations qui désactivent l'attribution automatique des rôles pour les comptes de service par défaut.

Exécutez les commandes suivantes pour vous assurer que le compte de service dispose des autorisations appropriées:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/clouddeploy.jobRunner"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/container.developer"

Consultez la présentation de Google Cloud Deploy.

Cette présentation vous aidera à comprendre le service et les concepts Google Cloud Deploy.

Configurer Config Controller

Google Cloud Deploy déploie vos services et révisions Cloud Run à l'aide d'une instance Config Controller.

Avant de créer le contrôleur de configuration, assurez-vous qu'il existe un réseau par défaut:
```
gcloud compute networks list
```
Les résultats de la console réussis se présentent comme suit:
```
NAME: default
SUBNET_MODE: AUTO
BGP_ROUTING_MODE: REGIONAL
IPV4_RANGE:
GATEWAY_IPV4:
```
Si vous n'avez pas de réseau par défaut, exécutez la commande suivante:
```
gcloud compute networks create default --subnet-mode=auto
```
Si le résultat est correct, vous n'avez pas besoin d'exécuter cette commande.

Si vous rencontrez d'autres problèmes, consultez le guide de dépannage de Config Controller ou contactez l'administrateur de votre organisation.

Créez votre instance Config Controller.

gcloud anthos config controller create cc-deployrun --location=us-central1

Accordez des autorisations Config Controller aux projets sur lesquels vous souhaitez effectuer le déploiement. La commande suivante donne les autorisations minimales nécessaires à Config Controller pour créer et gérer des services Cloud Run dans votre projet.

export SA_EMAIL="$(kubectl get ConfigConnectorContext -n config-control -o jsonpath='{.items[0].spec.googleServiceAccount}' 2> /dev/null)"

gcloud projects add-iam-policy-binding "PROJECT_ID" \
    --member "serviceAccount:${SA_EMAIL}" \
    --role "roles/run.admin" \
    --project "PROJECT_ID"

gcloud projects add-iam-policy-binding "PROJECT_ID" \
    --member "serviceAccount:${SA_EMAIL}" \
    --role "roles/iam.serviceAccountUser" \
    --project "PROJECT_ID"

Créer vos fichiers de configuration

Google Cloud Deploy fournit des informations détaillées sur les éléments à déployer et sur la manière de le déployer correctement pour vos cibles distinctes à l'aide de Skaffold. Pour ce test, nous avons deux cibles: run-dev et run-prod.

Cibles de test Cloud Run de Google Cloud Deploy, run-dev et run-prod

Dans cette section, vous allez créer un fichier skaffold.yaml qui identifie les fichiers manifestes Cloud Run qui déploieront votre application via un pipeline de livraison Google Cloud Deploy. Vous allez également créer des fichiers manifestes pour vos services Cloud Run, un pour chaque environnement cible (respectivement run-dev-service.yaml et run-prod-service.yaml).

Créez un répertoire pour vos fichiers manifestes et accédez-y:
```
mkdir deploy-cloudrun
cd deploy-cloudrun
```

Créez le fichier skaffold.yaml dans ce répertoire.

skaffold.yaml indique à Google Cloud Deploy quels fichiers manifestes doivent être déployés pour chaque cible du pipeline, pour une version donnée.

apiVersion: skaffold/v2beta26
kind: Config
profiles:
 - name: prod
   deploy:
     kubectl:
       manifests:
         - run-prod-*.yaml
 - name: dev
   deploy:
     kubectl:
       manifests:
         - run-dev-*.yaml

Créez le fichier run-dev-service.yaml dans le même répertoire.

Ce fichier manifeste déclaratif représente la version de l'environnement dev de votre service Cloud Run.

Notez les paramètres personnalisés pour cet environnement, tels que la limitation du scaling des conteneurs à deux instances. Des étiquettes et un nom permettent de distinguer cette version du service de votre projet. Notez que le nom de l'image est une variable run-container plutôt qu'une image de conteneur spécifique. Elle est remplacée par une image de conteneur spécifique lorsque vous créez une version dans Google Cloud Deploy.

apiVersion: run.cnrm.cloud.google.com/v1beta1
kind: RunService
metadata:
  labels:
    cloud-deploy-target: run-dev
  name: deploytest-dev
  namespace: config-control
spec:
  ingress: INGRESS_TRAFFIC_ALL
  location: us-central1
  projectRef:
    external: projects/PROJECT_ID
  template:
    containers:
      - env:
          - name: environment
            value: dev
        image: run-container
    scaling:
      maxInstanceCount: 2
  traffic:
    - percent: 100
      type: TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST

Créez le fichier run-prod-service.yaml dans le même répertoire.

Ce fichier manifeste représente la version prod de votre service Cloud Run. Notez le nouveau nom, les nouveaux libellés et les nouveaux paramètres de scaling, ainsi que la réutilisation de run-container.

apiVersion: run.cnrm.cloud.google.com/v1beta1
kind: RunService
metadata:
  labels:
    cloud-deploy-target: run-prod
  name: deploytest-prod
  namespace: config-control
spec:
  ingress: INGRESS_TRAFFIC_ALL
  location: us-central1
  projectRef:
    external: projects/PROJECT_ID
  template:
    containers:
      - env:
          - name: environment
            value: prod
        image: run-container
    scaling:
      maxInstanceCount: 10
  traffic:
    - percent: 100
      type: TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST

Créer votre pipeline de livraison et vos cibles

Vous pouvez définir votre pipeline de livraison Google Cloud Deploy et vos cibles dans un ou plusieurs fichiers. Dans ce tutoriel, par souci de simplicité, vous allez créer un seul fichier.

Dans le répertoire contenant vos fichiers manifestes récemment créés (/deploy-cloudrun/), créez le fichier clouddeploy.yaml:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
 name: my-run-app-1
description: main application pipeline
serialPipeline:
 stages:
 - targetId: run-dev
   profiles:
   - dev
 - targetId: run-prod
   profiles:
   - prod
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: run-dev
description: Cloud Run development environment
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/krmapihost-cc-deployrun
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: run-prod
description: Cloud Run production environment
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/krmapihost-cc-deployrun

cloudeploy.yaml définit une séquence de progression de deux étapes dans le pipeline de livraison: run-dev et run-prod. Le fichier définit également des cibles pour chacune de ces deux étapes.

Notez que les deux cibles pointent vers le même contrôleur de configuration qu'un cluster GKE. Config Controller, qui est compatible avec un cluster GKE sous-jacent créé au moment de la création de Config Controller, crée les services Cloud Run pour chaque environnement à l'aide de leur fichier manifeste.

Votre cluster GKE