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 sans frais 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. Assurez-vous 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 de 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'application 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 aux nouvelles applications. Pour cet atelier, vous allez amorcer votre dépôt de modèles avec une structure d'exemple fournie ici. Vous pouvez ajouter vos propres modèles en ajoutant des dossiers supplémentaires sur le modèle de l'exemple.

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

Il s'agit d'étapes ponctuelles permettant de remplir 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 à différents moments. Le script ci-dessous vous aidera à obtenir les valeurs et à les stocker en tant que variables locales pour une utilisation ultérieure.

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. Dans cette étape, vous allez créer votre propre copie de ces fichiers dans un dépôt appelé mcd-app-templates dans votre compte GitHub.

1. Copier 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éez un dépôt distant vide dans votre compte GitHub.

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

3. Transférez 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 plate-forme d'évoluer dans de nombreuses équipes et environnements.

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

1. Copier 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éez un dépôt distant vide dans votre compte GitHub.

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

3. Transférez 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'application

Lorsque vous créez une application à partir d'un modèle, vous devez souvent 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 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 dans leur développement quotidien.

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

Définissez 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 d'espace réservé

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

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

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

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

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

2. Transférez 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, il est temps d'implémenter les builds continus.

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

La partie centrale d'un système d'intégration continue est la capacité à exécuter la logique du pipeline en fonction des événements provenant du système de contrôle du code source. 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.

Dans cette étape, vous allez configurer GitHub pour appeler Google Cloud Build et exécuter 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 un accès sécurisé au pipeline de votre application. Une clé API et un code secret propres 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 qui n'est pas abordée ici consiste à limiter le champ d'application de la clé API aux API spécifiques auxquelles le client accédera. Vous avez créé la clé lors d'une étape précédente.

1. Pour examiner la clé, cliquez 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 sont utilisés pour autoriser un appelant et s'assurer qu'il dispose des droits d'accès au job cible Cloud Build spécifique. Vous pouvez avoir deux dépôts différents dans GitHub qui ne doivent avoir accès qu'à leurs propres pipelines. Alors que la clé API limite les API qui peuvent être utilisées par GitHub (dans ce cas, l'API Cloud Build est appelée), le secret limite le job de l'API Cloud Build qui peut être exécuté 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 CI/CD.

Pour configurer correctement le déclencheur, vous devez fournir quelques valeurs clés lors de la création du job.

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é.

export KUSTOMIZE_REPO=${GIT_BASE_URL}/mcd-shared_kustomize

6. Une variable a été définie dans le script onboard-env.sh pour définir le registre de conteneurs du projet. Examinez la valeur à l'aide de la commande ci-dessous.

echo $IMAGE_REPO

7. Créez un déclencheur de webhook Cloud Build à 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 depuis 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 sur ce lien.
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 les 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. Au lieu de cela, la logique doit être intégrée à un script pour une exécution facile. Les étapes ci-dessus ont déjà été incluses dans un script que vous pouvez utiliser.

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

Créer une application

1. Assurez-vous d'être 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.

Examiner le dépôt GitHub

À ce stade, vous pourrez examiner 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 avec 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 webhook configuré à l'URL ci-dessous.

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

Examiner le déclencheur Cloud Build

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

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