Cette page a été traduite par l'API Cloud Translation.

Créer des images de conteneur

Cette page explique comment configurer Cloud Build pour générer et stocker des images Docker. Si vous débutez avec Cloud Build, commencez par lire les guides de démarrage rapide et la présentation de la configuration des compilations.

Cloud Build fournit des images prédéfinies que vous pouvez référencer 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 compatible pour exécuter des commandes Docker et créer des images Docker.

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 les images dans Artifact Registry, ou créez un dépôt.
Si vous souhaitez exécuter les commandes gcloud de cette page, installez la Google Cloud CLI.
Si vous voulez 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'ID.

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 :

Dans le répertoire contenant le code source de votre application, créez un fichier nommé cloudbuild.yaml ou cloudbuild.json.
Dans le fichier de configuration de compilation :
- Ajoutez un champ name et spécifiez l'image Docker prédéfinie. L'image prédéfinie est stockée dans gcr.io/cloud-builders/docker. Dans l'exemple de fichier de configuration ci-dessous, le champ name indique que l'image Docker prédéfinie 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.
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 packs de création Google Cloud

Cloud Build vous permet de créer une image sans fichier Dockerfile ou fichier de configuration de compilation. Pour ce faire, utilisez les buildpacks 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 :

à l'aide du champ images, qui stocke l'image dans Artifact Registry une fois la compilation terminée.
à l'aide de la commande docker push, qui stocke l'image dans Artifact Registry dans le cadre de 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 Description de la compilation pour une compilation dans la console Google Cloud, ainsi que les résultats de Build.get() et 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:

Si le dépôt cible n'existe pas, créez-en un.
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.
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. L'image est alors stockée dans Artifact Registry. L'extrait de code suivant montre une configuration de compilation permettant de générer une image et de 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
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 votre flux de compilation:

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.

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

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 :

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.

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

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 des images de conteneurs avec une cosignation

Si vous stockez des images dans Artifact Registry, vous pouvez ajouter une couche de sécurité supplémentaire à l'aide de l'outil cosign afin de créer un enregistrement du compte de service utilisé pour lancer une compilation. Grâce à la norme OpenID Connect (OIDC), les auditeurs peuvent utiliser cet enregistrement pour vérifier qu'une image a été créée par un compte de service de confiance.

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"
  - name: 'gcr.io/cloud-builders/gcloud'
    id: 'generate-token-and-get-digest'
    script: |
      #!/bin/sh
      set -e
      gcloud auth print-identity-token --audiences=sigstore > token
      gcloud 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

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 où 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 est stockée.
IMAGE_NAME correspond au nom de l'image.
SERVICE_ACCOUNT_ID est l'adresse e-mail du compte de service spécifié par l'utilisateur avec lequel vous souhaitez exécuter la compilation. Par exemple, l'adresse e-mail d'un compte de service se présente comme suit : service-account-name@project-id.iam.gserviceaccount.com.

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 de confiance qui devrait avoir été utilisé pour créer l'image de conteneur.
IMAGE est le nom complet de l'image, y compris le condensé de l'image sha256.

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.

Configurez Docker pour qu'il utilise vos identifiants Artifact Registry lors de l'interaction avec Artifact Registry. (Cette opération n'est requise qu'une seule fois.) Exécutez la commande suivante pour vous authentifier à l'aide de gcloud credential helper.
```
gcloud auth configure-docker HOSTNAME-LIST
```
Où HOSTNAME-LIST correspond à une liste de noms d'hôtes 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
```
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.
```

Étapes suivantes

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.