Compiler, tester et déployer des artefacts

Cette page vous explique comment utiliser des images de compilateur officielles de Cloud Build pour écrire des configurations de compilation, afin d'extraire un code source et des dépendances, ainsi que pour compiler, tester et déployer des artefacts.

Si vous disposez déjà d'un fichier de configuration de compilation et que vous souhaitez exécuter vos compilations sur Cloud Build, consultez les pages Démarrer des compilations manuellement et Automatiser les compilations avec des déclencheurs de compilation.

Avant de commencer

Récupérer des dépendances

Récupérez un code source ou installez des dépendances à l'aide d'une étape de compilation qui exécute des outils, tels que docker, git, npm et gsutil :

docker

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['pull', 'gcr.io/$PROJECT_ID/latest-image']

git

steps:
- name: 'gcr.io/cloud-builders/git'
  args: ['clone', 'https://github.com/GoogleCloudPlatform/cloud-builders']

npm

steps:
- name: 'gcr.io/cloud-builders/npm'
  args: ['install']

gsutil

steps:
- name: 'gcr.io/cloud-builders/gsutil'
  args: ['cp', 'gs://mybucket/remotefile.zip', 'localfile.zip']

Compiler des images de conteneurs

Pour compiler des images de conteneurs Docker, utilisez l'étape de compilation docker dans laquelle vous pouvez appeler des commandes docker. Les arguments transmis à cette étape de compilation seront directement transférés vers docker, ce qui vous permettra d'exécuter n'importe quelle commande docker dans cette étape de compilation.

Ajoutez des instructions au fichier de configuration de compilation pour effectuer les actions suivantes :

  • Appeler le compilateur docker et transmettre les arguments pour appeler la commande Docker build. Dans la configuration de compilation suivante, l'étape de compilation de Docker est appelée deux fois pour compiler deux images. Leurs fichiers de code source se trouvent dans le répertoire de travail utilisé au moment de la compilation, comme indiqué par .. Le code source de gcr.io/my-project/image2 se trouve dans un sous-répertoire du répertoire de travail utilisé au moment de la compilation, subdirectory.
  • Ajouter le champ images pour envoyer les images obtenues vers Container Registry.

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/my-project/image1', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/my-project/image2', '.']
  dir: 'subdirectory'
images: ['gcr.io/my-project/image1', 'gcr.io/my-project/image2']

JSON

{
  "steps": [
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": ["build", "-t", "gcr.io/my-project/image1", "."]
    },
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": ["build", "-t", "gcr.io/my-project/image2", "."],
      "dir": "subdirectory"
    }
  ],
  "images": ["gcr.io/my-project/image1", "gcr.io/my-project/image2"]
}

Compiler des artefacts non issus de conteneurs

Cloud Build propose des étapes de compilation prises en charge pour les langages et outils courants que vous pouvez utiliser pour exécuter des compilations.

Pour compiler des artefacts non issus de conteneurs, ajoutez une section Étapes de compilation qui exécute des compilateurs, tels que maven, gradle, go ou bazel :

maven

steps:
- name: 'gcr.io/cloud-builders/mvn'
  args: ['install']
- name: 'gcr.io/cloud-builders/mvn'
  args: ['package']

gradle

steps:
- name: 'gcr.io/cloud-builders/gradle'
  args: ['build']

go

steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['build', 'my-package']

bazel

steps:
- name: 'gcr.io/cloud-builders/bazel'
  args: ['build', '//path/to:target']

Exécuter des tests unitaires et d'intégration

Si le code source est disponible, vous pouvez exécuter des tests unitaires et des tests d'intégration comme étapes de compilation. Chaque étape de compilation est exécutée avec son conteneur associé à un réseau de conteneurs Docker local nommé cloudbuild. Pour que les tests d'intégration fonctionnent, le nom du réseau doit être spécifié.

Supposons que vous disposez d'une application JavaScript avec des tests unitaires, d'un fichier Dockerfile qui crée une image Docker, et de tests d'intégration qui s'exécutent sur cette image en cours d'exécution.

Pour exécuter des tests unitaires et des tests d'intégration sur cette application, ajoutez des instructions aux éléments suivants dans le fichier de configuration de compilation :

  • Installez des dépendances pour exécuter la compilation.
  • Exécutez le test unitaire.
  • Compilez l'image Docker de l'application.
  • Exécutez l'application et les dépendances en arrière-plan à l'aide de Docker Compose.
  • Exécutez les tests d'intégration sur la pile Docker Compose en cours d'exécution.
  • Envoyez l'image créée vers Container Registry.

    steps:
    - name: 'gcr.io/cloud-builders/npm'
      args: ['install']
    - name: 'gcr.io/cloud-builders/npm'
      args: ['run', 'test:unit']
    - name: 'gcr.io/cloud-builders/docker'
      args: ['build', '-t', 'gcr.io/$PROJECT_ID/gcb-docker-compose:latest', '.']
    - name: 'docker/compose:1.15.0'
      args: ['up', '-d']
      env:
      - 'PROJECT_ID=$PROJECT_ID'
    - name: 'gcr.io/cloud-builders/npm'
      args: ['run', 'test:integration']
      env:
      - 'HOST=counter' # name of the running container
      - 'PORT=50051'
    images: ['gcr.io/$PROJECT_ID/gcb-docker-compose:latest']
    

Déployer des artefacts

Dans le cadre de votre pipeline de déploiement continu, Cloud Build peut exécuter des déploiements à l'aide d'outils de ligne de commande.

Procédez comme suit pour procéder à un déploiement sur GKE, App Engine, Cloud Functions et Firebase.

Kubernetes Engine

Pour déployer GKE, appelez l'étape de compilation gke-deploy :

  1. Activez l'API GKE.

  2. Créez un cluster.

  3. Ajoutez le rôle GKE au compte de service :

    1. Accédez à la page "Paramètres" de Cloud Build.

      Accéder à la page Paramètres de Cloud Build

      La page Service account permissions (Autorisations de compte de service) s'affiche :

      Capture d'écran de la page des autorisations de compte de service

    2. Définissez le rôle Kubernetes Engine Developer (Développeur sur Kubernetes Engine) sur l'état Activé.

  4. Ajoutez l'une des étapes de compilation suivantes dans votre fichier de configuration de compilation :

    • Ajoutez ces étapes de compilation si vous fournissez vos propres fichiers de configuration Kubernetes qui font référence à votre image :

      steps:
      - name: 'gcr.io/cloud-builders/docker'
        args: ["build", "-t", "gcr.io/[PROJECT-ID]/[IMAGE]", "."]
      - name: 'gcr.io/cloud-builders/docker'
        args: ["push", "gcr.io/[PROJECT-ID]/[IMAGE]"]
      - name: 'gcr.io/cloud-builders/gke-deploy:stable'
        args:
        - run
        - --filename=[CONFIG]
        - --image=gcr.io/[PROJECT-ID]/[IMAGE]:[TAG]
        - --location=[LOCATION]
        - --cluster=[CLUSTER]
      
    • Ajoutez ces étapes de compilation si vous ne disposez d'aucun fichier de configuration Kubernetes pour votre image :

      steps:
      - name: 'gcr.io/cloud-builders/docker'
        args: ["build", "-t", "gcr.io/[PROJECT-ID]/[IMAGE]", "."]
      - name: 'gcr.io/cloud-builders/docker'
        args: ["push", "gcr.io/[PROJECT-ID]/[IMAGE]"]
      - name: 'gcr.io/cloud-builders/gke-deploy:stable'
        args:
        - run
        - --image=gcr.io/[PROJECT-ID]/[IMAGE]:[TAG]
        - --location=[LOCATION]
        - --cluster=[CLUSTER]
      

Cette compilation appelle l'étape de compilation docker pour créer une image Docker et l'envoyer à Container Registry. La compilation appelle ensuite l'étape de compilation gke-deploy à déployer sur votre cluster GKE.

Pour utiliser cet exemple de configuration de compilation, indiquez les informations suivantes :

  • [PROJECT-ID], l'ID du projet GCP
  • [IMAGE], le nom de l'image et son [TAG] comme la version souhaitée ou le commit SHA
  • [CLUSTER], le nom du cluster pour lequel les informations d'authentification sont demandées
  • [LOCATION], la région ou la zone du cluster
  • [CONFIG], le (ou les) fichier(s) de configuration Kubernetes à utiliser par gke-deploy run, le cas échéant

App Engine

Pour déployer une application depuis une image de conteneur vers App Engine, appelez l'étape de compilation gcloud avec des arguments pour la commande gcloud app deploy :

  1. Activez l'API App Engine.

  2. Ajoutez le rôle App Engine au compte de service :

    1. Accédez à la page "Paramètres" de Cloud Build.

      Accéder à la page Paramètres de Cloud Build

      La page Service account permissions (Autorisations de compte de service) s'affiche :

      Capture d'écran de la page des autorisations de compte de service

    2. Définissez le rôle App Engine Admin (Administrateur App Engine) sur l'état Activé.

  3. Créez un fichier de configuration de compilation qui utilise gcloud app deploy :

    steps:
    - name: 'gcr.io/cloud-builders/gcloud'
      args: ['app', 'deploy']
      timeout: '1600s'
    

L'étape de compilation gcloud appelle la commande gcloud app deploy pour compiler une image de conteneur avec votre code source, puis déploie l'image sur App Engine.

Cloud Functions

Pour déployer une application sur Cloud Functions, appelez l'étape de compilation gcloud pour faire appel à gcloud functions deploy :

  1. Activez l'API Cloud Functions.

  2. Ajoutez le rôle Cloud Functions au compte de service :

    1. Accédez à la page "Paramètres" de Cloud Build.

      Accéder à la page Paramètres de Cloud Build

      La page Service account permissions (Autorisations de compte de service) s'affiche :

      Capture d'écran de la page des autorisations de compte de service

    2. Définissez le rôle Cloud Functions Developer (Développeur Cloud Functions) sur l'état Activé.

    3. Sélectionnez Accorder l'accès à tous les comptes de service pour attribuer le rôle Utilisateur du compte de service à tous les comptes de service du projet sur votre page.

  3. Créez un fichier de configuration de compilation qui utilise gcloud functions deploy :

    steps:
    - name: 'gcr.io/cloud-builders/gcloud'
      args:
      - functions
      - deploy
      - [FUNCTION_NAME]
      - --source=.
      - --trigger-http
    

Cette commande génère le code source de l'application et appelle gcloud functions deploy pour déployer l'application sur Cloud Functions.

Cloud Run

Pour déployer une application sur Cloud Run, appelez l'étape de compilation gcloud pour faire appel à gcloud beta run deploy :

  1. Activez l'API Cloud Run.

  2. Ajoutez le rôle Cloud Run au compte de service :

    1. Accédez à la page "Paramètres" de Cloud Build.

      Accéder à la page Paramètres de Cloud Build

      La page Service account permissions (Autorisations de compte de service) s'affiche :

      Capture d'écran de la page des autorisations de compte de service

    2. Définissez le rôle Cloud Run Admin (Administrateur Cloud Run) sur l'état Activé.

    3. Sélectionnez Accorder l'accès à tous les comptes de service pour attribuer le rôle Utilisateur du compte de service à tous les comptes de service du projet sur votre page.

  3. Créez un fichier de configuration de compilation qui utilise gcloud beta run deploy :

    steps:
      # build the container image
    - name: 'gcr.io/cloud-builders/docker'
      args: ['build', '-t', 'gcr.io/$PROJECT_ID/[SERVICE-NAME]', '.']
      # push the container image to Container Registry
    - name: 'gcr.io/cloud-builders/docker'
      args: ['push', 'gcr.io/$PROJECT_ID/[SERVICE-NAME]']
      # Deploy container image to Cloud Run
    - name: 'gcr.io/cloud-builders/gcloud'
      args: ['beta', 'run', 'deploy', '[SERVICE-NAME]', '--image', 'gcr.io/$PROJECT_ID/[SERVICE-NAME]', '--region', '[REGION]', '--platform', 'managed']
    images:
    - gcr.io/$PROJECT_ID/[SERVICE-NAME]
    

Remplacez [SERVICE-NAME] et [REGION] par le nom et la région du service Cloud Run sur lequel vous déployez.

Si vous utilisez Cloud Run sur GKE, utilisez gke au lieu de managed, et --cluster et --cluster-location à la place du paramètre --region.

Cette commande génère le code source de l'application et appelle gcloud run deploy pour déployer l'application sur Cloud Run.

Pour plus d'informations sur le déploiement d'images sur Cloud Run, consultez la section Déployer sur Cloud Run.

Firebase

Vous pouvez utiliser Firebase dans vos compilations en créant une étape de compilation personnalisée Firebase.

Pour créer une étape de compilation Firebase, créez un fichier Dockerfile et un fichier de configuration de compilation à partir des exemples suivants.

Créez un fichier Dockerfile avec le contenu suivant. Celui-ci installe l'outil de ligne de commande Firebase, firebase, lorsqu'il est appelé par la compilation :

# use latest Node LTS (Boron)
FROM node:boron
# install Firebase CLI
RUN npm install -g firebase-tools

ENTRYPOINT ["/usr/local/bin/firebase"]

Créez une configuration de compilation nommée cloudbuild.yaml avec le contenu suivant. Cette configuration de compilation utilise le fichier Dockerfile pour intégrer firebase-tools dans un conteneur en tant que firebase. Ensuite, la compilation envoie l'image en conteneur à Container Registry pour l'utiliser ultérieurement dans des compilations :

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'gcr.io/[PROJECT_ID]/firebase', '.' ]
images:
- 'gcr.io/[PROJECT_ID]/firebase'

Lorsque Dockerfile et cloudbuild.yaml se trouvent dans le même répertoire, exécutez la commande suivante à partir de votre interface système ou d'une fenêtre de terminal :

gcloud builds submit --config=cloudbuild.yaml .

La commande gcloud builds envoie une compilation à Cloud Build qui utilise la configuration de compilation cloudbuild.yaml et la source dans le répertoire actif (indiqué par .). La compilation installe l'outil firebase dans l'environnement. Ensuite, l'outil est placé dans un conteneur et envoyé vers Container Registry.

Pour appeler firebase dans vos compilations, ajoutez l'étape de compilation gcr.io/[PROJECT_ID]/firebase à votre configuration de compilation :

steps:
- name: 'gcr.io/cloud-builders/npm'
  args: [ 'install' ]
- name: 'gcr.io/cloud-builders/npm'
  args: [ 'test' ]
- name: 'gcr.io/cloud-builders/npm'
  args: [ 'run', 'build.prod' ]
- name: 'gcr.io/[PROJECT_ID]/firebase'
  args: [ 'deploy', '-P', 'js-demo-fe-staging', '--token', '[FIREBASE_TOKEN]']

Pour utiliser cette configuration de compilation, renseignez la valeur [FIREBASE_TOKEN], qui est le jeton d'authentification Firebase généré.

Exemples de fichiers de configuration de compilation

Compilation déclenchée depuis GitHub

La configuration suivante montre une compilation simple déclenchée depuis GitHub. Ce type de configuration est généralement utilisé dans un pipeline CI/CD.

Dans cet exemple :

  • L'étape de compilation npm est appelée pour installer les dépendances et exécuter des tests unitaires.
  • L'étape de compilation docker est appelée pour compiler une image Docker de l'application et envoyer l'image à Container Registry.
  • L'étape de compilation gke-deploy est appelée pour déployer l'image compilée sur le cluster Kubernetes.

YAML

steps:
- name: 'gcr.io/cloud-builders/npm'
  args: ['install']
- name: 'gcr.io/cloud-builders/npm'
  args: ['test']
- name: 'gcr.io/cloud-builders/docker'
  args: ["build", "-t", "gcr.io/my-project/my-image:$REVISION_ID", "."]
- name: 'gcr.io/cloud-builders/docker'
  args: ["push", "gcr.io/my-project/my-image:$REVISION_ID"]
- name: 'gcr.io/cloud-builders/gke-deploy:stable'
  args:
  - 'run'
  - '--image=gcr.io/my-project/my-image:$REVISION_ID'
  - '--location=us-east4-b'
  - '--cluster=my-cluster'

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/npm",
        "args": [
            "install"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/npm",
        "args": [
            "test"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/my-project/my-image:$REVISION_ID",
            "."
        ]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "push",
            "gcr.io/my-project/my-image:$REVISION_ID"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/gke-deploy:stable",
        "args": [
            "run",
            "--image=gcr.io/my-project/my-image:$REVISION_ID",
            "--location=us-east4-b",
            "--cluster=my-cluster"
        ]
    }
    ]
}

Écrire des demandes de compilation sans envoi d'images

Vous pouvez utiliser Cloud Build pour exécuter des tâches arbitraires sans générer d'images Docker.

L'exemple suivant :

  • utilise docker pour générer un outil d'analyse ;
  • extrait certaines données du répertoire data-to-analyze ;
  • envoie les résultats d'analyse dans un bucket Cloud Storage.

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'analyzer', '.']

- name: 'gcr.io/cloud-builders/gsutil'
  args: ['cp', 'gs://my-data-warehouse/data-to-analyze.tgz', '.']

- name: 'debian'
  args: ['tar', '-xzf', 'data-to-analyze.tgz']

- name: 'analyzer'
  args: ['--output=results.csv']
  dir: 'data-to-analyze'

- name: 'gcr.io/cloud-builders/gsutil'
  args: ['cp', 'data-to-analyze/results.csv', 'gs://my-data-warehouse/results.tgz']

JSON

{
  "steps": [
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "analyzer",
        "."
      ]
    },
    {
      "name": "gcr.io/cloud-builders/gsutil",
      "args": [
        "cp",
        "gs://my-data-warehouse/data-to-analyze.tgz",
        "."
      ],
    },
    {
      "name": "debian",
      "args": [
        "tar",
        "-xzf",
        "data-to-analyze.tgz"
      ],
    },
    {
      "name": "analyzer",
      "args": [
        "--output=results.csv"
      ],
      "dir": "data-to-analyze"
    },
    {
      "name": "gcr.io/cloud-builders/gsutil",
      "args": [
        "cp",
        "data-to-analyze/results.csv",
        "gs://my-data-warehouse/results.tgz"
      ]
    }
  ]
}

Étape suivante