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 accepte une seule valeur de chaîne.

Vous pouvez ajouter un shebang au début de la valeur de la chaîne pour spécifier le shell à utiliser pour interpréter le script. Par exemple, ajoutez #!/usr/bin/env bash pour spécifier le shell Bash. Si vous ne préfixez pas la chaîne de script par un shebang, 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 ou entrypoint dans 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 compatibles directement avec les substitutions, mais ils acceptent les variables d'environnement. Vous pouvez mapper des substitutions à des variables d'environnement, soit automatiquement toutes en même temps, soit manuellement en définissant vous-même chaque variable d'environnement.

Map substitutions automatically

  • Au niveau de la compilation Pour mapper automatiquement toutes les substitutions sur des variables d'environnement, qui seront disponibles tout au long du build, définissez automapSubstitutions sur true en tant qu'option au niveau du build. Par exemple, le fichier de configuration de compilation suivant montre la substitution $_USER définie par l'utilisateur 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 de l'étape. Pour mapper automatiquement toutes les substitutions et les mettre à disposition en tant que variables d'environnement en une seule étape, définissez le champ automapSubstitutions sur true à cette étape. Dans l'exemple suivant, seule la deuxième étape affichera correctement les substitutions, car elle est la seule à avoir activé le mappage automatique des substitutions:

    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"
  }

    Vous pouvez également rendre les substitutions disponibles en tant que variables d'environnement dans l'ensemble de la compilation, 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 de 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"
  }

Map substitutions manually

Vous pouvez mapper manuellement les substitutions sur 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

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 est utilisé pour exécuter des commandes gcloud qui interrogent Cloud Build sur l'état de la compilation, en listant les compilations avec un état d'échec.

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.

Étape suivante