Création et test de code Go

Introduction

Ce guide explique comment générer, tester et publier un package Go.

Les exécuteurs hébergés dans GitHub ont un cache d’outils où sont préinstallés des logiciels, notamment les dépendances pour Go. Pour obtenir la liste complète des logiciels à jour et des versions préinstallées de Swift et Xcode, consultez « Utilisation des exécuteurs hébergés par GitHub ».

Prérequis

Vous devez déjà être familiarisé avec la syntaxe YAML et savoir comment elle s’utilise avec GitHub Actions. Pour plus d’informations, consultez « Workflow syntax for GitHub Actions ».

Il est recommandé de connaître les bases du langage Go. Pour plus d’informations, consultez Bien démarrer avec Go.

Utilisation d’un workflow de démarrage pour Go

Pour commencer rapidement, ajoutez le workflow de démarrage à l’annuaire .github/workflows de votre référentiel.

GitHub fournit un workflow de démarrage Go qui doit fonctionner pour la plupart des projets Go. Les sections suivantes de ce guide donnent des exemples de la façon dont vous pouvez personnaliser ce workflow de démarrage.

1. Dans votre instance GitHub Enterprise Server, accédez à la page principale du dépôt.

2. Sous le nom de votre dépôt, cliquez sur Actions.

   

3. Si vous disposez déjà d’un workflow dans votre dépôt, cliquez sur Nouveau workflow.

4. La page « Choisir un workflow » présente une sélection de workflows de démarrage recommandés. Recherchez « go ».

5. Filtrez la sélection des flux de travail en cliquant sur Intégration continue.

6. Dans le workflow « Go – par GitHub Actions », cliquez sur Configurer.

   Si vous ne trouvez pas le workflow de démarrage « Go, par GitHub Actions », copiez le code de workflow suivant dans un nouveau fichier appelé go.yml dans l’annuaire .github/workflows de votre référentiel.

   YAML

   name: Go
   
   on:
     push:
       branches: [ "main" ]
     pull_request:
       branches: [ "main" ]
   
   jobs:
     build:
   
       runs-on: self-hosted
       steps:
         - uses: actions/checkout@v4
   
         - name: Set up Go
           uses: actions/setup-go@v3
           with:
             go-version: '1.20'
   
         - name: Build
           run: go build -v ./...
   
         - name: Test
           run: go test -v ./...
   

7. Modifiez le workflow en fonction des besoins. Par exemple, modifiez la version de Go.

8. Cliquez sur Valider les changements.

Spécification d’une version de Go

Le moyen le plus simple de spécifier une version Go consiste à utiliser l’action setup-go fournie par GitHub. Pour plus d’informations, consultez l’action setup-go.

Pour utiliser une version préinstallée de Go sur un exécuteur hébergé par GitHub, passez la version concernée à la propriété go-version de l’action setup-go. Cette action recherche une version spécifique de Go à partir du cache d’outils de chaque exécuteur, et ajoute les fichiers binaires nécessaires à PATH. Ces modifications seront conservées pendant toute la durée du travail.

L’action setup-go est recommandée pour l’utilisation de Go avec GitHub Actions, car cela contribue à garantir un comportement cohérent sur tous les exécuteurs et toutes les versions de Go. Si vous utilisez un exécuteur auto-hébergé, vous devez installer Go et l’ajouter à PATH.

Utilisation de plusieurs versions de Go

name: Go

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.19', '1.20', '1.21.x' ]

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go ${{ matrix.go-version }}
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      # You can test your matrix by printing the current Go version
      - name: Display Go version
        run: go version

name: Go

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.19', '1.20', '1.21.x' ]

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go ${{ matrix.go-version }}
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      # You can test your matrix by printing the current Go version
      - name: Display Go version
        run: go version

Utilisation d’une version spécifique de Go

Vous pouvez configurer votre travail pour qu’il utilise une version spécifique de Go, comme 1.20.8. Vous pouvez également utiliser la syntaxe de versioning sémantique pour obtenir la dernière version mineure. Cet exemple utilise la dernière version corrective de Go 1.21 :

      - name: Setup Go 1.21.x
        uses: actions/setup-go@v3
        with:
          # Semantic version range syntax or exact version of Go
          go-version: '1.21.x'

      - name: Setup Go 1.21.x
        uses: actions/setup-go@v3
        with:
          # Semantic version range syntax or exact version of Go
          go-version: '1.21.x'

Installer les dépendances

Vous pouvez utiliser go get pour installer des dépendances :

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.21.x'
      - name: Install dependencies
        run: |
          go get .
          go get example.com/octo-examplemodule
          go get example.com/octo-examplemodule@v1.3.4

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.21.x'
      - name: Install dependencies
        run: |
          go get .
          go get example.com/octo-examplemodule
          go get example.com/octo-examplemodule@v1.3.4

Mise en cache des dépendances

Vous pouvez mettre en cache et restaurer des dépendances à l’aide de l’action setup-go. Par défaut, la mise en cache est désactivée, mais vous pouvez définir le paramètre cache sur true pour l’activer.

Lorsque la mise en cache est activée, l’action setup-go recherche le fichier de dépendance, go.sum, dans la racine du référentiel, et utilise le hachage du fichier de dépendance dans le cadre de la clé de cache.

      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.21.x'
          cache: true

      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.21.x'
          cache: true

Vous pouvez également utiliser le paramètre cache-dependency-path pour les cas où plusieurs fichiers de dépendance sont utilisés ou lorsqu’ils se trouvent dans des sous-répertoires différents.

      - uses: actions/setup-go@v3
        with:
          go-version: '1.17'
          cache: true
          cache-dependency-path: subdir/go.sum

      - uses: actions/setup-go@v3
        with:
          go-version: '1.17'
          cache: true
          cache-dependency-path: subdir/go.sum

Si vous avez une exigence particulière ou si vous avez besoin d’un contrôle plus précis pour la mise en cache, vous pouvez utiliser l’action cache. Pour plus d’informations, consultez « Mise en cache des dépendances pour accélérer les workflows ».

Génération et test de votre code

Vous pouvez utiliser les mêmes commandes que celles que vous utilisez localement pour générer et tester votre code. Cet exemple de workflow montre comment utiliser go build et go test dans un travail :

name: Go
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.21.x'
      - name: Install dependencies
        run: go get .
      - name: Build
        run: go build -v ./...
      - name: Test with the Go CLI
        run: go test

name: Go
on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: '1.21.x'
      - name: Install dependencies
        run: go get .
      - name: Build
        run: go build -v ./...
      - name: Test with the Go CLI
        run: go test

Empaquetage des données de workflow en tant qu’artefacts

Une fois le workflow terminé, vous pouvez charger les artefacts résultants à des fins d’analyse. Par exemple, vous devrez peut-être enregistrer des fichiers journaux, des vidages principaux, des résultats de test ou des captures d’écran. L’exemple suivant montre comment utiliser l’action upload-artifact pour charger les résultats de test.

Pour plus d’informations, consultez « Stockage des données de workflow en tant qu’artefacts ».

name: Upload Go test results

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.19', '1.20', '1.21.x' ]

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      - name: Install dependencies
        run: go get .
      - name: Test with Go
        run: go test -json > TestResults-${{ matrix.go-version }}.json
      - name: Upload Go test results
        uses: actions/upload-artifact@v3
        with:
          name: Go-results-${{ matrix.go-version }}
          path: TestResults-${{ matrix.go-version }}.json

name: Upload Go test results

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        go-version: [ '1.19', '1.20', '1.21.x' ]

    steps:
      - uses: actions/checkout@v4
      - name: Setup Go
        uses: actions/setup-go@v3
        with:
          go-version: ${{ matrix.go-version }}
      - name: Install dependencies
        run: go get .
      - name: Test with Go
        run: go test -json > TestResults-${{ matrix.go-version }}.json
      - name: Upload Go test results
        uses: actions/upload-artifact@v3
        with:
          name: Go-results-${{ matrix.go-version }}
          path: TestResults-${{ matrix.go-version }}.json