Hur man samlar projekt i Jenkins om många olika miljöer behövs

Det finns många artiklar om Jenkins på Habré, men få ställen beskriver exempel på hur Jenkins och Docker-agenter fungerar. Alla populära projektbyggverktyg som Drone.io, Bitbucket Pipeline, GitLab, GitHub Actions och andra kan bygga allt i containrar. Men hur fungerar Jenkins?

Idag finns det en lösning på problemet: Jenkins 2 fungerar utmärkt med Docker-agenter. I den här artikeln vill jag dela med mig av mina erfarenheter och visa hur du kan göra detta själv.

Varför började jag lösa detta problem?

Eftersom vi på företaget Citronium använder många olika teknologier, måste byggmaskinen ha olika versioner av Node.JS, Gradle, Ruby, JDK och andra. Men det är ofta oundvikligt med versionskonflikter. Ja, du har rätt om du säger att det finns olika versionshanterare som nvm, rvm, men det är inte alltid så enkelt med dem och dessa lösningar har sina problem:

• stora mängder av runtime-miljöer som utvecklare glömmer att rensa;
• det finns konflikter mellan olika versioner av samma runtime-miljöer;
• varje utvecklare behöver olika uppsättningar av komponenter.

Det finns andra problem, men låt mig hellre berätta om lösningen.

Jenkins i Docker

Eftersom Docker nu har fått ett starkt fäste inom utvecklingsvärlden kan nästan allt köras med hjälp av Docker. Min lösning är att Jenkins ska köras i Docker och kunna starta andra Docker-containrar. Denna fråga började diskuteras redan 2013 i artikeln "Docker can now run within Docker«.

Kort sagt, det är nödvändigt att installera Docker i arbetscontainern och montera filen /var/run/docker.sock.

Här är ett exempel på Dockerfile som skapades för 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

På så sätt fick vi en Docker-container som kan utföra Docker-kommandon på värdmaskinen.

Inställning av byggning

För inte så länge sedan fick Jenkins möjlighet att beskriva sina regler med Pipeline syntax, vilket gör det ganska enkelt att ändra byggskriften och lagra den i ett repository.

Låt oss sätta en speciell Dockerfile i själva arkivet som kommer att innehålla alla nödvändiga bibliotek för byggprocessen. På så sätt kan utvecklaren själv förbereda en reproducerbar miljö och behöver inte be OPS att installera en viss version av Node.JS på värden.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Den här byggavbildningen passar för de flesta Node.JS-applikationer. Men om du till exempel behöver en avbildning för ett JVM-projekt med en inbyggd Sonar-scanner? Du har friheten att välja de nödvändiga komponenterna för byggprocessen.

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/

Vi har beskrivit byggmiljön, men vad har Jenkins med saken att göra? Jenkins-agenter kan arbeta med sådana Docker-avbilder och utföra byggprocesser inuti.

stage("Bygg projekt") {
    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"
    }
}

Direktiv agent använder egenskapen docker, där du kan ange:

• namnet på byggcontainern enligt din namngivningspolicy;
• de argument som behövs för att köra byggcontainern, där vi i vårt fall monterar den aktuella katalogen som en katalog inuti containern.

Och redan i byggstegen anger vi vilka kommandon som ska köras inuti bygg-Docker-agenten. Det kan vara vad som helst, på så sätt utför jag även distribution av applikationer med hjälp av ansible.

Nedan vill jag visa en allmän Jenkinsfile som kan bygga en enkel Node.JS-applikation.

def DOCKER_IMAGE_BRANCH = ""
def GIT_COMMIT_HASH = ""

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

    agent any

    stages {

        stage("Förbered byggbild") {
            steps {
                sh "docker build -f Dockerfile.build . -t project-build:${DOCKER_IMAGE_BRANCH}"
            }
        }

        stage("Bygg projekt") {
            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()
        }
    }

}

Vad blev resultatet?

Genom denna metod löste vi följande problem:

• tiden för att konfigurera byggmiljön reduceras till 10 - 15 minuter per projekt;
• en helt reproducerbar byggmiljö, eftersom den kan byggas även på den lokala datorn;
• inga problem med konflikter mellan olika versioner av byggverktyg;
• alltid en ren arbetsyta som inte blir överbelastad.

Själva lösningen är enkel och uppenbar och ger enbart fördelar. Ja, inträdesbarriären har höjts något jämfört med enklare byggkommandon, men nu finns det en garanti på att bygget alltid kommer att lyckas och utvecklaren kan själv välja allt som behövs i sin byggprocess.

Du kan också använda den bild jag har byggt Jenkins + Docker. All källkod är öppen och ligger på rmuhamedgaliev/jenkins_docker.

Under skrivandet av artikeln uppstod en diskussion om användningen av agenter på fjärrservrar för att inte belasta huvudnoden med hjälp av pluginet docker-plugin. Men det kommer jag att berätta om i framtiden.

Källa: habr.com