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

Na Habru je veliko člankov o Jenkinsu, vendar le malo jih opisuje primer delovanja agentov Jenkins in Docker. Vsa priljubljena orodja za gradnjo projektov, kot so Drone.io, Cevovod Bitbucket, GitLab, GitHub dejanja in drugi lahko vse zgradijo v kontejnerjih. Kaj pa Jenkins?

Danes obstaja rešitev problema: Jenkins 2 odlično deluje z Dockerjevi agentiV tem članku želim deliti svoje izkušnje in vam pokazati, kako lahko to storite sami.

Zakaj sem začel reševati ta problem?

Ker smo v podjetju Citronij Ker uporabljamo različne tehnologije, moramo na gradbenem računalniku vzdrževati različne različice Node.JS, Gradle, Ruby, JDK in drugih. Vendar pa se konflikti različic pogosto ne morejo izogniti. Čeprav imate morda prav, ko rečete, da obstajajo različni upravitelji različic, kot sta nvm in rvm, niso vedno mačji kašelj in te rešitve imajo svoje težave:

• velika količina izvajalnih okolij, ki jih razvijalci pozabijo očistiti;
• obstajajo konflikti med različnimi različicami istih izvajalnih okolij;
• Vsak razvijalec potrebuje drugačen nabor komponent.

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

Jenkins v Dockerju

Ker je Docker zdaj dobro uveljavljen v svetu razvoja, je skoraj vse mogoče zagnati z njim. Moja rešitev je, da imam Jenkins v Dockerju in da lahko zaženem druge Dockerjeve vsebnike. To vprašanje je bilo prvič obravnavano leta 2013 v članku "Docker se zdaj lahko izvaja znotraj Dockerja".

Skratka, Docker morate le namestiti v delovni vsebnik in namestiti datoteko /var/run/docker.sock.

Tukaj je primer datoteke Dockerfile, ki je nastala za Jenkins.

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 Dockerjev kontejner, ki lahko izvaja Dockerjeve ukaze na gostiteljskem računalniku.

Nastavitev gradnje

Nedolgo nazaj je Jenkins pridobil sposobnost opisovanja svojih pravil z uporabo Pipeline sintaksa, ki omogoča enostavno spreminjanje skripte za gradnjo in njeno shranjevanje v repozitorij.

Torej, v sam repozitorij namestimo posebno datoteko Dockerfile, ki vsebuje vse knjižnice, potrebne za gradnjo. Na ta način lahko razvijalec pripravi ponovljivo okolje, ne da bi moral od OPS zahtevati namestitev določene različice Node.JS na gostitelja.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Ta slika gradnje je primerna za večino aplikacij Node.JS. Kaj pa, če na primer potrebujete sliko JVM za projekt z integriranim skenerjem Sonar? Izberete lahko komponente, ki jih potrebujete za gradnjo.

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 okolje za gradnjo, kaj pa ima Jenkins s tem opraviti? Jenkinsovi agenti lahko delajo s temi Dockerjevimi slikami in gradijo znotraj njih.

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 nepremičnino docker, kjer lahko določite:

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

V korakih gradnje določimo, katere ukaze bomo zagnali znotraj Dockerjevega agenta za gradnjo. To je lahko karkoli, zato tudi sam izvajam uvajanje aplikacij z Ansible.

Spodaj želim prikazati splošno datoteko Jenkinsfile, s katero je mogoče zgraditi preprosto aplikacijo 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 torej zgodilo?

S to metodo smo rešili naslednje probleme:

• čas za konfiguriranje gradbenega okolja se skrajša na 10–15 minut na projekt;
• popolnoma ponovljivo okolje za gradnjo aplikacij, saj ga je mogoče zgraditi tudi na lokalnem računalniku;
• ni težav s konflikti med različnimi različicami orodij za gradnjo;
• vedno čisto delovno mesto, ki ni natrpano.

Rešitev sama po sebi je preprosta in očitna ter ponuja le prednosti. Da, vstopna ovira je nekoliko višja kot pri preprostih ukazih za gradnjo, vendar zdaj obstaja zagotovilo, da bo gradnja vedno delovala, razvijalec pa lahko izbere vse, kar potrebuje za svoj postopek gradnje.

Lahko pa uporabiš tudi sliko, ki sem jo sestavil. Jenkins + DockerVsi viri so odprti in se nahajajo na rmuhamedgaliev/jenkins_docker.

Med pisanjem tega članka je potekala razprava o uporabi agentov na oddaljenih strežnikih, da bi se izognili nalaganju glavnega vozlišča z vtičnikom. vtičnik za DockerAmpak o tem vam bom povedal v prihodnosti.

Vir: www.habr.com