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.

  1. Construisez Jenkins avec Docker
  2. Créez un DockerFile pour le conteneur avec Pyenv installé
  3. Créez un fichier Jenkins qui utilise DockerFile
  4. Créez tox.ini pour obtenir un test unitaire et un rapport de couverture
  5. Placez DockerFile, Jenkinsfile, tox.ini en haut du référentiel
  6. Créez un travail de pipeline dans Jenkins
  7. 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".

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.

jenkins.png

Choisissez de créer un nouvel emploi,

  1. Entrez le nom du travail dans le nom de l'élément
  2. Sélectionnez un pipeline

jenkins2.png

Sur l'écran des paramètres

  1. Sélectionnez "Pipeline script from SCM" comme définition
  2. Sélectionnez "Git" pour SCM
  3. Entrez le chemin du référentiel dans l'URL du référentiel

Exécution de la construction

image.png

À 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

Environnement toxique facile avec Jenkins
Construction d'un environnement Jupyter facile avec Cloud9
Environnement de déploiement facile avec gaffer + tissu
[Linux] Créer un environnement Jenkins avec Docker
Easy Grad-CAM avec pytorch-gradcam
environnement python avec docker-compose
Débogage facile avec ipdb
Environnement virtuel avec Python 3.6
TopView facile avec OpenCV
De Kafka à KSQL - Construction d'environnement facile avec docker
Créer un environnement avec virtualenv
[Analyse de co-occurrence] Analyse de co-occurrence facile avec Python! [Python]
Environnement de site Web de configuration minimale avec django
Installer l'environnement Python avec Anaconda
Gérez l'environnement python avec virtualenv
Environnement Venv avec Windows PowerShell
Synchronisation facile des dossiers avec Python
Créer un environnement python3 avec ubuntu 16.04
Rendre avec la syntaxe facile
Préparer l'environnement python3 avec Docker
Grattage Web facile avec Scrapy
Construire un environnement python avec direnv
Compilation facile de Python avec NUITKA-Utilities
Serveur HTTP facile avec Python
Connexion proxy facile avec django-hijack
Changer d'environnement virtuel avec jupyter
Définir des variables d'environnement avec lambda-uploader
Créer un environnement Kubernetes avec Ansible 2
Préparer l'environnement pipenv avec Amazon Linux 2
Activez l'environnement virtuel d'Anaconda avec PowerShell
Prédiction de séries chronologiques facile avec Prophet
Commencez avec Python! ~ ① Construction de l'environnement ~
[Python] Traitement parallèle facile avec Joblib
Soyez prudent avec les références de méthodes faciles
Easy Slackbot avec Docker et Errbot
Configurer un environnement Python moderne avec Homebrew
Construction de l'environnement Ruby avec AWS EC2
Construire un environnement Mysql + Python avec docker
Créez un environnement virtuel avec Python!
Créer un environnement virtuel avec Python 3
Application GUI facile avec Tkinter Text
Installez facilement pyspark avec conda
Créer un environnement Flask avec Dockerfile + docker-compose.yml
Programmation facile Python + OpenCV avec Canopy
Transmission de courrier facile avec Hâte Python3
Optimisation bayésienne très simple avec Python
Créer un environnement de notebook IPython avec boot2docker
Tests faciles d'AWS S3 avec MinIO
Automatisez la construction d'environnement avec ShellScript
Réglage facile de la police japonaise avec matplotlib
Construction de l'environnement Python3 avec pyenv-virtualenv (CentOS 7.3)
Visualisez facilement vos données avec Python seaborn.
Utilisation de Chainer avec CentOS7 [Construction de l'environnement]
Facile avec Slack en utilisant Bot #NowPlaying
Dessinez facilement des graphiques avec matplotlib