Comment utiliser les variables d’environnement de GitHub Actions

Play Video: How to Use GitHub Actions Environment Variables and Secrets

Pour améliorer l’efficacité de la mise en production de code fonctionnel, il est recommandé de mettre en place un pipeline d’intégration et de livraison continues (CI/CD). Ces pipelines automatisent la vérification des modifications de code avant leur mise en production et fournissent des outils pour automatiser le déploiement en production.

Une méthode courante consiste à utiliser votre système de gestion de versions existant. GitHub est l’un des systèmes de gestion de versions les plus populaires et propose GitHub Actions, qui permet aux développeurs de compiler, tester et déployer automatiquement du code afin de créer des pipelines CI/CD sécurisés.

Les tâches de GitHub Actions ont souvent besoin d’accéder à des variables d’environnement. Ces variables peuvent être définies à l’avance et utilisées uniquement par les pipelines exécutés dans l’environnement concerné. Les développeurs peuvent ainsi modifier le comportement du pipeline CI/CD selon les variables d’environnement, par exemple pour créer une version de production optimisée de l’application avant son déploiement en production.

Cet article pratique présente les variables d’environnement disponibles dans GitHub Actions et explique quand les utiliser.

Prérequis

Pour suivre ce tutoriel, vous avez besoin des éléments suivants :

• D’un accès à une machine équipée d’un éditeur de code (ce tutoriel utilise Visual Studio Code) et d’un compte GitHub.

• Du code d’exemple. Il contient une application Java simple qui nous servira à montrer comment fonctionnent les variables d’environnement.

Saviez-vous que nous proposons un plugin Snyk pour Visual Studio Code qui vous permet d’analyser votre projet pendant son développement ? Consultez la documentation pour en savoir plus.

Utiliser les variables d’environnement de GitHub Actions

Après avoir téléchargé le code d’exemple, créez un dépôt dans GitHub et ajoutez-y le code.

Le code d’exemple contient déjà un fichier de workflow GitHub Actions. L’extrait ci-dessous présente le contenu du fichier .github/workflows/pipeline.yml :

1name: Java CI with Maven
2
3on:
4  push:
5    branches: [ "main" ]
6  pull_request:
7    branches: [ "main" ]
8
9jobs:
10  build:
11
12    runs-on: ubuntu-latest
13
14    steps:
15    - uses: actions/checkout@v3
16    - name: Set up JDK 21
17      uses: actions/setup-java@v3
18      with:
19        java-version: '21'
20        distribution: 'temurin'
21        cache: maven
22    - name: Build with Maven
23      run: mvn -B package --file pom.xml

Ce fichier définit un workflow simple pour compiler notre application Java avec Maven.

Nous pouvons définir des variables d’environnement dans le fichier de configuration YAML du workflow à trois niveaux : workflow, tâche et étape. Ces niveaux déterminent la portée des variables d’environnement. Au niveau du workflow, les variables s’appliquent à l’ensemble du workflow. Au niveau de la tâche, elles s’appliquent à des tâches spécifiques. Les variables d’environnement d’étape s’appliquent à des étapes précises.

Examinons chacune de ces variables en détail.

Variables d’environnement du workflow

Pour définir une variable d’environnement au niveau du workflow, nous devons l’ajouter au niveau supérieur du fichier YAML. Ajoutons le code suivant sous la variable NAME, au début du fichier :

1env:
2  NAME: 'Snyk Demo'

Ce code définit une variable d’environnement appelée NAME, à laquelle nous pouvons désormais accéder partout dans notre workflow. Pour accéder à cette variable, nous devons utiliser une syntaxe spécifique, similaire à celle des variables d’environnement UNIX. Pour utiliser notre variable NAME, nous devons la faire précéder d’un signe dollar, ce qui donne $NAME.

Ajoutons une nouvelle étape à notre workflow, à la ligne 23, pour afficher cette variable :

1- name: Print name
2  run: echo "Hello $NAME"

Validez cette modification et envoyez-la vers le dépôt.

Ensuite, ouvrez GitHub dans un navigateur et accédez à l’onglet Actions du dépôt. Sélectionnez le dernier workflow sous Jobs, puis affichez la sortie de la tâche de compilation. Cliquez sur Print name. Une fois la section développée, vous verrez que la variable d’environnement a bien été affichée, comme dans l’image ci-dessous.

Les variables d’environnement au niveau du workflow sont utiles pour déclarer des variables qui s’appliquent à toutes les tâches et étapes. Nous pouvons, par exemple, les utiliser pour définir le type d’environnement dans lequel le workflow s’exécute : développement, test ou production. C’est utile pour les applications Node compilées avec npm, qui peuvent utiliser la variable NODE_ENV. Chaque tâche peut ainsi adopter le comportement approprié à l’environnement concerné. Pour en savoir plus sur la publication sécurisée de vos packages npm, consultez cet article du blog Snyk.

Variables d’environnement des tâches

Voyons maintenant comment définir des variables d’environnement pour les tâches et les étapes. La méthode est la même que pour les variables du workflow, mais il faut les définir dans la section correspondante.

Pour notre variable de tâche, nous voulons définir la version de Java comme suit :

1jobs:
2  build:
3    env:
4        JAVA_VERSION: '21'

Nous pouvons maintenant utiliser cette variable dans nos étapes, comme précédemment.

1steps:
2- uses: actions/checkout@v3
3- name: Set up JDK ${{env.JAVA_VERSION}}
4  uses: actions/setup-java@v3
5  with:
6    java-version: ${{env.JAVA_VERSION}}
7    distribution: 'temurin'
8    cache: maven

Vous remarquerez peut-être que la syntaxe est légèrement différente pour utiliser notre variable d’environnement JAVA_VERSION. Il s’agit ici d’utiliser les contextes pour accéder à une variable d’environnement. Les contextes permettent à GitHub Actions d’utiliser nos variables d’environnement sur n’importe quelle machine virtuelle, car ces tâches ne s’exécutent pas toujours sur la même machine virtuelle que celle où nous avons déclaré notre environnement.

Vous pouvez utiliser les variables d’environnement d’une tâche pour remplacer une variable définie au niveau du workflow si cette tâche nécessite une valeur différente, ou pour limiter la portée de la variable à une seule tâche.

Comme le montre l’exemple ci-dessus, nous pouvons utiliser les variables d’environnement des tâches pour définir la version de Java et ainsi utiliser cette variable à chaque étape. Si nous voulons utiliser une autre version de Java par la suite, il suffit de la modifier à un seul endroit : toutes les étapes de la tâche utiliseront automatiquement la nouvelle version.

Puisque vous travaillez déjà sur une action GitHub, vous pouvez facilement intégrer Snyk à GitHub Actions et analyser votre projet dès maintenant. Nous mettons à votre disposition des actions GitHub Snyk préconfigurées. Si ce n’est pas déjà fait, créez un compte Snyk et intégrez l’analyse dès aujourd’hui.

Variables d’environnement des étapes

Nous pouvons également définir des variables dans une étape. Voici un exemple de variable d’environnement d’étape. Modifiez l’étape Print name dans le fichier pipeline.yml pour qu’elle corresponde à l’extrait de code ci-dessous :

1- name: Print name
2  run: echo "Hello $NAME. $BUILD. Using Java Version $JAVA_VERSION"
3  env:
4    BUILD: 'We are currently running the Build job'

Les variables d’environnement d’étape limitent la portée à une seule étape. Elles sont utiles, par exemple, pour définir les chemins d’accès à des fichiers d’entrée ou de sortie propres à une étape. Dans l’exemple ci-dessus, nous avons utilisé la variable d’étape pour définir le texte à afficher.

Voici un exemple du fichier YAML complet du workflow GitHub, avec les nouvelles variables d’environnement de tâche et d’étape :

1name: Java CI with Maven
2
3env:
4  NAME: 'Snyk Demo'
5
6on:
7  push:
8    branches: [ "main" ]
9  pull_request:
10    branches: [ "main" ]
11
12jobs:
13  build:
14    env:
15        JAVA_VERSION: '21'
16
17    runs-on: ubuntu-latest
18
19    steps:
20    - uses: actions/checkout@v3
21    - name: Set up JDK ${{env.JAVA_VERSION}}
22      uses: actions/setup-java@v3
23      with:
24        java-version: ${{env.JAVA_VERSION}}
25        distribution: 'temurin'
26        cache: maven
27    - name: Build with Maven
28      run: mvn -B package --file pom.xml
29    - name: Print name
30      run: echo "Hello $NAME. $BUILD. Using Java Version $JAVA_VERSION"
31      env:
32        BUILD: 'We are currently running the Build job'

Enregistrez ce nouveau workflow dans GitHub et consultez le résultat, qui devrait ressembler à l’image ci-dessous.

Nous avons configuré notre variable d’environnement à l’aide de contextes, et notre étape d’affichage fonctionne comme prévu.

Si nous avions essayé d’utiliser notre variable d’environnement sans contextes, nous aurions obtenu l’erreur suivante :

En effet, l’action setup-java action n’a pas accès au même environnement. Il est donc nécessaire d’utiliser des contextes pour rendre la variable disponible.

Utiliser les variables par défaut et les secrets GitHub

En plus de définir nos variables d’environnement, GitHub fournit des variables par défaut auxquelles vous pouvez accéder dans un workflow. Elles donnent accès à des informations comme le dépôt GitHub, l’action GitHub et l’exécuteur du workflow. Vous pouvez les utiliser comme les variables d’environnement définies par l’utilisateur. Lorsque vous utilisez GitHub Actions, vous devez y accéder à l’aide de contextes, le cas échéant.

Les secrets GitHub constituent le dernier type de variable d’environnement. Vous pouvez les utiliser pour les variables contenant des données sensibles : GitHub les chiffre et les met à disposition dans votre workflow.

Vous pouvez créer des variables d’environnement chiffrées dans GitHub en accédant à la section Settings du dépôt, puis en sélectionnant Secrets and variables, et ensuite Actions dans le menu de gauche. Cliquez ensuite sur New repository secret, puis saisissez un nom et une valeur pour votre secret. Créez un secret nommé API_KEY et attribuez-lui une valeur aléatoire, comme indiqué ci-dessous.

Pour utiliser le secret dans le workflow, nous employons la même syntaxe que pour transmettre des variables d’environnement à GitHub Actions à l’aide de contextes. Toutefois, au lieu de faire précéder la variable de env., nous utilisons secrets..

1${{secrets.API_KEY}}

Ajoutez ${{secrets.API_KEY}} à l’instruction d’affichage que nous avons déjà créée dans le fichier YAML du workflow. Elle doit correspondre à l’extrait de code ci-dessous :

1- name: Print name
2  run: echo "Hello $NAME. $BUILD. Using Java Version $JAVA_VERSION. My API_KEY is ${{secrets.API_KEY}}"
3  env:
4    BUILD: 'We are currently running the Build job'

Validez les modifications et envoyez-les vers le dépôt. Accédez ensuite à la page Actions sur GitHub pour consulter le résultat de la dernière exécution du workflow.

Comme vous pouvez le constater, GitHub masque automatiquement la valeur de notre secret chiffré afin d’éviter toute divulgation accidentelle.

Les secrets GitHub permettent de stocker des données sensibles, comme des mots de passe ou des clés d’autorisation d’API. Ils évitent d’inscrire ces valeurs en dur dans notre workflow, au risque de les exposer à des tiers. GitHub les chiffre à la place, les transmet de manière sécurisée aux actions de notre workflow et veille à ce qu’elles n’apparaissent pas en clair dans les journaux.

Conclusion

Cet article a présenté les variables d’environnement de GitHub Actions. Nous avons abordé les trois portées possibles (workflow, tâche et étape) et expliqué comment définir des variables à chacun de ces niveaux. Nous avons ensuite vu comment transmettre des variables d’environnement à GitHub Actions à l’aide de contextes et chiffrer des variables sensibles avec des secrets.

Les variables d’environnement de GitHub Actions permettent aux développeurs de créer des workflows dynamiques. Nous pouvons les utiliser pour modifier le comportement du workflow en fonction d’une variable définie par l’utilisateur ou d’une variable GitHub par défaut. Utilisez des variables pour modifier dynamiquement le fonctionnement du workflow, d’une tâche ou d’une étape, ainsi que les conditions de leur exécution.

L’article a également expliqué comment utiliser les secrets GitHub comme variables d’environnement pour protéger les informations sensibles. N’oubliez pas d’utiliser des secrets GitHub pour les variables sensibles, comme les mots de passe et les clés d’API : GitHub les chiffre et les injecte dans un workflow sans risque de divulgation.

Et n’oubliez pas : la sécurité compte ! Découvrez comment Snyk peut renforcer la sécurité de vos workflows GitHub et apprenez-en davantage sur l’intégration de Snyk à votre pipeline CI/CD pour sécuriser votre code, vos conteneurs, vos projets open source et votre IaC.