Hogyan gyűjtsön projekteket a Jenkinsben, ha sok különböző környezetre van szüksége

Habréról sok cikk szól Jenkinsről, de kevés példát ír le Jenkins és a dokkolóügynökök működésére. Minden népszerű projektépítő eszköz, mint pl Drone.io, Bitbucket Pipeline, GitLab, GitHub-műveletek és mások mindent konténerekbe gyűjthetnek. De mi a helyzet Jenkinsszel?

Ma már van megoldás a problémára: a Jenkins 2 remekül használható Docker ügynökök. Ebben a cikkben szeretném megosztani tapasztalataimat, és megmutatni, hogyan teheti meg saját maga.

Miért kezdtem el megoldani ezt a problémát?

Mivel társaságban vagyunk Citronium Mivel sokféle technológiát használunk, a Node.JS, Gradle, Ruby, JDK és mások különböző verzióit kell az összeszerelő gépen tartani. De gyakran nem lehet elkerülni a verziókonfliktusokat. Igen, igazad lesz, ha azt mondod, hogy vannak különféle verziókezelők, mint például az nvm, az rvm, de nem minden olyan zökkenőmentes velük, és ezekkel a megoldásokkal vannak problémák:

• nagy mennyiségű futási idő, amelyet a fejlesztők elfelejtenek megtisztítani;
• konfliktusok vannak ugyanazon futási környezet különböző verziói között;
• Minden fejlesztőnek más összetevőkészletre van szüksége.

Vannak más problémák is, de hadd mondjam el a megoldást.

Jenkins a Dockerben

Mivel a Docker mára jól bevált a fejlesztői világban, szinte bármi futtatható a Docker segítségével. Az én megoldásom az, hogy a Jenkins a Dockerben van, és más Docker konténereket is futtathatok. Ezt a kérdést még 2013-ban kezdték feltenni a „A Docker mostantól futhat a Dockeren belül”.

Röviden, csak telepítenie kell magát a Dockert egy működő tárolóba, és csatlakoztatnia kell a fájlt /var/run/docker.sock.

Íme egy példa a Dockerfile-re, amely Jenkins számára készült.

FROM jenkins/jenkins:lts

USER root

RUN apt-get update && 

apt-get -y install apt-transport-https 
     ca-certificates 
     curl 
     gnupg2 
     git 
     software-properties-common && 
curl -fsSL https://download.docker.com/linux/$(. /etc/os-release; echo "$ID")/gpg > /tmp/dkey; apt-key add /tmp/dkey && 
add-apt-repository 
   "deb [arch=amd64] https://download.docker.com/linux/$(. /etc/os-release; echo "$ID") 
   $(lsb_release -cs) 
   stable" && 
apt-get update && 
apt-get -y install docker-ce && 
usermod -aG docker jenkins

RUN curl -L https://github.com/docker/compose/releases/download/1.25.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose && chmod +x /usr/local/bin/docker-compose 

RUN apt-get clean autoclean && apt-get autoremove —yes && rm -rf /var/lib/{apt,dpkg,cache,log}/

USER jenkins

Így kaptunk egy Docker-tárolót, amely képes Docker-parancsokat végrehajtani a gazdagépen.

Építési beállítás

Nem sokkal ezelőtt Jenkins lehetőséget kapott arra, hogy leírja a szabályait Csővezeték szintaxis, ami meglehetősen egyszerűvé teszi a build szkript megváltoztatását és tárolását a tárolóban.

Tehát tegyünk egy speciális Dockerfile-t magába a repository-ba, amely az összeépítéshez szükséges összes könyvtárat tartalmazza. Így a fejlesztő maga készíthet elő ismételhető környezetet, és nem kell kérnie az OPS-t, hogy telepítse a Node.JS egy adott verzióját a gazdagépen.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Ez az összeállítási lemezkép a legtöbb Node.JS alkalmazáshoz alkalmas. Mi van, ha például egy Sonar szkennerrel ellátott JVM-projekthez van szüksége egy képre? Szabadon választhatja ki az összeszereléshez szükséges alkatrészeket.

FROM adoptopenjdk/openjdk12:latest

RUN apt update 
    && apt install -y 
        bash unzip wget

RUN mkdir -p /usr/local/sonarscanner 
    && cd /usr/local/sonarscanner 
    && wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-3.3.0.1492-linux.zip 
    && unzip sonar-scanner-cli-3.3.0.1492-linux.zip 
    && mv sonar-scanner-3.3.0.1492-linux/* ./ 
    && rm sonar-scanner-cli-3.3.0.1492-linux.zip 
    && rm -rf sonar-scanner-3.3.0.1492-linux 
    && ln -s /usr/local/sonarscanner/bin/sonar-scanner /usr/local/bin/sonar-scanner

ENV PATH $PATH:/usr/local/sonarscanner/bin/
ENV SONAR_RUNNER_HOME /usr/local/sonarscanner/bin/

Leírtuk az összeszerelési környezetet, de mi köze ehhez Jenkinsnek? A Jenkins-ügynökök pedig dolgozhatnak ilyen Docker-képekkel, és belsőleg is elkészíthetik azokat.

stage("Build project") {
    agent {
        docker {
            image "project-build:${DOCKER_IMAGE_BRANCH}"
            args "-v ${PWD}:/usr/src/app -w /usr/src/app"
            reuseNode true
            label "build-image"
        }
    }
    steps {
        sh "yarn"
        sh "yarn build"
    }
}

Irányelv agent ingatlant használ dockerahol megadhatja:

• az összeállítási konténer neve az Ön elnevezési szabályzatának megfelelően;
• A build tároló futtatásához szükséges argumentumok, ahol esetünkben az aktuális könyvtárat csatoljuk a tárolón belüli könyvtárként.

És már a felépítési lépésekben jelezzük, hogy mely parancsokat kell végrehajtani a Docker build ügynökön belül. Ez bármi lehet, ezért az ansible segítségével elindítom az alkalmazástelepítést is.

Az alábbiakban egy általános Jenkinsfile-t szeretnék bemutatni, amelyet egy egyszerű Node.JS alkalmazás képes létrehozni.

def DOCKER_IMAGE_BRANCH = ""
def GIT_COMMIT_HASH = ""

pipeline { 
    options {
        buildDiscarder(
            logRotator(
                artifactDaysToKeepStr: "",
                artifactNumToKeepStr: "",
                daysToKeepStr: "",
                numToKeepStr: "10"
            )
        )
        disableConcurrentBuilds()
    }

    agent any

    stages {

        stage("Prepare build image") {
            steps {
                sh "docker build -f Dockerfile.build . -t project-build:${DOCKER_IMAGE_BRANCH}"
            }
        }

        stage("Build project") {
            agent {
                docker {
                    image "project-build:${DOCKER_IMAGE_BRANCH}"
                    args "-v ${PWD}:/usr/src/app -w /usr/src/app"
                    reuseNode true
                    label "build-image"
                }
            }
            steps {
                sh "yarn"
                sh "yarn build"
            }
        }

    post {
        always {
            step([$class: "WsCleanup"])
            cleanWs()
        }
    }

}

Mi történt?

Ennek a módszernek köszönhetően a következő problémákat oldottuk meg:

• a környezeti összeállítás konfigurációs ideje projektenként 10-15 percre csökken;
• teljesen megismételhető alkalmazásépítési környezet, mivel így a helyi számítógépen is elkészítheti;
• nincs probléma az összeszerelő szerszámok különböző verziói közötti ütközésekkel;
• mindig tiszta munkaterület, amely nem tömődik el.

Maga a megoldás egyszerű és kézenfekvő, és lehetővé teszi bizonyos előnyök megszerzését. Igen, a belépési küszöb kissé emelkedett az összeállítások egyszerű parancsaihoz képest, de most már garantált, hogy mindig megépül, és a fejlesztő maga választhat ki mindent, ami az építési folyamatához szükséges.

Használhatod az általam összegyűjtött képet is Jenkins + Docker. Minden forrás nyitott és a címen található rmuhamedgaliev/jenkins_docker.

A cikk írásakor vita alakult ki az ügynökök távoli szervereken való használatáról, hogy ne töltsék be a főcsomópontot plugin segítségével docker-plugin. De erről a jövőben fogok beszélni.

Forrás: will.com