Création d'images de conteneurs

Cette page explique comment configurer Cloud Build pour générer et stocker des images Docker. Si vous débutez avec Cloud Build, consultez le guides de démarrage rapide et la documentation Configuration des compilations présentation.

Cloud Build fournit des images prédéfinies auxquelles vous pouvez faire référence dans un fichier de configuration Cloud Build pour exécuter vos tâches. La compatibilité et la gestion de ces images est assurée par Google Cloud. Vous pouvez utiliser l'image Docker prédéfinie et compatible pour exécuter les commandes Docker et générer des images Docker.

Remarque :Ce guide est destiné aux conteneurs Linux. Pour les conteneurs Windows Server, consultez la page Créer des images multi-arch à l'aide de Cloud Build gke-windows-builder.

Avant de commencer

Les instructions de cette page partent du principe que vous connaissez bien Docker. En outre :

• Gardez à portée de main le code source de votre application ainsi que le fichier Dockerfile.
• Disposez d'un dépôt Docker pour stocker vos images dans Artifact Registry ou créez un dépôt.
• Si vous souhaitez utiliser les commandes gcloud de cette page, installez Google Cloud CLI.
• Si vous souhaitez exécuter les images, installez Docker.
• Si vous souhaitez signer les images avec une cosignature, suivez les instructions de la section Autoriser l'accès de service à service pour créer un compte de service spécifié par l'utilisateur et accorder les autorisations requises pour générer des jetons d'identité.

Compiler avec un fichier de configuration de compilation

Pour générer votre image Docker à l'aide d'un fichier de configuration de compilation, procédez comme suit :

1. Dans le répertoire contenant le code source de votre application, créez un fichier nommé cloudbuild.yaml ou cloudbuild.json.

2. Dans le fichier de configuration de compilation :

   • Ajoutez un champ name et spécifiez l'image Docker prédéfinie. La l'image prédéfinie est stockée sous gcr.io/cloud-builders/docker. Dans l'exemple ci-dessous, le champ name indique que le fichier Docker prédéfini est utilisée par Cloud Build pour exécuter la tâche indiquée par le champ args.

   • Dans le champ args, ajoutez les arguments requis pour générer l'image.

     YAML

     steps:
     - name: 'gcr.io/cloud-builders/docker'
       args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]
     

     JSON

     {
      "steps": [
       {
           "name": "gcr.io/cloud-builders/docker",
           "args": [
             "build",
             "-t",
             "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
             "."
            ]
        }
        ]
      }
     

     Remplacez les valeurs d'espace réservé dans la configuration de compilation ci-dessus par ce qui suit :

   • LOCATION: emplacement régional ou multirégional de votre dépôt Docker dans Artifact Registry.

   • PROJECT_ID : ID de votre projet Google Cloud.

   • REPOSITORY: nom de votre dépôt Docker dans Artifact Registry.

   • IMAGE_NAME : nom de votre image de conteneur

     Si Dockerfile et votre code source se trouvent dans des répertoires différents, ajoutez -f et le chemin d'accès à Dockerfile à la liste des arguments du champ args:

     YAML

     steps:
     - name: 'gcr.io/cloud-builders/docker'
       args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '-f', 'DOCKERFILE_PATH', '.' ]
     

     JSON

     {
      "steps": [
       {
           "name": "gcr.io/cloud-builders/docker",
           "args": [
             "build",
             "-t",
             "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME", '-f', 'DOCKERFILE_PATH', "."
            ]
        }
        ]
      }
     

     Remplacez les valeurs d'espace réservé dans la configuration de compilation ci-dessus par ce qui suit :

     • LOCATION : emplacement régional ou multirégional de votre dépôt.
     • PROJECT_ID : ID de votre projet Google Cloud.
     • REPOSITORY: nom de votre dépôt Artifact Registry.
     • IMAGE_NAME : nom de votre image de conteneur
     • DOCKERFILE_PATH: chemin d'accès à Dockerfile.

3. Lancez la compilation à l'aide du fichier de configuration de compilation :

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Remplacez les valeurs d'espace réservé dans la commande ci-dessus par les éléments suivants :

   • CONFIG_FILE_PATH : chemin d'accès du fichier de configuration de compilation.
   • SOURCE_DIRECTORY : chemin d'accès ou URL du code source.

   Si vous ne spécifiez pas les éléments CONFIG_FILE_PATH et SOURCE_DIRECTORY dans la commande gcloud builds submit, Cloud Build considère que le fichier de configuration et le code source se trouvent dans le répertoire de travail actuel.

Compiler avec un Dockerfile

Cloud Build vous permet de créer une image Docker à l'aide d'un simple fichier Dockerfile. Aucun fichier de configuration de compilation distinct n'est requis.

Pour générer une image à l'aide d'un Dockerfile, exécutez la commande suivante depuis le répertoire contenant votre code source et le fichier Dockerfile :

    gcloud builds submit --tag LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME

Remplacez les valeurs d'espace réservé dans la commande ci-dessus par les éléments suivants :

• LOCATION: emplacement régional ou multirégional de votre dépôt.
• PROJECT_ID : ID de votre projet Google Cloud.
• REPOSITORY: nom de votre dépôt Artifact Registry.
• IMAGE_NAME : nom de votre image de conteneur

Compiler avec les buildpacks Google Cloud

Cloud Build vous permet de créer une image sans fichier Dockerfile ou fichier de configuration de compilation. Pour ce faire, vous pouvez utiliser Packs de création de Google Cloud

Pour compiler à l'aide des buildpacks, exécutez la commande suivante à partir du répertoire contenant votre code source :

    gcloud builds submit --pack builder=BUILDPACK_BUILDER, \
        env=ENVIRONMENT_VARIABLE, \
        image=IMAGE_NAME

Remplacez les valeurs d'espace réservé dans les commandes ci-dessus par les éléments suivants :

• BUILDPACK_BUILDER : le compilateur buildpacks à utiliser. Si vous ne spécifiez pas de compilateur, Cloud Build utilise gcr.io/buildpacks/builder par défaut.
• ENVIRONMENT_VARIABLE : toutes les variables d'environnement de votre compilation.
• IMAGE : URL de l'image dans Artifact Registry. L'URL de l'image doit être au format LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME.

Voici quelques exemples de commandes :

• Exécuter une compilation à l'aide du fichier gcr.io/buildpacks/builder par défaut pour créer l'image us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app :

    gcloud builds submit --pack image=us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app
  

• Transmettre plusieurs variables d'environnement à votre compilation à l'aide de ^--^ comme séparateur. Pour en savoir plus sur les arguments d'échappement, consultez la section gcloud topic escaping.

    gcloud builds submit --pack \
        ^--^image=gcr.io/my-project/myimage--env=GOOGLE_ENTRYPOINT='java -jar target/myjar.jar',GOOGLE_RUNTIME_VERSION='3.1.301'
  

Configurer des déclencheurs pour utiliser des packs de création: en plus de procéder à la compilation à l'aide de la ligne de commande, vous pouvez configurer des déclencheurs afin d'utiliser des packs de création pour créer automatiquement votre image. Pour en savoir plus, consultez la page Créer et gérer des déclencheurs de compilation.

Différentes manières de stocker des images dans Artifact Registry

Vous pouvez configurer Cloud Build pour stocker l'image générée de l'une des manières suivantes :

• Avec le champ images, qui stocke l'image dans Artifact Registry une fois la compilation terminée.
• Avec la commande docker push, qui stocke l'image dans Artifact Registry dans votre flux de compilation.

L'utilisation du champ images et celle de la commande Docker push diffèrent en ce que si vous utilisez le champ images, l'image stockée sera affichée dans les résultats de la compilation. Cela inclut la page Build description (Description de la compilation) d'une compilation dans le la console Google Cloud, les résultats Build.get(), et les résultats de gcloud builds list. Toutefois, si vous utilisez la commande Docker push pour stocker l'image compilée, celle-ci ne sera pas affichée dans les résultats de la compilation.

Pour stocker une image dans le cadre du flux de compilation et l'afficher dans les résultats de la compilation, utilisez à la fois la commande Docker push et le champ images dans la configuration de compilation.

Pour stocker une image de conteneur dans Artifact Registry une fois la compilation terminée :

1. Si le dépôt cible n'existe pas, créez un dépôt.
2. Dans le répertoire contenant le code source de votre application et le fichier Dockerfile, créez un fichier nommé cloudbuild.yaml ou cloudbuild.json.

3. Dans votre fichier de configuration de compilation, ajoutez une étape chargée de générer l'image, puis ajoutez un champ images spécifiant l'image créée. Cela permet de stocker l'image Artifact Registry. L'extrait de code suivant montre une configuration de compilation à compiler une image et la stocker dans Artifact Registry:

   YAML

   steps:
   - name: 'gcr.io/cloud-builders/docker'
     args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]
   images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
   

   JSON

   {
   "steps": [
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "build",
           "-t",
           "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
           "."
       ]
   }
   ],
   "images": [
       "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
   ]
   }
   

   Où :

   • LOCATION : emplacement régional ou multirégional de votre dépôt.
   • PROJECT_ID : ID de votre projet Google Cloud.
   • REPOSITORY: nom de votre dépôt Artifact Registry.
   • IMAGE_NAME : nom de votre image de conteneur

4. Lancez la compilation à l'aide du fichier de configuration de compilation :

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Où :

   • CONFIG_FILE_PATH est le chemin d'accès du fichier de configuration de compilation
   • SOURCE_DIRECTORY est le chemin d'accès ou l'URL du code source.

Pour stocker l'image dans Artifact Registry dans le cadre de votre flux de compilation :

1. Dans le répertoire contenant le code source de votre application et le fichier Dockerfile, créez un fichier nommé cloudbuild.yaml ou cloudbuild.json.

2. Dans votre fichier de configuration, ajoutez une étape de compilation docker pour générer l'image, puis ajoutez une autre étape de compilation docker et transmettez des arguments pour appeler la commande push :

   YAML

   steps:
   - name: 'gcr.io/cloud-builders/docker'
     args: ['build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
   - name: 'gcr.io/cloud-builders/docker'
     args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
   

   JSON

   {
     "steps": [
      {
         "name": "gcr.io/cloud-builders/docker",
         "args": [
             "build",
             "-t",
             "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
             "."
          ]
      },
      {
          "name": "gcr.io/cloud-builders/docker",
          "args": [
             "push",
             "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
           ]
      }
     ]
   }
   

   Où :

   • LOCATION : emplacement régional ou multirégional de votre dépôt.
   • PROJECT_ID : ID de votre projet Google Cloud.
   • REPOSITORY: nom de votre dépôt Artifact Registry.
   • IMAGE_NAME : nom de votre image de conteneur

3. Lancez la compilation à l'aide du fichier de configuration de compilation :

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Où :

   • CONFIG_FILE_PATH est le chemin d'accès du fichier de configuration de compilation
   • SOURCE_DIRECTORY est le chemin d'accès ou l'URL du code source.

Pour stocker une image dans le cadre du flux de compilation et l'afficher dans les résultats de la compilation :

1. Dans le répertoire contenant le code source de votre application et le fichier Dockerfile, créez un fichier nommé cloudbuild.yaml ou cloudbuild.json.

2. Dans votre fichier de configuration, après l'étape de compilation de l'image, ajoutez une étape pour appeler la commande Docker push et ajoutez le champ images :

   YAML

   steps:
   - name: 'gcr.io/cloud-builders/docker'
     args: ['build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
   - name: 'gcr.io/cloud-builders/docker'
     args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
   images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
   

   JSON

   {
       "steps": [
      {
          "name": "gcr.io/cloud-builders/docker",
          "args": [
              "build",
              "-t",
              "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
              "."
           ]
      },
      {
          "name": "gcr.io/cloud-builders/docker",
          "args": [
              "push",
              "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
           ]
      }
      ],
       "images": [
          "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
       ]
   }
   

   Où :

   • LOCATION : emplacement régional ou multirégional de votre dépôt.
   • PROJECT_ID : ID de votre projet Google Cloud.
   • REPOSITORY: nom de votre dépôt Artifact Registry.
   • IMAGE_NAME : nom de votre image de conteneur

3. Lancez la compilation à l'aide du fichier de configuration de compilation :

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Où :

   • CONFIG_FILE_PATH est le chemin d'accès du fichier de configuration de compilation
   • SOURCE_DIRECTORY est le chemin d'accès ou l'URL du code source.

Signer les images de conteneurs avec cosign

Si vous stockez des images dans Artifact Registry, vous pouvez ajouter une couche de sécurité supplémentaire à l'aide de la commande Cosign créer un enregistrement indiquant le compte de service utilisé pour lancer une compilation. Soutenu par la norme OpenID Connect (OIDC), les auditeurs peuvent utiliser cet enregistrement pour vérifier qu'une image a été créée par de service géré.

Remarque :Les étapes suivantes ne peuvent pas être effectuées avec le compte de service Cloud Build. Suivez les instructions de la section Autoriser l'accès de service à service pour créer un compte de service spécifié par l'utilisateur et accorder les autorisations requises pour générer des jetons d'identité.

Les étapes suivantes montrent comment utiliser votre fichier de configuration cloudbuild.yaml pour obtenir un jeton d'identité et signer votre image de conteneur.

YAML

  steps:
  - name: 'gcr.io/cloud-builders/docker'
    id: 'tag-and-push'
    script: |
      #!/bin/sh
      set -e
      docker build -t $_IMAGE .
      docker push "$_IMAGE"
      docker inspect $_IMAGE --format "$_IMAGE@{{.Id}}" >image_with_digest
  - name: 'gcr.io/cloud-builders/gcloud'
    id: 'generate-token'
    script: |
      #!/bin/sh
      set -e
      gcloud auth print-identity-token --audiences=sigstore > token
  - name: 'gcr.io/cloud-builders/docker'
    id: 'sign-image'
    script: |
      #!/bin/sh
      set -e
      docker run \
      --network=cloudbuild \
      --mount source=home-volume,target=/builder/home \
      --rm \
      -e SIGSTORE_NO_CACHE=true \
      -e HOME=/builder/home \
      gcr.io/projectsigstore/cosign \
      sign --identity-token=$(cat token) $(cat image_with_digest) -y
  service_account: '$_SERVICE_ACCOUNT'
  artifacts:
    images:
    - $_IMAGE
  substitutions:
    _IMAGE: 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME'
    _SERVICE_ACCOUNT_ID: 'SERVICE_ACCOUNT_ID'
    _SERVICE_ACCOUNT: projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}
  options:
    env:
    - '_IMAGE=$_IMAGE'
    dynamic_substitutions: true
    logging: CLOUD_LOGGING_ONLY

JSON

    {
        "steps": [
            {
                "name": "gcr.io/cloud-builders/docker",
                "id": "tag-and-push",
                "script": "#!/bin/sh set -e \ndocker build -t $_IMAGE . \ndocker push \"$_IMAGE\""
            },
            {
                "name": "gcr.io/cloud-builders/gcloud",
                "id": "generate-token-and-get-digest",
                "script": "#!/bin/sh set -e \ngcloud auth print-identity-token --audiences=sigstore > token \ngcloud container images describe \"$_IMAGE\" --format=\"value(image_summary.fully_qualified_digest)\" > image_with_digest"
            },
            {
                "name": "gcr.io/projectsigstore/cosign",
                "id": "sign-image",
                "script": "#!/busybox/sh cosign sign --identity-token=$(cat token) $(cat image_with_digest) -y",
                "env": [
                    "SIGSTORE_NO_CACHE=true"
                ]
            }
        ],
        "service_account": "$_SERVICE_ACCOUNT",
        "artifacts": {
            "images": [
                "$_IMAGE"
            ]
        },
        "substitutions": {
            "_IMAGE": "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
            "_SERVICE_ACCOUNT_ID": "SERVICE_ACCOUNT_ID",
            "_SERVICE_ACCOUNT": "projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}"
        },
        "options": {
            "env": [
                "_IMAGE=$_IMAGE"
            ],
            "dynamic_substitutions": true,
            "logging": "CLOUD_LOGGING_ONLY"
        }
    }

Où :

• LOCATION est l'emplacement régional ou multirégional du dépôt dans lequel l'image est stockée, par exemple us-east1 ou us.

• PROJECT_ID : ID de votre projet Google Cloud.

• REPOSITORY est le nom du dépôt dans lequel l'image sont stockées.

• IMAGE_NAME correspond au nom de l'image.

• SERVICE_ACCOUNT_ID correspond à l'adresse e-mail du compte de service spécifié par l'utilisateur avec lequel vous souhaitez exécuter votre build. Par exemple, une adresse e-mail de compte de service se présente comme suit : [e-mail].

Pour vérifier la signature, installez cosign sur votre ordinateur local, puis exécutez la commande cosign verify :

cosign verify \
--certificate-identity=SERVICE_ACCOUNT_ID \
--certificate-oidc-issuer=https://accounts.google.com \
IMAGE

Où :

• SERVICE_ACCOUNT_ID est l'adresse e-mail du compte de service approuvé que vous prévoyez d'avoir utilisé pour créer l'image de conteneur.
• IMAGE correspond au nom complet de l'image, y compris le condensé de l'image sha256.

Remarque : Vous devez spécifier le condensé de l'image, car il s'agit d'un identifiant immuable de votre image. Les tags sont modifiables, ce qui les rend moins fiables. Voir Versions des images de conteneur pour en savoir plus sur les versions.

Exécuter l'image Docker

Pour vérifier le bon fonctionnement de l'image compilée, vous pouvez l'exécuter à l'aide de Docker.

1. Configurez Docker pour qu'il utilise vos identifiants Artifact Registry lors de l'interaction avec Artifact Registry. (Vous n'avez besoin de le faire qu'une seule fois.) Utilisez la commande suivante pour vous authentifier à l'aide de gcloud credential helper.

   gcloud auth configure-docker HOSTNAME-LIST
   

   Où HOSTNAME-LIST est une liste de noms d'hôte de dépôt séparés par une virgule à ajouter à la configuration de l'assistant d'identification.

   Par exemple, pour ajouter les régions us-central1 et asia-northeast1, exécutez la commande suivante :

   gcloud auth configure-docker us-central1-docker.pkg.dev,asia-northeast1-docker.pkg.dev
   

2. Exécutez l'image Docker que vous avez créée précédemment :

   docker run LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME
   

   Où :

   • LOCATION : emplacement régional ou multirégional de votre dépôt.
   • PROJECT_ID : ID de votre projet Google Cloud.
   • REPOSITORY: nom de votre dépôt Artifact Registry.
   • IMAGE_NAME : nom de votre image de conteneur

   Un résultat semblable aux lignes suivantes s'affiche :

   Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.
   

Étape suivante

• Découvrez comment créer des applications Java.
• Découvrez comment créer des applications Python.
• Découvrez comment créer des applications Go.
• Découvrez comment stocker des artefacts de compilation dans Cloud Storage.
• Découvrez comment stocker des artefacts de compilation dans Artifact Registry.
• Découvrez comment résoudre les erreurs de compilation.