Esecuzione di script bash

Questa pagina spiega come configurare Cloud Build per eseguire script bash all'interno di un passaggio di compilazione. Se non hai mai utilizzato Cloud Build, leggi prima gli avvii rapidi e la panoramica della configurazione di compilazione.

Puoi eseguire script bash all'interno di un passaggio di compilazione per configurare una serie di flussi di lavoro, tra cui:

  • Esecuzione di più comandi in un unico passaggio di build.
  • Lettura dal file system.
  • Implementazione di logica come i tentativi di nuovo o i casi con condizioni.
  • Output nel log, ad esempio esecuzione di echo $VARNAME.

Utilizzo del campo script

Cloud Build fornisce un campo script che puoi utilizzare per specificare gli script shell da eseguire in un passaggio di compilazione. Il campo script accetta una singola stringa valore.

Puoi anteporre al valore della stringa un shebang per specificare la shell che deve interpretare lo script. Ad esempio, aggiungi #!/usr/bin/env bash per specificare la shell Bash. Se non anteponi alla stringa dello script un shebang, Cloud Build utilizza #!/bin/sh, ovvero lo shell sh di base, non lo shell Bash.

Se specifichi script in un passaggio di compilazione, non puoi specificare args o entrypoint nello stesso passaggio.

Il seguente snippet illustra il campo 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"
  }
  ]
}

Utilizzare sostituzioni con il campo script

Gli script non supportano direttamente le sostituzioni, ma supportano le variabili di ambiente. Puoi mappare le sostituzioni alle variabili di ambiente, automaticamente tutte insieme o manualmente definendo ogni variabile di ambiente per te.

Sostituzioni mappa automaticamente

  • A livello di build. Per mappare automaticamente tutte le sostituzioni alle variabili di ambiente, che saranno disponibili per l'intera build, imposta automapSubstitutions su true come opzione a livello di build. Ad esempio, il seguente file di configurazione di compilazione mostra la sostituzione definita dall'utente $_USER e la sostituzione predefinita $PROJECT_ID mappate alle variabili di ambiente:

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

  • A livello di passaggio. Per mappare automaticamente tutte le sostituzioni e renderle disponibili come variabili di ambiente in un unico passaggio, imposta il campo automapSubstitutions su true in quel passaggio. Nell'esempio seguente, solo il secondo passaggio mostrerà le sostituzioni correttamente, perché è l'unico con la mappatura delle sostituzioni automatiche abilitata:

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

    Inoltre, puoi rendere disponibili le sostituzioni come variabili di ambiente nell'intera compilazione, per poi ignorarle in un solo passaggio. Imposta automapSubstitutions su true a livello di compilazione, quindi imposta lo stesso campo su false nel passaggio in cui vuoi ignorare le sostituzioni. Nella nell'esempio seguente, anche se le sostituzioni di mappatura sono abilitate a livello di build, l'ID progetto non verrà stampato nel secondo passaggio perché automapSubstitutions è impostato su false in questo passaggio:

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

Mappare le sostituzioni manualmente

Puoi mappare manualmente le sostituzioni alle variabili di ambiente. Ogni variabile di ambiente viene definita a livello di passaggio utilizzando il campo env e l'ambito delle variabili è limitato al passaggio in cui sono definite. Questo campo accetta un elenco di chiavi e valori.

L'esempio seguente mostra come mappare la sostituzione $PROJECT_ID alla variabile di ambiente BAR:

YAML 

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

JSON 

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

Esecuzione di script bash sul disco

Se hai salvato lo script bash in un file, archivialo insieme all'origine della build e fai riferimento al file dello script nel file di configurazione della build:

YAML 

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

JSON 

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

Utilizzo di uno script bash su file se bash non è il punto di ingresso predefinito dell'immagine che stai utilizzando, aggiungi un campo entrypoint che rimandi a 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"
    ]
  }
  ]
}

Esecuzione di script bash in linea

Per eseguire comandi bash utilizzando l'immagine bash, specifica bash come name del passaggio di build e il comando nel campo degli argomenti:

YAML 

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

JSON 

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

Se l'immagine che stai utilizzando è preconfezionata con bash, ma se bash non è punto di ingresso predefinito, aggiungi un campo entrypoint che rimandi a bash. Nell'esempio: di seguito, il punto di ingresso bash viene utilizzato per eseguire comandi gcloud che eseguono Cloud Build per lo stato della build, che elenca le build con lo stato "Non riuscita".

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

Il flag -c nel codice riportato sopra viene utilizzato per eseguire comandi multiriga. Qualsiasi stringa che superi dopo che -c è stato considerato un comando. Per ulteriori informazioni sull'esecuzione di bash con -c, consulta le documentazione bash.

Passaggi successivi