Intégration d'applications

1. Avant de commencer

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères qui n'est pas utilisée par les API Google, et que vous pouvez modifier à tout moment.
• L'ID du projet doit être unique sur l'ensemble des projets Google Cloud et doit être immuable (vous ne pouvez pas le modifier une fois que vous l'avez défini). Cloud Console génère automatiquement une chaîne unique dont la composition importe peu, en général. Dans la plupart des ateliers de programmation, vous devrez référencer l'ID du projet (généralement identifié comme PROJECT_ID), donc s'il ne vous convient pas, générez-en un autre au hasard ou définissez le vôtre, puis vérifiez s'il est disponible. Il est ensuite "gelé" une fois le projet créé.
• La troisième valeur est le numéro de projet, utilisé par certaines API. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet doit être unique au niveau mondial. Personne d'autre ne peut l'employer une fois que vous l'avez sélectionné. Vous en êtes le seul utilisateur. Si un projet est supprimé, cet ID ne pourra plus jamais être utilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement pertinent pour votre organisation.

2. Vous devez ensuite activer la facturation dans Cloud Console afin d'utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour arrêter les ressources afin d'éviter qu'elles ne vous soient facturées après ce tutoriel, suivez les instructions de nettoyage indiquées à la fin de l'atelier. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai gratuit pour bénéficier d'un crédit de 300 $.

2. Préparer votre espace de travail

1. Ouvrez l'éditeur Cloud Shell en accédant à l'URL suivante :

https://ide.cloud.google.com

2. Vérifiez que le nom de votre projet est défini dans la CLI

gcloud config set project {{project-id}}

export PROJECT_ID=$(gcloud config get-value project)

export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

3. Activer les API

gcloud services enable \

cloudbuild.googleapis.com \

secretmanager.googleapis.com

4. Accorder des droits à CloudDeploy

gcloud projects add-iam-policy-binding --member="serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" --role roles/clouddeploy.admin ${PROJECT_ID}

gcloud projects add-iam-policy-binding --member="serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" --role roles/container.developer ${PROJECT_ID}

gcloud projects add-iam-policy-binding --member="serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" --role roles/iam.serviceAccountUser ${PROJECT_ID}

gcloud projects add-iam-policy-binding --member="serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" --role roles/clouddeploy.jobRunner ${PROJECT_ID}

5. Dans la fenêtre du terminal, clonez la source de l'application à l'aide de la commande suivante:

git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git

6. Accédez au répertoire et définissez l'espace de travail de l'IDE sur la racine du dépôt.

cd software-delivery-workshop && rm -rf .git

cd delivery-platform && cloudshell workspace .

3. Utiliser des modèles d'applications prédéfinis et personnalisés

Les développeurs doivent pouvoir choisir parmi un ensemble de modèles couramment utilisés dans l'organisation. Le processus d'intégration créera un ensemble centralisé de dépôts de modèles stockés dans votre compte GitHub. Dans les étapes suivantes, ces dépôts de modèles seront copiés et modifiés pour servir de base à de nouvelles applications. Dans cet atelier, vous allez utiliser l'exemple de structure fourni ici pour alimenter votre dépôt de modèles. Vous pouvez ajouter vos propres modèles en ajoutant des dossiers supplémentaires sur le modèle.

Au cours de cette étape, vous allez créer votre propre dépôt pour stocker des modèles d'application, à partir des fichiers d'exemple fournis. Un script d'assistance est fourni pour simplifier les interactions avec GitHub.

Il s'agit d'étapes ponctuelles utilisées pour renseigner vos dépôts de modèles. Les étapes suivantes réutiliseront ces dépôts.

Configurer l'accès à GitHub

Les étapes de ce tutoriel appellent l'API GitHub pour créer et configurer des dépôts. Votre nom d'utilisateur GitHub et un jeton d'accès personnel sont requis à plusieurs reprises dans les étapes suivantes. Le script ci-dessous vous aidera à acquérir les valeurs et à les stocker en tant que variables locales pour les utiliser ultérieurement.

source ./onboard-env.sh

echo Git Username: $GIT_USERNAME

echo Git Base URL: $GIT_BASE_URL

Créer un dépôt de modèles d'applications

Des exemples de modèles d'application sont fournis avec cet atelier pour vous montrer comment intégrer vos propres modèles de base. Au cours de cette étape, vous allez créer votre propre copie de ces fichiers dans un dépôt nommé mcd-app-templates dans votre compte GitHub.

1. Copiez le modèle dans le répertoire de travail.

cp -R $BASE_DIR/resources/repos/app-templates $WORK_DIR

cd $WORK_DIR/app-templates

2. Créer un dépôt distant vide dans votre compte GitHub

$BASE_DIR/scripts/git/gh.sh create mcd-app-templates

3. Transférer le dépôt de modèles vers votre dépôt distant

git init && git symbolic-ref HEAD refs/heads/main && git add . && git commit -m "initial commit"

git remote add origin $GIT_BASE_URL/mcd-app-templates

git push origin main

4. Nettoyer le répertoire de travail

cd $BASE_DIR

rm -rf $WORK_DIR/app-templates

Créer un dépôt de configurations de base partagées

Ce tutoriel utilise un outil appelé Kustomize qui utilise des fichiers de configuration de base partagés par plusieurs équipes, puis superpose des configurations spécifiques à l'application. Cela permet aux équipes de la plate-forme de s'étendre à de nombreuses équipes et environnements.

À cette étape, vous allez créer le dépôt de configuration partagé appelé mcd-shared_kustomize à partir des exemples fournis.

1. Copiez le modèle dans le répertoire de travail.

cp -R $BASE_DIR/resources/repos/shared-kustomize $WORK_DIR

cd $WORK_DIR/shared-kustomize

2. Créer un dépôt distant vide dans votre compte GitHub

$BASE_DIR/scripts/git/gh.sh create mcd-shared_kustomize

3. Transférer le dépôt de modèles vers votre dépôt distant

git init && git symbolic-ref HEAD refs/heads/main && git add . && git commit -m "initial commit"

git remote add origin $GIT_BASE_URL/mcd-shared_kustomize

git push origin main

4. Nettoyer le répertoire de travail

cd $BASE_DIR

rm -rf $WORK_DIR/shared-kustomize

Une fois vos dépôts de modèles créés, vous pouvez les utiliser pour créer une instance d'application.

4. Créer une instance d'une application

La création d'une application à partir d'un modèle nécessite souvent de remplacer les variables d'espace réservé par des valeurs réelles dans plusieurs fichiers de la structure du modèle. Une fois la substitution effectuée, un nouveau dépôt est créé pour la nouvelle instance d'application. C'est ce dépôt d'instances d'application que les développeurs cloneront et utiliseront pour développer leurs applications au quotidien.

Au cours de cette étape, vous allez remplacer des valeurs dans un modèle d'application et publier les fichiers générés dans un nouveau dépôt.

Définir un nom pour la nouvelle application

export APP_NAME=my-app

Récupérer le dépôt de modèles Golang

cd $WORK_DIR/

git clone -b main $GIT_BASE_URL/mcd-app-templates app-templates

rm -rf app-templates/.git

cd app-templates/golang

Remplacer les valeurs des espaces réservés

L'un des besoins les plus courants lors de l'intégration consiste à remplacer les variables dans les modèles par des instances réelles utilisées dans l'application. Par exemple, en indiquant le nom de l'application. La commande suivante crée des instances de tous les fichiers .tmpl avec les valeurs stockées dans des variables d'environnement.

for template in $(find . -name '*.tmpl'); do envsubst < ${template} > ${template%.*}; done

Créer un dépôt et stocker les fichiers mis à jour

1. Créer un dépôt distant vide dans votre compte GitHub

$BASE_DIR/scripts/git/gh.sh create ${APP_NAME}

2. Transférer le dépôt de modèles vers votre dépôt distant

git init && git symbolic-ref HEAD refs/heads/main && git add . && git commit -m "initial commit"

git remote add origin $GIT_BASE_URL/${APP_NAME}

git push origin main

Maintenant que l'instance d'application a été créée, vous pouvez implémenter des compilations continues.

5. Configurer l'exécution automatisée du pipeline

La partie centrale d'un système d'intégration continue est la capacité d'exécuter la logique du pipeline en fonction des événements provenant du système de contrôle des sources. Lorsqu'un développeur valide du code dans son dépôt, des événements sont déclenchés et peuvent être configurés pour déclencher des processus dans d'autres systèmes.

À cette étape, vous allez configurer GitHub pour qu'il appelle Google Cloud Build et exécute votre pipeline chaque fois que des utilisateurs valident ou taguent du code dans leur dépôt.

Activer l'accès sécurisé

Vous aurez besoin de deux éléments pour configurer l'accès sécurisé à votre pipeline d'application. Une clé API et un secret propre au pipeline.

Clé API

La clé API permet d'identifier le client qui appelle une API donnée. Dans ce cas, le client sera GitHub. Une bonne pratique non abordée ici consiste à limiter la portée de la clé API aux API spécifiques auxquelles le client aura accès. Vous avez créé la clé à une étape précédente.

1. Vous pouvez consulter la clé en cliquant sur ce lien.
2. Pour vous assurer que la valeur est définie, exécutez la commande suivante :

echo $API_KEY_VALUE

Secret du pipeline

Les secrets permettent d'autoriser un appelant et de s'assurer qu'il dispose des droits sur la tâche cible de compilation dans le cloud spécifique. Vous pouvez avoir deux dépôts différents sur GitHub qui ne doivent avoir accès qu'à leurs propres pipelines. Alors que la clé API limite les API pouvant être utilisées par GitHub (dans ce cas, l'API Cloud Build est appelée), le secret limite les tâches de l'API Cloud Build pouvant être exécutées par le client.

1. Définir le nom, l'emplacement et la valeur du secret

SECRET_NAME=${APP_NAME}-webhook-trigger-cd-secret

SECRET_PATH=projects/${PROJECT_NUMBER}/secrets/${SECRET_NAME}/versions/1

SECRET_VALUE=$(sed "s/[^a-zA-Z0-9]//g" <<< $(openssl rand -base64 15))

2. Créer le secret

printf ${SECRET_VALUE} | gcloud secrets create ${SECRET_NAME} --data-file=-

3. Autoriser Cloud Build à lire le secret

gcloud secrets add-iam-policy-binding ${SECRET_NAME} \

--member=serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-cloudbuild.iam.gserviceaccount.com \

--role='roles/secretmanager.secretAccessor'

Créer un déclencheur Cloud Build

Le déclencheur Cloud Build est la configuration qui exécutera réellement les processus de CI/CD.

Lors de la création, vous devez fournir quelques valeurs clés pour configurer correctement le déclencheur.

4. Définissez le nom du déclencheur et l'emplacement du fichier de configuration.

export TRIGGER_NAME=${APP_NAME}-clouddeploy-webhook-trigger

export BUILD_YAML_PATH=$WORK_DIR/app-templates/golang/build/cloudbuild-cd.yaml

5. Définissez l'emplacement du dépôt de configuration de base partagée.

export KUSTOMIZE_REPO=${GIT_BASE_URL}/mcd-shared_kustomize

6. Une variable a été définie dans le script onboard-env.sh définissant le registre Container Registry du projet. Vérifiez la valeur à l'aide de la commande ci-dessous.

echo $IMAGE_REPO

7. Créez un déclencheur de webhook CloudBuild à l'aide des variables créées précédemment. L'emplacement du dépôt de l'application est extrait du corps de la requête de GitHub. Une valeur ci-dessous fait référence au chemin d'accès dans le corps de la requête où elle se trouve.gcloud alpha builds triggers create webhook \

    `--name=${TRIGGER_NAME} \`
   
    `--substitutions='_APP_NAME='${APP_NAME}',_APP_REPO=$(body.repository.git_url),_CONFIG_REPO='${GIT_BASE_URL}'/'${CLUSTER_CONFIG_REPO}',_DEFAULT_IMAGE_REPO='${IMAGE_REPO}',_KUSTOMIZE_REPO='${GIT_BASE_URL}'/'${SHARED_KUSTOMIZE_REPO}',_REF=$(body.ref)' \`
   
    `--inline-config=$BUILD_YAML_PATH \`
   
    `--secret=${SECRET_PATH}`
   

8. Examinez le déclencheur Cloud Build que vous venez de créer dans la console en cliquant ici.
9. Définissez une variable pour l'URL du point de terminaison qui sera utilisée par GitHub à l'étape suivante

WEBHOOK_URL="https://cloudbuild.googleapis.com/v1/projects/${PROJECT_ID}/triggers/${TRIGGER_NAME}:webhook?key=${API_KEY_VALUE}&secret=${SECRET_VALUE}"

Configurer le webhook GitHub

1. Configurer le webhook dans GitHub

$BASE_DIR/scripts/git/gh.sh create_webhook ${APP_NAME} $WEBHOOK_URL

2. Accédez au dépôt de l'application et examinez le webhook nouvellement configuré.

REPO_URL=${GIT_BASE_URL}/${APP_NAME}/settings/hooks

echo $REPO_URL

Maintenant que vous avez effectué manuellement toutes les étapes nécessaires pour créer une application, il est temps de l'automatiser dans un script.

6. Automatiser toutes les étapes d'intégration

En pratique, il n'est pas possible d'exécuter chacune des étapes ci-dessus pour chaque nouvelle application. La logique doit plutôt être intégrée à un script pour faciliter son exécution. Les étapes ci-dessus ont déjà été incluses dans un script que vous pouvez utiliser.

Dans cette étape, vous allez utiliser le script fourni pour créer une application.

Créer une application

1. Vérifier que vous vous trouvez dans le bon répertoire

cd $BASE_DIR

2. Créer une application

export APP_NAME=demo-app

./app.sh create ${APP_NAME}

Toutes les étapes sont exécutées automatiquement.

Vérifier le dépôt GitHub

Vous pourrez alors consulter le nouveau dépôt dans GitHub.

1. Récupérez l'URL du dépôt GitHub en exécutant la commande suivante :

echo ${GIT_BASE_URL}/demo-app

2. Ouvrez l'URL dans votre navigateur Web pour examiner la nouvelle application.
3. Notez les exemples où les variables de modèle ont été remplacées par des valeurs d'instance, comme indiqué dans l'URL ci-dessous.

echo ${GIT_BASE_URL}/demo-app/blob/main/k8s/prod/deployment.yaml#L24

4. Vérifiez le point d'ancrage Web configuré à l'adresse URL ci-dessous

echo ${GIT_BASE_URL}/demo-app/settings/hooks

Examiner le déclencheur CloudBuild

Le déclencheur a été configuré automatiquement par le script

1. Examinez le déclencheur Cloud Build dans la console en cliquant ici.
2. Consultez l'historique des compilations sur cette page.