Environnement toxique facile avec Jenkins
en premier
Le testez-vous les gars? "Tox" qui exécute des tests unitaires en Python dans plusieurs environnements. C'est pratique, n'est-ce pas? Si vous créez un environnement CI avec Jenkins, vous pouvez vérifier l'opération avec plusieurs versions en une seule fois.
Cependant, l'installation de pyenv et la préparation de plusieurs environnements python demandent beaucoup de temps et d'efforts. C'est donc un moyen simple de créer un environnement qui utilise tox avec Jenkins.
La procédure est la suivante.
- Construisez Jenkins avec Docker
- Créez un DockerFile pour le conteneur avec Pyenv installé
- Créez un fichier Jenkins qui utilise DockerFile
- Créez tox.ini pour obtenir un test unitaire et un rapport de couverture
- Placez DockerFile, Jenkinsfile, tox.ini en haut du référentiel
- Créez un travail de pipeline dans Jenkins
- Exécution de la construction
Préparation préalable
Cette fois, j'expliquerai principalement la partie qui génère dynamiquement l'environnement CI à l'aide de Jenkisfile. Par conséquent, nous omettons la construction de l'environnement Docker et de Jenkins. __ Cependant, assurez-vous de créer Jenkins sous l'environnement Docker. __
Construire Jenkins avec Docker
Si vous êtes dans un environnement Windows, vous devez le créer en vous référant à la page suivante. https://qiita.com/sh1928kd/items/b248a8d48d16eaab9617
Un point, lors du partage d'un socket Docker dans un environnement Ubuntu, etc., veuillez faire attention à l'autorité de socket du socket côté hôte. Une erreur se produira si vous n'avez pas l'autorisation d'exécution du côté Jenkins.
La version de Jenkins au moment de la rédaction de l'article est "Jenkins 2.255".
Brancher
Mettez ce que vous voulez. Cette fois, je veux afficher le résultat d'Unittest et le rapport de couverture, donc installez "JUnit" et "Cobertura".
- https://plugins.jenkins.io/junit/
- https://plugins.jenkins.io/cobertura/
Créer un DockerFile pour le conteneur avec Pyenv installé
Vous devriez pouvoir créer l'environnement avec uniquement le fichier Jenkins, Lorsque j'ai essayé d'utiliser pyenv lors de la création de plusieurs environnements Python, cela n'a pas fonctionné. Par conséquent, nous utiliserons DockerFile pour créer plusieurs environnements Python.
FROM python:3.8
USER root
ENV HOME /root
ENV PYENV_ROOT $HOME/.pyenv
ENV PATH $PYENV_ROOT/bin:$PATH
# ENV HTTP_PROXY '{Adresse du serveur proxy}'
# ENV HTTPS_PROXY '{Adresse du serveur proxy'
# ENV FTP_PROXY '{Adresse du serveur proxy}'
# RUN echo 'Acquire::http::Proxy "{Adresse du serveur proxy}";' >> /etc/apt/apt.conf
# RUN echo 'Acquire::https::Proxy "{Adresse du serveur proxy}";' >> /etc/apt/apt.conf
RUN apt-get update && apt-get upgrade -y \
&& apt-get install -y \
git \
make \
build-essential \
libssl-dev \
zlib1g-dev \
libbz2-dev \
libreadline-dev \
libsqlite3-dev \
wget \
curl \
llvm \
libncurses5-dev \
libncursesw5-dev \
xz-utils \
tk-dev \
libffi-dev \
liblzma-dev \
&& git clone https://github.com/pyenv/pyenv.git $PYENV_ROOT
RUN echo 'eval "$(pyenv init -)"' >> ~/.bashrc && \
eval "$(pyenv init -)"
RUN pyenv install 3.5.9
RUN pyenv install 3.6.2
RUN pyenv install 3.7.2
RUN pyenv install 3.8.2
RUN echo '3.5.9' >> .python-version
RUN echo '3.6.2' >> .python-version
RUN echo '3.7.2' >> .python-version
RUN echo '3.8.2' >> .python-version
Créer un fichier Jenkins qui utilise un Dockerfile
Jenkinsfile n'est pas difficile une fois que vous avez créé l'environnement avec Dockerfile
pipeline {
agent {
dockerfile {
filename 'Dockerfile'
args '-u root:sudo'
}
}
stages {
stage('setup') {
steps {
sh 'pip install flake8'
sh 'pip install tox'
sh 'pip install tox-pyenv'
}
}
stage('test') {
steps {
sh 'tox'
//Obtenez une couverture
cobertura coberturaReportFile: 'coverage.xml'
//Obtenez les résultats des tests
junit 'junit_reports/*.xml'
}
}
}
}
Il aurait peut-être été bon de décrire le contenu de l'installation dans DockerFile.
Créez tox.ini pour obtenir des tests unitaires et des rapports de couverture
Écrivez tox.ini. Cette fois, nous obtiendrons un rapport de test et un rapport de couverture, nous l'avons donc configuré pour générer chaque rapport
tox.ini
[tox]
envlist = py35, py36, py37, py38, flake8
[travis]
python =
3.8: py38
3.7: py37
3.6: py36
3.5: py35
[testenv:flake8]
basepython = python
deps = flake8
commands = flake8 {Nom du module à analyser} tests
[flake8]
exclude = tests/*
[testenv]
setenv =
PYTHONPATH = {toxinidir}
deps =
coverage
unittest-xml-reporting
commands =
rm -rf junit_reports
python -m xmlrunner discover -o junit_reports
coverage erase
coverage run --append setup.py test
coverage report --omit='.tox/*'
coverage xml --omit='.tox/*'
Placez DockerFile, Jenkinsfile, tox.ini en haut du référentiel
Fondamentalement, s'il s'agit d'un projet au format PYPI, il aura la structure suivante.
-project
|-module_dir/
|-main.py
|-tests/
|-test_main.py
|-setup.py
|-Dockerfile
|-Jenkinsfile
|-tox.ini
Créer un travail de pipeline dans Jenkins
Poussez le script terminé sur Github, etc.
Choisissez de créer un nouvel emploi,
- Entrez le nom du travail dans le nom de l'élément
- Sélectionnez un pipeline
Sur l'écran des paramètres
- Sélectionnez "Pipeline script from SCM" comme définition
- Sélectionnez "Git" pour SCM
- Entrez le chemin du référentiel dans l'URL du référentiel
Exécution de la construction
À partir de l'écran de travail Jenkins, cliquez sur "Exécuter la génération" pour créer l'environnement à partir du fichier Docker Jenkins obtiendra le résultat de l'exécution de tox.
Résumé
J'ai introduit l'environnement pour exécuter facilement tox avec Jenkins. Je voulais vraiment le construire avec seulement Jenkinsfile, mais je ne comprenais pas le comportement autour de PATH, donc J'ai utilisé un Dockerfile.
S'il s'agit d'une structure de projet au format PyPI, elle peut être presque réutilisée par cette méthode, il est donc facile de créer un environnement de test. De plus, étant donné que l'environnement est créé, vous devez être conscient des omissions d'enregistrement de module et des bibliothèques dépendantes.
Recommended Posts