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:

  • Eseguire più comandi in un unico passaggio di compilazione.
  • Lettura dal file system.
  • Implementazione di logica come i tentativi di nuovo o i casi.
  • 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 un singolo valore di stringa.

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 mostra 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 le 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, in modo automatico tutte contemporaneamente o manualmente definendo ogni variabile di ambiente da solo.

Mappare le sostituzioni 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 unico passaggio. Imposta automapSubstitutions su true a livello di compilazione, quindi imposta lo stesso campo su false nel passaggio in cui vuoi ignorare le sostituzioni. Nel seguente esempio, anche se le sostituzioni di mappatura sono abilitate a livello di compilazione, l'ID progetto non verrà stampato nel secondo passaggio perché automapSubstitutions è impostato su false in quel 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"
     ]
  }
  ]
}

Per utilizzare uno script bash in un file se bash non è il punto di contatto 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 compilazione e il comando nel campo 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"
       ]
    }
  ]
}

Se l'immagine che utilizzi è precompilata con bash, ma bash non è il punto di contatto predefinito, aggiungi un campo entrypoint che rimandi a bash. Nell'esempio riportato di seguito, il punto di contatto bash viene utilizzato per eseguire comandi gcloud che eseguono query su Cloud Build per lo stato delle build, elencando le build con stato non riuscito.

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 passi dopo -c viene considerata un comando. Per ulteriori informazioni sull'esecuzione di comandi bash con -c, consulta la documentazione di bash.

Passaggi successivi