Kako zbrati projekte v Jenkinsu, če potrebujete veliko različnih okolij

Na Habréju je veliko člankov o Jenkinsu, le malo jih opisuje primere delovanja Jenkinsa in pristaniških agentov. Vsa priljubljena orodja za gradnjo projektov, kot je Drone.io, Bitbucket cevovod, GitLab, GitHub dejanja in drugi, lahko vse zbirajo v zabojnike. Kaj pa Jenkins?

Danes obstaja rešitev za problem: Jenkins 2 je odličen za delo Docker agenti. V tem članku želim deliti svoje izkušnje in pokazati, kako lahko to storite sami.

Zakaj sem se lotil reševanja tega problema?

Ker smo v družbi Citronij Ker uporabljamo veliko različnih tehnologij, moramo na montažnem stroju hraniti različne različice Node.JS, Gradle, Ruby, JDK in drugih. Toda pogosto se konfliktom različic ni mogoče izogniti. Da, prav boste imeli, če boste rekli, da obstajajo različni upravitelji različic, kot sta nvm, rvm, vendar z njimi ni vse tako gladko in te rešitve imajo težave:

• veliko časa izvajanja, ki ga razvijalci pozabijo očistiti;
• obstajajo konflikti med različnimi različicami istih izvajalnih časov;
• Vsak razvijalec potrebuje drugačen nabor komponent.

Obstajajo še druge težave, a naj vam povem o rešitvi.

Jenkins v Dockerju

Ker je Docker zdaj dobro uveljavljen v razvojnem svetu, je mogoče z Dockerjem izvajati skoraj vse. Moja rešitev je, da imam Jenkinsa v Dockerju in da lahko poganjam druge vsebnike Docker. To vprašanje se je začelo postavljati že leta 2013 v članku "Docker lahko zdaj deluje znotraj Dockerja".

Skratka, samo Docker morate namestiti v delujoč vsebnik in namestiti datoteko /var/run/docker.sock.

Tukaj je primer Dockerfile, ki se je izkazal za Jenkinsa.

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

Tako smo dobili Docker vsebnik, ki lahko izvaja Docker ukaze na gostiteljskem računalniku.

Nastavitev zgradbe

Nedolgo nazaj je Jenkins dobil priložnost opisati svoja pravila z uporabo Pipeline sintakso, ki omogoča precej preprosto spreminjanje skripta gradnje in njegovo shranjevanje v repozitorij.

V repozitorij postavimo torej poseben Dockerfile, ki bo vseboval vse knjižnice, potrebne za gradnjo. Na ta način lahko razvijalec sam pripravi ponovljivo okolje in mu ne bo treba zahtevati od OPS-a, da na gostitelja namesti določeno različico Node.JS.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Ta gradbena slika je primerna za večino aplikacij Node.JS. Kaj pa, če na primer potrebujete sliko za projekt JVM z vključenim optičnim bralnikom Sonar? Komponente, ki jih potrebujete za sestavo, lahko prosto izberete.

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/

Opisali smo montažno okolje, toda kaj ima Jenkins s tem? In Jenkinsovi agenti lahko delajo s takšnimi slikami Docker in jih sestavijo interno.

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"
    }
}

Direktiva agent uporablja lastnino dockerkjer lahko določite:

• ime vsebnika za sestavljanje v skladu z vašo politiko poimenovanja;
• argumenti, potrebni za zagon gradbenega vsebnika, kjer v našem primeru vpnemo trenutni imenik kot imenik znotraj vsebnika.

In že v korakih gradnje navedemo, katere ukaze je treba izvesti znotraj gradbenega agenta Docker. To je lahko karkoli, zato zaženem tudi uvajanje aplikacije z uporabo ansible.

Spodaj želim prikazati generično datoteko Jenkins, ki jo lahko zgradi preprosta aplikacija Node.JS.

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()
        }
    }

}

Kaj se je zgodilo?

Zahvaljujoč tej metodi smo rešili naslednje težave:

• čas konfiguracije sestave okolja se zmanjša na 10 - 15 minut na projekt;
• popolnoma ponovljivo okolje za gradnjo aplikacije, saj ga lahko na ta način zgradite na vašem lokalnem računalniku;
• ni težav s konflikti med različnimi različicami montažnih orodij;
• vedno čist delovni prostor, ki se ne zamaši.

Sama rešitev je preprosta in očitna ter vam omogoča, da pridobite nekaj prednosti. Da, vstopni prag se je nekoliko zvišal v primerjavi s preprostimi ukazi za sklope, vendar zdaj obstaja jamstvo, da bo vedno zgrajen in razvijalec lahko sam izbere vse, kar je potrebno za njegov gradbeni proces.

Uporabite lahko tudi sliko, ki sem jo zbral Jenkins + Docker. Vsi viri so odprti in se nahajajo na rmuhamedgaliev/jenkins_docker.

Med pisanjem tega članka se je pojavila razprava o uporabi agentov na oddaljenih strežnikih, da ne bi nalagali glavnega vozlišča z vtičnikom docker-plugin. Ampak o tem bom govoril v prihodnje.

Vir: www.habr.com