Ce tutoriel constitue la deuxième partie d'une série qui traite de la création d'un pipeline d'intégration continue (CI) automatisé pour créer des images de conteneurs multi-architectures sur Google Cloud.
Dans ce tutoriel, vous allez mettre en œuvre un pipeline pour créer des images de conteneurs multi-architectures à l'aide de Cloud Build et de Container Registry. Ce tutoriel illustre la stratégie de création multi-architecture décrite dans la section Mettre en œuvre un pipeline de création d'images de conteneurs multi-architectures de la partie 1 de cette série.
Par exemple, supposons que vous gériez un parc d'appareils IoT (Internet des objet). À mesure qu'apparaissent de nouvelles exigences pour votre solution IoT, vous avez besoin de nouveaux appareils. Si l'architecture matérielle de ces nouveaux appareils est différente de celle existante, vous devez modifier votre pipeline de compilation pour l'adapter à la nouvelle architecture.
Ce tutoriel s'adresse aux professionnels de l'informatique qui souhaitent simplifier et optimiser les pipelines complexes pour la création d'images de conteneurs, ou étendre ces pipelines afin de créer des images multi-architectures.
Dans ce tutoriel, nous partons du principe que vous disposez des connaissances de base dans les domaines suivants :
- Terraform, pour créer une infrastructure sur Google Cloud.
- Google Cloud CLI, pour effectuer des tâches de plate-forme sur Google Cloud.
- Cloud Shell, pour exécuter des commandes dans ce tutoriel. Tous les outils utilisés dans ce tutoriel sont préinstallés dans Cloud Shell.
- Cloud Build, pour la configuration d'un pipeline CI.
- Docker, en tant que plate-forme de gestion des conteneurs.
- Container Registry, pour stocker les images de conteneurs générées par le processus de compilation.
Dans ce tutoriel, vous allez utiliser Terraform pour configurer les ressources dont vous avez besoin pour provisionner et configurer le pipeline de création d'images de conteneurs.
Architecture
Le schéma suivant illustre le workflow du pipeline que vous allez mettre en œuvre dans ce tutoriel pour créer des images de conteneurs.
Les modifications apportées au code source de l'image de conteneur déclenchent Cloud Build pour créer une image de conteneur multi-architecture. Une fois la compilation terminée, l'image de conteneur multi-architecture est stockée dans Container Registry.
Objectifs
- Utiliser Terraform pour provisionner le pipeline permettant de créer des images de conteneurs sur Google Cloud.
- Modifier le code source de l'image de conteneur pour déclencher une nouvelle compilation.
- Inspecter l'image de conteneur stockée dans Container Registry.
Coûts
Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :
Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.
Avant de commencer
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.
Préparer l'environnement
Dans ce tutoriel, vous allez exécuter toutes les commandes dans Cloud Shell.
-
Dans la console Google Cloud, activez Cloud Shell.
En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Clonez l'exemple de dépôt de code :
cd "$HOME" git clone \ https://github.com/GoogleCloudPlatform/solutions-build-multi-architecture-images-tutorial.gitGénérez les identifiants par défaut de l'application :
gcloud auth application-default login --quietLe résultat ressemble à ce qui suit :
Go to the following link in your browser: https://accounts.google.com/o/oauth2/auth?code_challenge=... Enter verification code:Dans une fenêtre de navigateur, ouvrez l'URL qui s'affiche dans le résultat de la génération des identifiants par défaut de l'application (étape précédente).
Sélectionnez Autoriser pour continuer.
Copiez le code à l'écran et saisissez-le dans Cloud Shell.
Le résultat ressemble à ce qui suit :
/tmp/tmp.xxxxxxxxxx/application_default_credentials.json
Notez le chemin d'accès au fichier
application_default_credentials.json. Vous allez utiliser ce chemin pour définir une variable d'environnement dans la section suivante.
Définir des variables d'environnement
Avant de pouvoir provisionner l'infrastructure nécessaire à ce tutoriel, vous devez initialiser et exporter les variables d'environnement suivantes :
Dans Cloud Shell, créez une variable d'environnement qui stocke le nom du compte de service Google Cloud utilisé par Terraform pour provisionner les ressources :
export TF_SERVICE_ACCOUNT_NAME=tf-service-accountCréez une variable d'environnement qui stocke l'ID de projet Google Cloud utilisé par Terraform pour stocker l'état :
export TF_STATE_PROJECT=${DEVSHELL_PROJECT_ID}Créez une variable d'environnement qui stocke le bucket Cloud Storage utilisé par Terraform pour enregistrer les fichiers d'état :
export TF_STATE_BUCKET=tf-state-bucket-${TF_STATE_PROJECT}Créez une variable d'environnement qui stocke l'ID du projet Google Cloud contenant les ressources nécessaires au pipeline de création d'images de conteneurs :
export GOOGLE_CLOUD_PROJECT=${DEVSHELL_PROJECT_ID}Créez une variable d'environnement qui stocke le chemin d'accès aux identifiants par défaut de l'application Google Cloud, qui correspond à la valeur notée dans la section précédente :
export GOOGLE_APPLICATION_CREDENTIALS=PATH
Remplacez les éléments suivants :
PATH: chemin d'accès au fichierapplication_default_credentials.json
Provisionner l'environnement
Vous devez exécuter le script shell generate-tf-backend.sh qui génère la configuration du backend Terraform, les comptes de service Google Cloud nécessaires et le bucket Cloud Storage pour stocker les informations surl'état distant Terraform.
Dans Cloud Shell, provisionnez votre environnement de compilation :
cd $HOME/solutions-build-multi-architecture-images-tutorial/ ./generate-tf-backend.shLe script est idempotent et peut être exécuté plusieurs fois en toute sécurité.
Une fois le script exécuté pour la première fois, le résultat est semblable à celui-ci :
Generating the descriptor to hold backend data in terraform/backend.tf terraform { backend "gcs" { bucket = "tf-state-bucket-project-id" prefix = "terraform/state" } }
Créer le pipeline de compilation
Le fichier de modèle Terraform terraform/main.tf définit les ressources créées pour ce tutoriel. En exécutant Terraform avec ce descripteur, vous créez les ressources Google Cloud suivantes :
- Un dépôt de code Cloud Source Repositories pour stocker le descripteur d'image de conteneur et le fichier de configuration de compilation Cloud Build.
- Un sujet Pub/Sub dans lequel Cloud Build publie des messages à chaque modification de code source.
- Une compilation Cloud Build qui crée l'image du conteneur multi-architecture.
- Un dépôt Container Registry pour stocker des images de conteneurs.
Dans Cloud Shell, procédez comme suit :
Pour initialiser le répertoire de travail Terraform, exécutez la commande terraform init :
cd terraform terraform init(Facultatif) Pour examiner les modifications que Terraform va appliquer, exécutez la commande terraform plan :
terraform planLe résultat est une liste de toutes les actions que Terraform est censé effectuer pour provisionner des ressources dans l'environnement Google Cloud. Le résumé de toutes les actions est semblable à ce qui suit :
Plan: 8 to add, 0 to change, 0 to destroy.
Le nombre total d'actions d'ajout est de 8, sans aucune modification ni suppression.
Exécutez la commande terraform apply pour créer les ressources dans votre projet Google Cloud :
terraform applyPour poursuivre l'exécution de la commande, saisissez
yes.
Transférer les fichiers sources vers Cloud Source Repositories
Pour que le pipeline de compilation puisse exécuter le build, les fichiers de configuration Dockerfile et Cloud Build doivent être stockés dans un dépôt de code source Cloud Source Repositories.
Dans Cloud Shell, clonez le dépôt source :
cd $HOME gcloud source repos clone cross-buildCopiez le Dockerfile et le fichier de configuration Cloud Build dans le dépôt du code source :
cp -r "$HOME"/solutions-build-multi-architecture-images-tutorial/terraform/cloud-build/. "$HOME"/cross-buildValidez et transférez les fichiers dans le dépôt de code source :
cd "$HOME"/cross-build git add . git commit -m "Initial commit" git push
Inspecter les résultats
Pendant l'exécution de la tâche Cloud Build et après son achèvement, vous pouvez inspecter l'exécution de chaque étape de compilation sur la page Historique de compilation de Cloud Build.
Compilation Cloud Build
Sur la page Historique de compilation, vous obtenez un aperçu des étapes de compilation, ainsi que le temps nécessaire à chaque étape, comme le montre l'illustration suivante.
Si vous ouvrez une étape de compilation, le résultat de cette étape s'affiche. Par exemple, les détails de compilation de l'étape buildx inspect du diagramme précédent montrent les différentes architectures de plate-forme cible compatibles avec la plate-forme :
12 Name: mybuilder0 13 Endpoint: unix:///var/run/docker.sock 14 Status: running 15 Platforms: linux/amd64, linux/arm64, linux/ppc64le, linux/s390x, linux/386, linux/arm/v7, linux/arm/v6
Les détails de la compilation à la quatrième étape indiquent le résultat de la compilation pour chaque architecture cible :
#8 0.268 I am running on linux/amd64, building for linux/amd64 #12 0.628 I am running on linux/amd64, building for linux/arm/v7 #10 0.279 I am running on linux/amd64, building for linux/arm/v6 #14 0.252 I am running on linux/amd64, building for linux/arm64
Fichier manifeste d'images dans Container Registry
Une fois la compilation terminée, vous pouvez inspecter le fichier manifeste de l'image sur la page Images de Container Registry dans la console Google Cloud, comme le montre l'illustration suivante.
Si vous ouvrez le dépôt test dans la liste des dépôts, vous voyez toutes les versions d'image de conteneur qui appartiennent au dépôt test, comme illustré ci-dessous.
Vous pouvez ouvrir l'image taguée latest pour accéder à la page Informations sur le condensé afin d'afficher des informations détaillées sur l'image, comme illustré ci-dessous.
Sur la page Informations sur le condensé, vous pouvez développer la section Manifest et vérifier que l'architecture cible créée par la compilation est indiquée dans le fichier, comme dans l'exemple suivant :
{
"mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
"schemaVersion": 2,
"manifests": [
{
"mediaType": "application/vnd.docker.distribution.manifest.v2+json",
"digest": "sha256:839024acb1038509e3bc66f3744857840951d0d512be54fd6670ea1e8babdcb6",
"size": 735,
"platform": {
"architecture": "amd64",
"os": "linux"
}
},
{
"mediaType": "application/vnd.docker.distribution.manifest.v2+json",
"digest": "sha256:33489767c29efb805e446a61d91cc55e042d3cfadcd186d9a1c8698f2f12309d",
"size": 735,
"platform": {
"architecture": "arm64",
"os": "linux"
}
},
{
"mediaType": "application/vnd.docker.distribution.manifest.v2+json",
"digest": "sha256:f1958815778ca8c83d324bad3fc68a9e3e9d5ea48b5bb27a8aca7d8da20cf8d4",
"size": 735,
"platform": {
"architecture": "arm",
"os": "linux",
"variant": "v7"
}
}
]
}
Vous pouvez également afficher le fichier manifeste de l'image directement à partir de Cloud Shell.
Dans Cloud Shell, affichez le fichier manifeste de l'image :
DOCKER_CLI_EXPERIMENTAL=enabled docker manifest inspect gcr.io/"${DEVSHELL_PROJECT_ID}"/test:latestLe résultat est identique au fichier manifeste que vous pouvez développer sur la page Informations sur le condensé.
Configurer le déploiement continu à partir du pipeline de compilation
Pour créer l'image de conteneur pour la nouvelle architecture matérielle, vous devez modifier le fichier de configuration de compilation en ajoutant la nouvelle architecture cible. Une fois que vous avez validé et déployé la modification dans le dépôt source dans Cloud Source Repositories, Cloud Build démarre une nouvelle compilation. La compilation génère une nouvelle version de l'image de conteneur multi-architecture, y compris la compatibilité avec la nouvelle architecture matérielle.
Dans Cloud Shell, ajoutez la nouvelle plate-forme cible au fichier de configuration de compilation :
cd "$HOME"/cross-build sed -i -e 's/linux\/arm\/v7/linux\/arm\/v7,linux\/386/g' build-docker-image-trigger.yamlValidez et transférez la modification vers le dépôt du code source :
git add . git commit -m "add a new target platform" git pushAffichez le dernier fichier manifeste pour vérifier que la nouvelle plate-forme cible fait partie de la dernière image de conteneur :
DOCKER_CLI_EXPERIMENTAL=enabled docker manifest inspect gcr.io/${DEVSHELL_PROJECT_ID}/test:latestVérifiez que la plate-forme cible que vous venez d'ajouter se trouve dans le fichier manifeste, comme suit :
{ "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json", "schemaVersion": 2, "manifests": [ { "mediaType": "application/vnd.docker.distribution.manifest.v2+json", "digest": "sha256:bc80d063fccb4c370df9b505cbf4f8a814a366d99644de09ebee98af2ef0ff63", "size": 735, "platform": { "architecture": "amd64", "os": "linux" } }, { "mediaType": "application/vnd.docker.distribution.manifest.v2+json", "digest": "sha256:be10e4f01f529149815ebad7eb09edaa84ebef5b7d70d51f7d1acb5ceb1f61cd", "size": 735, "platform": { "architecture": "arm64", "os": "linux" } }, { "mediaType": "application/vnd.docker.distribution.manifest.v2+json", "digest": "sha256:f6ba5d5d3bc1ea0177e669517ea15a0d4fb97c06c7eca338afa43734d87af779", "size": 735, "platform": { "architecture": "arm", "os": "linux", "variant": "v7" } }, { "mediaType": "application/vnd.docker.distribution.manifest.v2+json", "digest": "sha256:a3c34621cca10974026f8ad0782af78539cd7bb0ebfa0082a27b2c3ed4418ca0", "size": 735, "platform": { "architecture": "386", "os": "linux" } } ] }
Effectuer un nettoyage
Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet Google Cloud que vous avez créé pour le tutoriel. Vous pouvez également supprimer les différentes ressources.
Supprimer le projet
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
Supprimer les ressources individuelles
Si vous souhaitez conserver le projet utilisé dans ce tutoriel, procédez comme suit pour supprimer les ressources que vous avez créées ici.
Dans Cloud Shell, supprimez les images de conteneur :
gcloud container images delete gcr.io/${DEVSHELL_PROJECT_ID}/test --quietSupprimez les ressources que vous avez provisionnées à l'aide de Terraform :
cd $HOME/solutions-build-multi-architecture-images-tutorial/terraform terraform destroySaisissez
yespour confirmer la suppression.
Étape suivante
- Consultez la page Images de conteneurs multi-architectures pour les appareils IoT.
- Découvrez comment gérer une infrastructure as Code avec Terraform, Cloud Build et GitOps.
- Consultez la page DevOps pour en savoir plus.
- Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.