ProHoster > Blog > Bestjoer > Hoe kinne jo projekten sammelje yn Jenkins as jo in protte ferskillende omjouwings nedich binne

Hoe kinne jo projekten sammelje yn Jenkins as jo in protte ferskillende omjouwings nedich binne

Hoe kinne jo projekten sammelje yn Jenkins as jo in protte ferskillende omjouwings nedich binne

D'r binne in protte artikels oer Habré oer Jenkins, mar in pear beskriuwe foarbylden fan hoe't Jenkins en docker-aginten wurkje. Alle populêre ark foar projektbou lykas Drone.io, Bitbucket Pipeline, GitLab, GitHub aksjes en oaren, kinne sammelje alles yn konteners. Mar hoe sit it mei Jenkins?

Hjoed is d'r in oplossing foar it probleem: Jenkins 2 is geweldich om mei te wurkjen Docker aginten. Yn dit artikel wol ik myn ûnderfining diele en sjen litte hoe't jo it sels kinne dwaan.

Wêrom begon ik dit probleem op te lossen?

Sûnt wy binne yn bedriuw Sitroanium Om't wy in protte ferskillende technologyen brûke, moatte wy ferskate ferzjes fan Node.JS, Gradle, Ruby, JDK en oaren op 'e assemblagemasine hâlde. Mar faaks kinne ferzjekonflikten net foarkommen wurde. Ja, jo sille gelyk hawwe as jo sizze dat d'r ferskate ferzjebehearders binne lykas nvm, rvm, mar net alles is sa glêd mei har en dizze oplossingen hawwe problemen:

  • in grutte hoemannichte runtime dy't ûntwikkelders ferjitte om skjin te meitsjen;
  • der binne konflikten tusken ferskillende ferzjes fan deselde runtimes;
  • Elke ûntwikkelder hat in oare set komponinten nedich.

D'r binne oare problemen, mar lit my jo fertelle oer de oplossing.

Jenkins yn Docker

Sûnt Docker no goed fêstige is yn 'e ûntwikkelingswrâld, kin hast alles wurde útfierd mei Docker. Myn oplossing is om Jenkins yn Docker te hawwen en oare Docker-konteners út te kinnen. Dizze fraach begon werom te wurden yn 2013 yn it artikel "Docker kin no rinne binnen Docker".

Koartsein, jo moatte gewoan Docker sels ynstallearje yn in wurkjende kontener en it bestân montearje /var/run/docker.sock.

Hjir is in foarbyld Dockerfile dat bliek foar 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

Sa krigen wy in Docker-kontener dy't Docker-kommando's kin útfiere op 'e hostmasine.

Bouwe opset

Net lang lyn krige Jenkins de kâns om har regels te beskriuwen mei help fan Pipeline syntaksis, wat it frij maklik makket om it bouskript te feroarjen en it op te slaan yn it repository.

Litte wy dus in spesjale Dockerfile yn 'e repository sels pleatse, dy't alle biblioteken sil befetsje dy't nedich binne foar de bou. Op dizze manier kin de ûntwikkelder sels in werhellbere omjouwing tariede en sil OPS net hoege te freegjen om in spesifike ferzje fan Node.JS op 'e host te ynstallearjen.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Dit build-ôfbylding is geskikt foar de measte Node.JS-applikaasjes. Wat as jo bygelyks in ôfbylding nedich hawwe foar in JVM-projekt mei in Sonar-scanner ynbegrepen? Jo binne frij om de komponinten te kiezen dy't jo nedich binne foar montage.

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/

Wy beskreaun de gearkomste omjouwing, mar wat hat Jenkins te krijen mei it? En Jenkins-aginten kinne mei sokke Docker-ôfbyldings wurkje en se yntern bouwe. 

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

Rjochtline agent brûkt eigendom dockerwêr kinne jo oantsjutte:

  • de namme fan de gearstalling kontener neffens jo nammebelied;
  • arguminten dy't nedich binne om de bouwkontener út te fieren, wêr't wy yn ús gefal de hjoeddeistige map as map yn 'e kontener montearje.

En al yn 'e boustappen jouwe wy oan hokker kommando's moatte wurde útfierd binnen de Docker build-agent. Dit kin alles wêze, dus ik lansearje ek applikaasje-ynset mei ansible.

Hjirûnder wol ik in generike Jenkinsfile sjen litte dy't in ienfâldige Node.JS-applikaasje kin bouwe.

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 is bard?

Troch dizze metoade hawwe wy de folgjende problemen oplost:

  • omjouwing assembly konfiguraasje tiid wurdt fermindere ta 10 - 15 minuten per projekt;
  • in folslein werheljebere applikaasje-buildomjouwing, om't jo it op dizze manier kinne bouwe op jo lokale kompjûter;
  • d'r binne gjin problemen mei konflikten tusken ferskate ferzjes fan assemblage-ark;
  • altyd in skjinne wurkromte dy't net ferstoppe wurdt.

De oplossing sels is ienfâldich en fanselssprekkend en lit jo wat foardielen krije. Ja, de yngongsdrompel is in bytsje ferhege yn ferliking mei ienfâldige kommando's foar gearkomsten, mar no is d'r garânsje dat it altyd boud wurde sil en de ûntwikkelder sels kin alles kieze dat nedich is foar syn bouproses.

Jo kinne ek de ôfbylding brûke dy't ik sammele Jenkins + Docker. Alle boarnen binne iepen en leit by rmuhamedgaliev/jenkins_docker.

By it skriuwen fan dit artikel ûntstie in diskusje oer it brûken fan aginten op tsjinners op ôfstân om de masterknooppunt net te laden mei in plugin docker-plugin. Mar ik sil it oer dit yn 'e takomst.

Boarne: www.habr.com

Add a comment