Jenkins: no se puede definir la variable en la etapa de canalización

Estoy intentando crear un script de canalización declarativo de Jenkins, pero tengo problemas con la declaración de variable simple.

Aquí está mi guión:

pipeline {
   agent none
   stages {
       stage("first") {
           def foo = "foo" // fails with "WorkflowScript: 5: Expected a step @ line 5, column 13."
           sh "echo ${foo}"
       }
   }
}

Sin embargo, obtengo este error:

org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed:
WorkflowScript: 5: Expected a step @ line 5, column 13.
           def foo = "foo"
           ^

Estoy en Jenkins 2.7.4 y Pipeline 2.4.

El modelo declarativo para Jenkins Pipelines tiene un subconjunto restringido de sintaxis que permite en los stagebloques; consulte la guía de sintaxis para obtener más información . Puede eludir esa restricción agrupando sus pasos en un script { ... }bloque, pero como resultado, perderá la validación de la sintaxis, los parámetros, etc.dentro del scriptbloque.

Creo que el error no proviene de la línea especificada sino de las primeras 3 líneas. Prueba esto en su lugar:

node {
   stage("first") {
     def foo = "foo"
     sh "echo ${foo}"
   }
}

Creo que tenías algunas líneas extra que no son válidas ...

EDITAR

De la documentación del modelo de canalización declaractiva , parece que debe usar un environmentbloque de declaración para declarar sus variables, por ejemplo:

pipeline {
   environment {
     FOO = "foo"
   }

   agent none
   stages {
       stage("first") {
           sh "echo ${FOO}"
       }
   }
}

De acuerdo con @ Pom12, @abayer. Para completar la respuesta, debe agregar un bloque de script

Intente algo como esto:

pipeline {
    agent any
    environment {
        ENV_NAME = "${env.BRANCH_NAME}"
    }

    // ----------------

    stages {
        stage('Build Container') {
            steps {
                echo 'Building Container..'

                script {
                    if (ENVIRONMENT_NAME == 'development') {
                        ENV_NAME = 'Development'
                    } else if (ENVIRONMENT_NAME == 'release') {
                        ENV_NAME = 'Production'
                    }
                }
                echo 'Building Branch: ' + env.BRANCH_NAME
                echo 'Build Number: ' + env.BUILD_NUMBER
                echo 'Building Environment: ' + ENV_NAME

                echo "Running your service with environemnt ${ENV_NAME} now"
            }
        }
    }
}

En Jenkins 2.138.3 hay dos tipos diferentes de canalizaciones.

Pipelines declarativos y con script.

"Las canalizaciones declarativas son una nueva extensión del DSL de canalización (básicamente es una secuencia de comandos de canalización con un solo paso, un paso de canalización con argumentos (llamados directivas), estas directivas deben seguir una sintaxis específica. El objetivo de este nuevo formato es que es más estricto y, por lo tanto, debería ser más fácil para los nuevos en las canalizaciones, permitir la edición gráfica y mucho más. Las canalizaciones con secuencias de comandos son la alternativa para los requisitos avanzados ".

canalización de Jenkins: agente vs nodo?

A continuación, se muestra un ejemplo del uso de variables globales y de entorno en una canalización declarativa. Por lo que puedo decir, el entorno es estático después de que se configuran.

def  browser = 'Unknown'

pipeline {
    agent any
    environment {
    //Use Pipeline Utility Steps plugin to read information from pom.xml into env variables
    IMAGE = readMavenPom().getArtifactId()
    VERSION = readMavenPom().getVersion()


    }
    stages {
        stage('Example') {
            steps {
                script {
                    browser = sh(returnStdout: true, script: 'echo Chrome')
                }
            }
        }
        stage('SNAPSHOT') {
                when {
                    expression { 
                        return !env.JOB_NAME.equals("PROD") && !env.VERSION.contains("RELEASE")
                    }
                }
                steps {
                    echo "SNAPSHOT"
                    echo "${browser}"
                }
            }
            stage('RELEASE') {
                when {
                    expression { 
                        return !env.JOB_NAME.equals("TEST") && !env.VERSION.contains("RELEASE")
                    }
                }
                steps {
                    echo "RELEASE"
                    echo "${browser}"
                }
            }
    }//end of stages 
}//end of pipeline

Está utilizando un canal declarativo que requiere un paso de guión para ejecutar el código Groovy. Esta es una gran diferencia en comparación con canal de secuencia de comandos donde esto no es necesario.

La documentación oficial dice lo siguiente:

El paso de guión toma un bloque de canalización con script y lo ejecuta en la canalización declarativa.

pipeline {
   agent none
   stages {
       stage("first") {
           script {
               def foo = "foo" 
               sh "echo ${foo}"
           }
       }
   }
}