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.

Utiliser 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 préfixer la valeur de chaîne avec un shebang pour spécifier le shell qui interprétera 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 avec 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 ni 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 directement compatibles avec les substitutions, mais ils sont compatibles avec 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 des substitutions automatiquement

  • Au niveau de la compilation. Pour mapper automatiquement toutes les substitutions à 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ées à 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 rendre disponibles en tant que variables d'environnement en une seule étape, définissez le champ automapSubstitutions sur true dans cette étape. Dans l'exemple suivant, seule la seconde étape affichera correctement les substitutions, car il s'agit de la seule pour laquelle le mappage automatique des substitutions 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 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 dans l'étape où vous souhaitez ignorer les substitutions. Dans l'exemple suivant, même si le mappage des substitutions est activé au niveau de la compilation, l'ID du projet ne sera pas imprimé lors de la seconde étape, car automapSubstitutions est défini sur false dans 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 des substitutions manuellement

Vous pouvez mapper manuellement les substitutions à des variables d'environnement. Chaque variable d'environnement est définie au niveau de l'étape à l'aide de le env champ, 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 dont l'état est "É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