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

Créer et tester des applications Go

Cette page explique comment utiliser Cloud Build pour compiler, tester et déployer des applications Go.

Avant de commencer

Les instructions de cette page partent du principe que vous connaissez bien Go. Notez en outre les points suivants:

Enable the Cloud Build, Cloud Run, and Artifact Registry APIs.
Enable the APIs
Pour exécuter les commandes gcloud sur cette page, installez Google Cloud CLI.
Gardez à portée de main votre projet Go.
Si vous souhaitez conteneuriser votre application Go à l'aide de Cloud Build, vous avez besoin d'un fichier Dockerfile et du code source.
Si vous souhaitez stocker le conteneur créé dans Artifact Registry, créez un dépôt Docker dans Artifact Registry.
Si vous souhaitez stocker les journaux de test dans Cloud Storage, créez un bucket dans Cloud Storage.

Autorisations IAM requises

Pour stocker des journaux de test dans Logging, attribuez le rôle Créateur des objets de stockage (roles/storage.objectCreator) pour le bucket Cloud Storage à votre compte de service de compilation.
Pour stocker des images compilées dans Artifact Registry, accordez le rôle Rédacteur Artifact Registry (roles/artifactregistry.writer) à votre compte de service de compilation.

Pour obtenir des instructions sur l'attribution de rôles, consultez la page Attribuer un rôle à l'aide de la page IAM.

Configurer des compilations Go

L'image golang publique de Docker Hub est compatible avec la compilation utilisant des modules Go. Utiliser cette image comme étape de compilation dans votre fichier de configuration Cloud Build vous permet d'appeler des commandes go au sein de l'image. Les arguments transmis à cette étape de compilation sont directement transmis à l'outil golang, ce qui vous permet d'exécuter n'importe quelle commande go dans cette image.

Cette section décrit un exemple de fichier de configuration de compilation pour une application Go. Il comporte des étapes de compilation pour compiler l'application, ajouter des tests unitaires et, une fois les tests réussis, conteneuriser et déployer l'application.

Pour compiler votre application Go :

Dans le répertoire racine de votre projet, créez un fichier de configuration Cloud Build nommé cloudbuild.yaml.
Compilation et test: si vous avez défini des tests unitaires dans votre application, vous pouvez configurer Cloud Build pour exécuter les tests en ajoutant les champs suivants dans une étape de compilation:
- name: définissez la valeur de ce champ sur golang pour utiliser l'image golang de Docker Hub pour votre tâche.
- entrypoint: définissez la valeur de ce champ sur /bin/bash. Cela vous permet d'exécuter des commandes bash multilignes directement à partir de l'étape de compilation.
- args : Le champ args d'une étape de compilation prend une liste d'arguments et la transmet à l'image à laquelle le champ name fait référence. Dans l'exemple suivant, le champ args utilise les arguments pour:
  - Exécuter l'outil de mise en forme du journal de test pour télécharger la sortie du journal de test
  - Affichage de la sortie du journal.
  - Enregistrement des résultats du test dans sponge.log.
  - Génération des résultats dans sponge.log dans un fichier XML JUnit Le nom du fichier XML JUnit est construit à l'aide de la version courte de l'ID de commit associé à votre compilation. Une étape de compilation ultérieure enregistrera les journaux de ce fichier dans Cloud Storage.
```
steps:
  # Run tests and save to file
  - name: golang:1.23
    entrypoint: /bin/bash
    args: 
      - -c
      - |
        go install github.com/jstemmer/go-junit-report/v2@latest
        2>&1 go test -timeout 1m -v ./... | /go/bin/go-junit-report -set-exit-code -iocopy -out ${SHORT_SHA}_test_log.xml
```
Conteneuriser l'application: après avoir ajouté l'étape de compilation pour vous assurer que les tests sont concluants, vous pouvez compiler l'application. Cloud Build fournit une image Docker prédéfinie que vous pouvez utiliser pour conteneuriser votre application Go. Pour conteneuriser votre application, ajoutez les champs suivants à l'étape de compilation:
- name: définissez la valeur de ce champ sur gcr.io/cloud-builders/docker pour pouvoir utiliser l'image Docker prédéfinie pour votre tâche.
- args: ajoutez les arguments de la commande docker build en tant que valeurs pour ce champ.
L'étape de compilation suivante crée l'image myimage et lui ajoute un tag correspondant à la version abrégée de votre ID de commit. L'étape de compilation utilise des substitutions pour l'ID de projet, le nom du dépôt et les valeurs SHA courtes. Par conséquent, ces valeurs sont automatiquement remplacées au moment de la compilation. Notez que vous devrez créer ou disposer d'un dépôt Docker existant dans Artifact Registry pour stocker l'image.
```
# Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 
         'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', '.']
```
Transférer le conteneur vers Artifact Registry: vous pouvez stocker le conteneur créé dans Artifact Registry, un service Google Cloud qui vous permet de stocker, gérer et sécuriser des artefacts de compilation. Pour ce faire, vous devez disposer d'un dépôt Docker existant dans Artifact Registry. Pour configurer Cloud Build afin de stocker l'image dans un dépôt Docker Artifact Registry, ajoutez une étape de compilation avec les champs suivants:
- name : définissez la valeur de ce champ sur gcr.io/cloud-builders/docker pour utiliser l'image de compilateur officielle docker pour votre tâche.
- args: ajoutez les arguments de la commande docker push en tant que valeurs de ce champ. Pour l'URL de destination, saisissez le dépôt Docker Artifact Registry dans lequel vous souhaitez stocker l'image.
L'étape de compilation suivante transfère l'image que vous avez créée lors de l'étape précédente vers Artifact Registry:
```
# Docker push to Google Artifact Registry
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA']
```
Déployez le conteneur sur Cloud Run: pour déployer l'image sur Cloud Run, ajoutez une étape de compilation avec les champs suivants:
- name : définissez la valeur de ce champ sur google/cloud-sdk pour utiliser l'image de la gcloud CLI afin d'appeler la commande gcloud permettant de déployer l'image sur Cloud Run.
- args: ajoutez les arguments de la commande gcloud run deploy en tant que valeurs de ce champ.
L'étape de compilation suivante déploie l'image créée précédemment sur Cloud Run:
```
# Deploy to Cloud Run
- name: 'gcr.io/cloud-builders/gcloud'
  args: ['run', 'deploy', 'helloworld-${SHORT_SHA}', 
         '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', 
         '--region', 'us-central1', '--platform', 'managed']
```

Enregistrer les journaux de test dans Cloud Storage: vous pouvez configurer Cloud Build pour stocker tous les journaux de test dans Cloud Storage en spécifiant un emplacement de bucket et un chemin d'accès existants vers les journaux de test.

L'étape de compilation suivante stocke les journaux de test que vous avez enregistrés dans le fichier XML JUnit dans un bucket Cloud Storage:

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://$_BUCKET_NAME/
    paths:
      - ${SHORT_SHA}_test_log.xml

L'extrait de code suivant montre le fichier de configuration de compilation complet pour toutes les étapes décrites ci-dessus:

steps:
  # Run tests and save to file
  - name: golang:1.23
    entrypoint: /bin/bash
    args: 
      - -c
      - |
        go install github.com/jstemmer/go-junit-report/v2@latest
        2>&1 go test -timeout 1m -v ./... | /go/bin/go-junit-report -set-exit-code -iocopy -out ${SHORT_SHA}_test_log.xml

  # Docker Build
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 
           'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', '.']

  # Docker push to Google Artifact Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA']

  # Deploy to Cloud Run
  - name: 'gcr.io/cloud-builders/gcloud'
    args: ['run', 'deploy', 'helloworld-${SHORT_SHA}', 
           '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', 
           '--region', 'us-central1', '--platform', 'managed']

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://$_BUCKET_NAME/
    paths:
      - ${SHORT_SHA}_test_log.xml
# Store images in Google Artifact Registry
images:
  - us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA

Démarrez la compilation à l'aide de la CLI gcloud ou de déclencheurs de compilation. Vous devez spécifier le nom du dépôt Artifact Registry au démarrage de la compilation.

Pour spécifier le dépôt Artifact Registry lors du démarrage de la compilation à l'aide de la gcloud CLI :
```
gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_AR_REPO_NAME="AR_REPO_NAME"
```
Remplacez AR_REPO_NAME par le nom de votre dépôt Artifact Registry.

Pour spécifier le dépôt Artifact Registry lors de la compilation avec des déclencheurs de compilation, spécifiez le nom de votre dépôt Artifact Registry dans le champ Variables de substitution lors de la création du déclencheur de compilation.

Étape suivante

Découvrez comment effectuer des déploiements bleu-vert sur Compute Engine.
Découvrez comment créer des images de conteneurs.
Découvrez comment résoudre les erreurs de compilation.