Jenkinsfile et Python virtualenv

J'essaye de configurer un projet qui utilise le nouveau brillant Jenkins pipelines, plus précisément un multibranch projet.

J'ai un Jenkinsfile créé dans un test de la branche comme ci-dessous:

node {
    stage 'Preparing VirtualEnv'
    if (!fileExists('.env')){
        echo 'Creating virtualenv ...'
        sh 'virtualenv --no-site-packages .env'
    }
    sh '. .env/bin/activate'
    sh 'ls -all'
    if (fileExists('requirements/preinstall.txt')){
        sh 'pip install -r requirements/preinstall.txt'
    }
    sh 'pip install -r requirements/test.txt'
    stage 'Unittests'
    sh './manage.py test --noinput'
}

Il est intéressant de noter que preinstall.txt sera mise à jour pip

Je suis d'erreur comme ci-dessous:

OSError: [Errno 13] Permission denied: '/usr/local/lib/python2.7/dist-packages/pip'

Dirait qu'il essaie de mettre à jour pip mondiale env au lieu de l'intérieur de virtualenv, et ressemble à chaque sh étape est sur son propre contexte, comment puis-je les faire exécuter, dans le même contexte?

activate s'applique uniquement à la coquille instace il est exécuté en, dans votre cas, seule ligne. Essayez d'exécuter le pip dans le venv avec chemin d'accès complet et manage.py avec (chemin complet) python.

InformationsquelleAutor James Lin | 2016-11-28

jenkins python

15

Ce que vous essayez de le faire ne fonctionnera pas. Chaque fois que vous appelez la sh commande, jenkins va créer un nouveau shell.

Cela signifie que si vous utilisez .env/bin/activate dans un sh il sera seulement des sources dans cette session shell. Le résultat est que, dans un nouvel sh commande que vous avez à la source du fichier à nouveau (si vous regardez de plus près à la sortie de la console, vous verrez que Jenkins va réellement créer shell temporaire des fichiers à chaque fois yu exécuter le comman.

De sorte que vous devrait à la source de la .env/bin/activate de fichier au début de chaque commande shell (vous pouvez utiliser le triple qoutes pour multiligne chaînes de caractères), comme
```
if (fileExists('requirements/preinstall.txt')) {
    sh """
    . .env/bin/activate
    pip install -r requirements/preinstall.txt
    """
}
...
sh """
. .env/bin/activate
pip install -r requirements/test.txt
"""
}
stage("Unittests") {
    sh """
    . .env/bin/activate
    ./manage.py test --noinput
    """
}
```
ou d'exécuter tout cela dans un shell
```
sh """
. .env/bin/activate
if [[ -f requirements/preinstall.txt ]]; then
    pip install -r requirements/preinstall.txt
fi
pip install -r requirements/test.txt
./manage.py test --noinput
"""
```
- Malheureusement, cette solution assure la maintenance de pipelines d'un cauchemar, nous avons clairement besoin de prolonger le Pipeline DSL pour permettre à ce cas d'utilisation et éviter de se retrouver avec cette. Cette solution fonctionne pour de simples oléoducs, mais une fois que vous pousser à complexes à l'aide de l'activer devient un cauchemar. Réfléchir sur les exceptions et même les blocs qui ne s'exécuter que si virtualenv création a échoué.
- Malheureusement je suis d'accord @sorin. Il cesse de s'améliorer, mais souvent des trucs pauses ou une solution de contournement est nécessaire. Sur l'autre main wee pourrait donner à tout le monde contribue un peu de mou pour les dépenses de leur temps. Concernant cette question, tou pouvez toujours mettre un script dans votre pension avec la logique, et il suffit d'appeler que
- Je suis entièrement d'accord, c'est une des principales source de maux de tête. Avez-vous trouver la meilleure des solutions de rechange?
InformationsquelleAutor Rik
5

Comme Rik posté, virtualenvs ne fonctionnent pas bien dans le Jenkins Pipeline de l'Environnement, puisqu'un nouveau shell est créé pour chaque commande.

J'ai créé un plugin qui rend ce processus est un peu moins douloureux, qui peut être trouvé ici: https://wiki.jenkins.io/display/JENKINS/Pyenv+Pipeline+Plugin. Il est essentiellement juste encapsule chaque appel de façon active le virtualenv avant l'exécution de la commande. En soi, c'est difficile, comme certaines méthodes de l'exécution de plusieurs commandes inline sont divisés en deux commandes séparées par Jenkins, provoquant l'activation virtualenv de ne plus appliquer.

InformationsquelleAutor cstarner
-1

Je suis nouveau sur Jenkins fichiers. Voici comment j'ai travaillé autour de l'environnement virtuel problème. (Je suis en cours d'exécution Python3, Jenkins 2.73.1)

Mise en garde: Juste pour être clair, je ne dis pas que c'est une bonne façon de résoudre le problème, et je n'ai pas testé ce suffisant pour se tenir derrière cette approche, mais ici ce qui est de travailler pour moi aujourd'hui:

J'ai été jouer avec en contournant le venv "activer" en appelant l'environnement virtuel de l'interpréteur python directement. Ainsi, au lieu de:
```
source ~/venv/bin/activate    
```
on peut utiliser:
```
~/venv/bin/python3 my_script.py
```
Je passe mon chemin vers l'environnement virtuel de l'interpréteur python via le shell du fichier rc (Dans mon cas, ~/.bashrc.) En théorie, chaque shell Jenkins appels devraient lire ce fichier de ressources. Dans la pratique, je dois redémarrer Jenkins, après avoir fait des changements à la coquille fichier de ressources.
```
HOME_DIR=~
export VENV_PATH="$HOME_DIR/venvs/my_venv"
export PYTHON_INTERPRETER="${VENV_PATH}/bin/python3"
```
Mon Jenkinsfile ressemble à ceci:
```
pipeline {
    agent {
        label 'my_slave'
    }

    stages {
        stage('Stage1') {
            steps {
                // sh 'echo $PYTHON_INTERPRETER'
                // sh 'env | sort'
                sh "$PYTHON_INTERPRETER my_script.py "
            }
        }
    }
}
```
Ainsi, lorsque la canalisation est exécuté, le sh a l' $PYTHON_INTERPRETER les valeurs de l'environnement défini.

Remarque un défaut de cette approche est que maintenant le Jenkins fichier ne contient pas toutes les informations nécessaires pour exécuter le script correctement. J'espère que cela va vous descendez le sol.

InformationsquelleAutor JS.

Vous devez vous connecter pour publier un commentaire.