ProHoster > Blag > Riarachán > Conas tionscadail a bhailiú i Jenkins má tá go leor timpeallachtaí éagsúla ag teastáil uait

Conas tionscadail a bhailiú i Jenkins má tá go leor timpeallachtaí éagsúla ag teastáil uait

Conas tionscadail a bhailiú i Jenkins má tá go leor timpeallachtaí éagsúla ag teastáil uait

Tá go leor alt ar Habré faoi Jenkins, ach is beag samplaí a chuireann síos ar conas a oibríonn Jenkins agus gníomhairí duga. Is maith le gach uirlis tógála tionscadail tóir Drone.io, Píblíne Bitbucket, GitLab, Gníomhartha GitHub agus daoine eile, in ann gach rud a bhailiú i gcoimeádáin. Ach cad faoi Jenkins?

Inniu tá réiteach ar an bhfadhb: tá Jenkins 2 iontach ag obair leis Gníomhairí docker. San Airteagal seo ba mhaith liom mo thaithí a roinnt agus a thaispeáint conas is féidir leat é a dhéanamh leat féin.

Cén fáth ar thosaigh mé ag réiteach na faidhbe seo?

Ós rud é go bhfuil muid i gcuideachta Citronium Toisc go n-úsáideann muid go leor teicneolaíochtaí éagsúla, ní mór dúinn leaganacha éagsúla de Node.JS, Gradle, Ruby, JDK agus daoine eile a choinneáil ar an meaisín tionóil. Ach go minic ní féidir coinbhleachtaí leagan a sheachaint. Sea, beidh tú ceart má deir tú go bhfuil bainisteoirí leaganacha éagsúla cosúil le nvm, rvm, ach níl gach rud chomh réidh leo agus tá fadhbanna ag na réitigh seo:

  • cuid mhór ama rite a dhéanann forbróirí dearmad a ghlanadh;
  • tá coinbhleachtaí ann idir leaganacha éagsúla de na hamanna rite céanna;
  • Tá sraith comhpháirteanna éagsúla ag teastáil ó gach forbróir.

Tá fadhbanna eile ann, ach lig dom an réiteach a insint duit.

Jenkins sa Docker

Ós rud é go bhfuil Docker bunaithe go maith anois sa domhan forbartha, is féidir beagnach rud ar bith a reáchtáil ag baint úsáide as Docker. Is é an réiteach atá agam ná Jenkins in Docker a bheith agam agus a bheith in ann coimeádáin Docker eile a rith. Thosaigh an cheist seo a chur siar in 2013 san alt “Is féidir le Docker rith laistigh de Docker anois".

I mbeagán focal, ní mór duit ach Docker féin a shuiteáil i gcoimeádán oibre agus an comhad a shuiteáil /var/run/docker.sock.

Seo sampla Dockerfile a d'iompaigh amach do 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

Mar sin, fuair muid coimeádán Docker ar féidir leis orduithe Docker a fhorghníomhú ar an meaisín óstach.

Socrú a thógáil

Ní fada ó shin fuair Jenkins an deis chun cur síos a rialacha ag baint úsáide as Píblíne comhréir, rud a fhágann go bhfuil sé sách éasca an script tógála a athrú agus é a stóráil sa stór.

Mar sin cuirimis Dockerfile speisialta sa stór féin, ina mbeidh na leabharlanna go léir atá riachtanach don tógáil. Ar an mbealach seo, is féidir leis an bhforbróir féin timpeallacht in-athdhéanta a ullmhú agus ní bheidh air iarraidh ar OPS leagan sonrach de Node.JS a shuiteáil ar an óstach.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Tá an íomhá tógála seo oiriúnach don chuid is mó d'fheidhmchláir Node.JS. Cad a tharlóidh más rud é, mar shampla, go dteastaíonn íomhá uait do thionscadal JVM le scanóir Sonar san áireamh taobh istigh? Tá tú saor in aisce na comhpháirteanna a theastaíonn le haghaidh cóimeála a roghnú.

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/

Rinneamar cur síos ar thimpeallacht an tionóil, ach cad atá le déanamh ag Jenkins leis? Agus is féidir le gníomhairí Jenkins oibriú le híomhánna Docker den sórt sin agus iad a thógáil go hinmheánach. 

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

Treoir agent úsáideann maoin dockeráit ar féidir leat a shonrú:

  • ainm an choimeádáin tionóil de réir do bheartais ainmniúcháin;
  • argóintí a theastaíonn chun an coimeádán tógála a rith, áit inár gcás féin a chuirfimid an t-eolaire reatha suas mar eolaire laistigh den choimeádán.

Agus cheana féin sna céimeanna tógála léirímid na horduithe atá le forghníomhú taobh istigh den ghníomhaire tógála Docker. Is féidir leis seo a bheith rud ar bith, mar sin cuirim imscaradh feidhmchlár ag baint úsáide as ansible freisin.

Thíos ba mhaith liom a thaispeáint Jenkinsfile cineálach gur féidir le feidhmchlár Node.JS simplí a thógáil.

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

}

Cad a tharla?

A bhuíochas leis an modh seo, réitigh muid na fadhbanna seo a leanas:

  • laghdaítear am cumraíochta cóimeála timpeallachta go 10 - 15 nóiméad in aghaidh an tionscadail;
  • timpeallacht tógála feidhmchláir atá go hiomlán athdhéanta, toisc gur féidir leat é a thógáil ar an mbealach seo ar do ríomhaire áitiúil;
  • níl aon fhadhbanna ann maidir le coinbhleachtaí idir leaganacha éagsúla d'uirlisí tionóil;
  • i gcónaí spás oibre glan nach bhfaigheann clogged.

Tá an réiteach féin simplí agus soiléir agus ligeann duit roinnt buntáistí a fháil. Sea, tá an tairseach iontrála ardaithe beagán i gcomparáid le horduithe simplí le haghaidh tionóil, ach anois tá ráthaíocht ann go dtógfar i gcónaí é agus is féidir leis an bhforbróir féin gach rud atá riachtanach dá phróiseas tógála a roghnú.

Is féidir leat an íomhá a bhailigh mé a úsáid freisin Jenkins + Docker. Tá gach foinse oscailte agus suite ag rmuhamedgaliev/jenkins_docker.

Agus an t-alt seo á scríobh, tháinig plé ar ghníomhairí a úsáid ar fhreastalaithe cianda ionas nach ndéanfaí an máistir nód a luchtú le breiseán docker-breiseán. Ach labhróidh mé faoi seo amach anseo.

Foinse: will.com

Add a comment