ProHoster > Blog > administrasie > Hoe om projekte in Jenkins te versamel as jy baie verskillende omgewings benodig

Hoe om projekte in Jenkins te versamel as jy baie verskillende omgewings benodig

Hoe om projekte in Jenkins te versamel as jy baie verskillende omgewings benodig

Daar is baie artikels oor Habré oor Jenkins, maar min beskryf voorbeelde van hoe Jenkins en dok-agente werk. Alle gewilde projekbou-instrumente soos Drone.io, Bitbucket-pyplyn, GitLab, GitHub-aksies en ander, kan alles in houers versamel. Maar wat van Jenkins?

Vandag is daar 'n oplossing vir die probleem: Jenkins 2 is wonderlik om mee te werk Docker-agente. In hierdie artikel wil ek my ervaring deel en wys hoe jy dit self kan doen.

Hoekom het ek hierdie probleem begin oplos?

Aangesien ons in geselskap is Sitronium Omdat ons baie verskillende tegnologieë gebruik, moet ons verskillende weergawes van Node.JS, Gradle, Ruby, JDK en ander op die monteermasjien hou. Maar dikwels kan weergawekonflikte nie vermy word nie. Ja, jy sal reg wees as jy sê dat daar verskeie weergawebestuurders is soos nvm, rvm, maar nie alles is so glad met hulle nie en hierdie oplossings het probleme:

  • 'n groot hoeveelheid looptyd wat ontwikkelaars vergeet om skoon te maak;
  • daar is konflikte tussen verskillende weergawes van dieselfde looptye;
  • Elke ontwikkelaar benodig 'n ander stel komponente.

Daar is ander probleme, maar kom ek vertel jou van die oplossing.

Jenkins in Docker

Aangesien Docker nou goed gevestig is in die ontwikkelingswêreld, kan byna enigiets met Docker bestuur word. My oplossing is om Jenkins in Docker te hê en ander Docker-houers te kan bestuur. Hierdie vraag begin terug in 2013 in die artikel "Docker kan nou binne Docker loop«.

Kortom, jy hoef net Docker self in 'n werkende houer te installeer en die lêer te monteer /var/run/docker.sock.

Hier is 'n voorbeeld Dockerfile wat vir Jenkins uitgedraai het.

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

Ons het dus 'n Docker-houer gekry wat Docker-opdragte op die gasheermasjien kan uitvoer.

Bou opstelling

Nie lank gelede nie het Jenkins die geleentheid gekry om sy reëls te beskryf deur gebruik te maak Pyplyn sintaksis, wat dit redelik maklik maak om die bouskrif te verander en dit in die bewaarplek te stoor.

Laat ons dus 'n spesiale Dockerfile in die bewaarplek self plaas, wat al die biblioteke sal bevat wat nodig is vir die bou. Op hierdie manier kan die ontwikkelaar self 'n herhaalbare omgewing voorberei en sal nie OPS hoef te vra om 'n spesifieke weergawe van Node.JS op die gasheer te installeer nie.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Hierdie boubeeld is geskik vir die meeste Node.JS-toepassings. Wat as jy byvoorbeeld 'n prent benodig vir 'n JVM-projek met 'n Sonar-skandeerder ingesluit? U is vry om die komponente te kies wat u benodig vir montering.

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/

Ons het die monteringsomgewing beskryf, maar wat het Jenkins daarmee te doen? En Jenkins-agente kan met sulke Docker-beelde werk en dit intern bou. 

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

Richtlijn agent eiendom gebruik dockerwaar jy kan spesifiseer:

  • die naam van die monteerhouer volgens u naambeleid;
  • argumente wat nodig is om die bouhouer te laat loop, waar ons in ons geval die huidige gids as 'n gids binne die houer monteer.

En reeds in die boustappe dui ons aan watter opdragte binne die Docker-bouagent uitgevoer moet word. Dit kan enigiets wees, so ek begin ook toepassing-ontplooiing met behulp van ansible.

Hieronder wil ek 'n generiese Jenkins-lêer wys wat 'n eenvoudige Node.JS-toepassing kan bou.

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

}

Wat het gebeur?

Danksy hierdie metode het ons die volgende probleme opgelos:

  • omgewing samestelling konfigurasie tyd word verminder tot 10 - 15 minute per projek;
  • 'n heeltemal herhaalbare toepassingsbou-omgewing, aangesien jy dit so op jou plaaslike rekenaar kan bou;
  • daar is geen probleme met konflikte tussen verskillende weergawes van monteergereedskap nie;
  • altyd 'n skoon werkspasie wat nie verstop raak nie.

Die oplossing self is eenvoudig en voor die hand liggend en laat jou toe om 'n paar voordele te kry. Ja, die toegangsdrempel het effens gestyg in vergelyking met eenvoudige opdragte vir samestellings, maar nou is daar 'n waarborg dat dit altyd gebou sal word en die ontwikkelaar kan self alles kies wat nodig is vir sy bouproses.

Jy kan ook die prent gebruik wat ek versamel het Jenkins + Docker. Alle bronne is oop en geleë by rmuhamedgaliev/jenkins_docker.

Tydens die skryf van hierdie artikel het 'n bespreking ontstaan ​​oor die gebruik van agente op afgeleë bedieners om nie die hoofnodus met 'n inprop te laai nie docker-inprop. Maar ek sal in die toekoms hieroor praat.

Bron: will.com

Voeg 'n opmerking