Exécuter des scripts bash

Cette page explique comment configurer Cloud Build pour exécuter des scripts bash dans une étape de compilation. 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.

Vous pouvez exécuter des scripts bash dans une étape de compilation pour configurer un certain nombre de workflows, y compris :

  • Exécuter plusieurs commandes en une seule étape de compilation
  • Lire à partir du système de fichiers
  • Intégrer une logique, telle que de nouvelles tentatives ou des conditions
  • Générer vers le journal, par exemple, en exécutant echo $VARNAME.

Définir le champ script

Cloud Build fournit un champ script que vous pouvez utiliser pour spécifier les scripts shell à exécuter dans une étape de compilation. Le champ script n'accepte qu'une seule valeur de chaîne.

Vous pouvez ajouter le préfixe shebang à la valeur de chaîne pour spécifier l'interface système qui doit interpréter le script. Par exemple, ajoutez #!/usr/bin/env bash pour spécifier le shell bash. Si vous n'ajoutez pas le préfixe "Shebang" à la chaîne de script, Cloud Build utilise #!/bin/sh, qui est le shell sh de base, et non le shell bash.

Si vous spécifiez script dans une étape de compilation, vous ne pouvez pas spécifier args ni entrypoint lors de la même étape.

L'extrait de code suivant illustre le champ script:

YAML 

steps:
- name: 'bash'
  script: |
    #!/usr/bin/env bash
    echo "Hello World"
- name: 'ubuntu'
  script: echo hello
- name: 'python'
  script: |
    #!/usr/bin/env python
    print('hello from python')

JSON 

{
  "steps": [
  {
    "name": "bash",
    "script": "#!/usr/bin/env bash echo 'Hello World'"
  },
  {
    "name": "ubuntu",
    "script": "echo hello"
  },
  {
    "name": "python",
    "script": "#!/usr/bin/env python\nprint('hello from python')\n"
  }
  ]
}

Utiliser des substitutions avec le champ script

Les scripts ne sont pas directement compatibles avec les substitutions, mais acceptent les variables d'environnement. Vous pouvez mapper des substitutions à des variables d'environnement soit automatiquement en une seule fois, soit manuellement en définissant vous-même chaque variable d'environnement.

Mapper automatiquement les substitutions

  • Au niveau de la compilation : Pour mapper automatiquement toutes les substitutions avec des variables d'environnement, qui seront disponibles tout au long de la compilation, définissez automapSubstitutions sur true en tant qu'option au niveau de la compilation. Par exemple, le fichier de configuration de compilation suivant montre la substitution définie par l'utilisateur $_USER et la substitution par défaut $PROJECT_ID mappée sur des variables d'environnement:

    YAML 

    steps:
- name: 'ubuntu'
  script: |
    #!/usr/bin/env bash
    echo "Hello $_USER"
- name: 'ubuntu'
  script: |
    #!/usr/bin/env bash
    echo "Your project ID is $PROJECT_ID"
options:
  automapSubstitutions: true
substitutions:
  _USER: "Google Cloud"

    JSON 

    {
  "steps": [
    {
      "name": "ubuntu",
      "script": "#!/usr/bin/env bash echo 'Hello $_USER'"
    },
    {
      "name": "ubuntu",
      "script": "#!/usr/bin/env bash echo 'Your project ID is $PROJECT_ID'"
    }
  ],
  "options": {
    "automap_substitutions": true
  },
  "substitutions": {
    "_USER": "Google Cloud"
  }
}

  • Au niveau des pas : Pour mapper automatiquement toutes les substitutions et les rendre disponibles en tant que variables d'environnement en une seule étape, définissez le champ automapSubstitutions sur true lors de cette étape. Dans l'exemple suivant, seule la deuxième étape affichera correctement les substitutions, car il s'agit de la seule pour laquelle le mappage de substitutions automatique est activé:

    YAML 

    steps:
- name: 'ubuntu'
  script: |
    #!/usr/bin/env bash
    echo "Hello $_USER"
- name: 'ubuntu'
  script: |
    #!/usr/bin/env bash
    echo "Your project ID is $PROJECT_ID"
  automapSubstitutions: true
substitutions:
  _USER: "Google Cloud"

    JSON 

    {
  "steps": [
    {
      "name": "ubuntu",
      "script": "#!/usr/bin/env bash echo 'Hello $_USER'"
    },
    {
      "name": "ubuntu",
      "script": "#!/usr/bin/env bash echo 'Your project ID is $PROJECT_ID'",
      "automap_substitutions": true
    }
  ],
  },
  "substitutions": {
    "_USER": "Google Cloud"
  }

    De plus, vous pouvez rendre les substitutions disponibles en tant que variables d'environnement dans l'ensemble du build, puis les ignorer en une seule étape. Définissez automapSubstitutions sur true au niveau de la compilation, puis définissez le même champ sur false à l'étape où vous souhaitez ignorer les substitutions. Dans l'exemple suivant, même si les substitutions de mappage sont activées au niveau de la compilation, l'ID du projet ne sera pas imprimé à la deuxième étape, car automapSubstitutions est défini sur false à cette étape:

    YAML 

    steps:
- name: 'ubuntu'
  script: |
    #!/usr/bin/env bash
    echo "Hello $_USER"
- name: 'ubuntu'
  script: |
    #!/usr/bin/env bash
    echo "Your project ID is $PROJECT_ID"
  automapSubstitutions: false
options:
  automapSubstitutions: true
substitutions:
  _USER: "Google Cloud"

    JSON 

    {
  "steps": [
    {
      "name": "ubuntu",
      "script": "#!/usr/bin/env bash echo 'Hello $_USER'"
    },
    {
      "name": "ubuntu",
      "script": "#!/usr/bin/env bash echo 'Your project ID is $PROJECT_ID'",
      "automap_substitutions": false
    }
  ],
  "options": {
    "automap_substitutions": true
  },
  },
  "substitutions": {
    "_USER": "Google Cloud"
  }

Mapper manuellement les substitutions

Vous pouvez mapper manuellement les substitutions avec des variables d'environnement. Chaque variable d'environnement est définie au niveau de l'étape à l'aide du champ env, et le champ d'application des variables est limité à l'étape où elles sont définies. Ce champ accepte une liste de clés et de valeurs.

L'exemple suivant montre comment mapper la substitution $PROJECT_ID à la variable d'environnement BAR:

YAML 

steps:
- name: 'ubuntu'
  env:
  - 'BAR=$PROJECT_ID'
  script: 'echo $BAR'

JSON 

{
  "steps": [
    {
      "name": "ubuntu",
      "env": [
        "BAR=$PROJECT_ID"
      ],
      "script": "echo $BAR"
    }
  ]
}

Exécuter des scripts bash sur le disque

Si votre script bash est enregistré dans un fichier, stockez-le avec votre source de compilation et référencez ce fichier dans votre fichier de configuration de compilation :

YAML 

steps:
- name: 'bash'
  args: ['./myscript.bash']

JSON 

{
  "steps": [
  {
    "name": "bash",
    "args": [
      "./myscript.bash"
     ]
  }
  ]
}

Pour utiliser un script bash sur un fichier alors que bash n'est pas le point d'entrée par défaut de l'image que vous utilisez, ajoutez un champ entrypoint pointant vers bash :

YAML 

steps:
- name: 'gcr.io/cloud-builders/gcloud'
  entrypoint: 'bash'
  args: ['tools/myScript.sh','--foo']

JSON 

{
  "steps": [
  {
    "name": "gcr.io/cloud-builders/gcloud",
    "entrypoint": "bash",
    "args": [
      "tools/myScript.sh",
      "--foo"
    ]
  }
  ]
}

Exécuter des scripts bash intégrés (anciens)

Pour exécuter des commandes bash à l'aide de l'image bash, spécifiez bash comme name de l'étape de compilation et la commande dans le champ args :

YAML 

steps:
- name: 'bash'
  args: ['echo', 'I am running a bash command']

JSON 

{
  "steps": [
    {
      "name": "bash",
      "args": [
        "echo",
        "I am running a bash command"
       ]
    }
  ]
}

Si l'image que vous utilisez est préinstallée avec bash, mais si bash n'est pas le point d'entrée par défaut, ajoutez un champ entrypoint pointant vers bash. Dans l'exemple ci-dessous, le point d'entrée bash permet d'exécuter des commandes gcloud qui interrogent Cloud Build pour connaître l'état de la compilation, en listant les compilations avec un état ayant échoué.

YAML 

steps:
- name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
  entrypoint: 'bash'
  args:
  - '-eEuo'
  - 'pipefail'
  - '-c'
  - |-
    gcloud builds list > builds.txt
    while read line; do
        if grep -q "FAILURE" <<< "$line"; then
            echo "$line"
        fi
    done < builds.txt

JSON 

{
  "steps": [
  {
    "name": "gcr.io/google.com/cloudsdktool/cloud-sdk",
    "entrypoint": "bash",
    "args": [
      "-eEuo",
      "pipefail",
      "-c",
      "gcloud builds list > builds.txt\nwhile read line; do\n    if grep -q \"FAILURE\" <<< \"$line\"; then\n        echo \"$line\"\n    fi\ndone < builds.txt"
    ]
  }
  ]
}

L'option -c figurant dans le code ci-dessus permet d'exécuter des commandes multilignes. Toutes les chaînes que vous transmettez après -c sont traitées comme des commandes. Pour en savoir plus sur l'exécution des commandes bash avec -c, consultez la documentation bash.

Étapes suivantes