🥇Mar a thogas tu pròiseactan ann an Jenkins ma tha feum agad air mòran àrainneachdan eadar-dhealaichte

Tha mòran artaigilean ann air Habr mu Jenkins, ach chan eil mòran a’ toirt cunntas air eisimpleir de mar a bhios riochdairean Jenkins agus Docker ag obair. Tha a h-uile inneal togail phròiseactan mòr-chòrdte mar… Drone.io, Pìob-loidhne Bitbucket, GitLab, Gnìomhan GitHub agus faodaidh feadhainn eile a h-uile càil a thogail ann an soithichean. Ach dè mu dheidhinn Jenkins?

An-diugh tha fuasgladh ann airson na trioblaid: tha Jenkins 2 math air obrachadh le Àidseantan DockerSan artaigil seo, tha mi airson mo eòlas a cho-roinn agus sealltainn dhut mar as urrainn dhut seo a dhèanamh leat fhèin.

Carson a thòisich mi air fuasgladh fhaighinn air an duilgheadas seo?

Leis gu bheil sinn anns a’ chompanaidh Citronium Leis gu bheil sinn a’ cleachdadh measgachadh de theicneòlasan, feumaidh sinn diofar dhreachan de Node.JS, Gradle, Ruby, JDK, agus feadhainn eile a chumail air an inneal togail. Ach gu tric chan eil còmhstri dreachan ri sheachnadh. Ged a dh’ fhaodadh tu a bhith ceart a ràdh gu bheil diofar mhanaidsearan dreachan ann leithid nvm agus rvm, chan eil iad an-còmhnaidh furasta, agus tha na duilgheadasan aca fhèin aig na fuasglaidhean seo:

meud mòr de ruith-ùine a dhìochuimhnicheas luchd-leasachaidh a ghlanadh;
tha còmhstri ann eadar diofar dhreachan den aon ruith-ùine;
Feumaidh gach leasaiche seata eadar-dhealaichte de phàirtean.

Tha duilgheadasan eile ann, ach leig dhomh innse dhut mun fhuasgladh.

Jenkins ann an Docker

Leis gu bheil Docker stèidhichte gu math a-nis ann an saoghal an leasachaidh, faodar cha mhòr a h-uile càil a ruith le Docker. Is e am fuasgladh agam Jenkins a bhith agam ann an Docker agus a bhith comasach air soithichean Docker eile a ruith. Chaidh dèiligeadh ris a’ cheist seo an toiseach ann an 2013 san artaigil "Faodaidh Docker a-nis ruith taobh a-staigh Docker".

Ann an ùine ghoirid, chan fheum thu ach Docker fhèin a stàladh anns a’ chiste-obrach agus am faidhle a chuir suas. /var/run/docker.sock.

Seo eisimpleir den Dockerfile a thàinig às dèidh sin airson 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, fhuair sinn soitheach Docker as urrainn òrdughan Docker a chuir an gnìomh air an inneal aoigheachd.

Suidheachadh togail

Chan eil fada bho chionn fhada, fhuair Jenkins comas air na riaghailtean aige a mhìneachadh le bhith a’ cleachdadh Pìob-loidhne co-chàradh, a tha ga dhèanamh furasta an sgriobt togail atharrachadh agus a stòradh san stòr-dàta.

Mar sin, cuiridh sinn Dockerfile sònraichte anns an stòras-dàta fhèin, anns a bheil na leabharlannan uile a dh’ fheumar airson togail. San dòigh seo, faodaidh an leasaiche àrainneachd ath-aithris ullachadh gun a bhith ag iarraidh air OPS dreach sònraichte de Node.JS a stàladh air an aoigh.

FROM node:12.10.0-alpine

RUN npm install yarn -g

Tha an ìomhaigh togail seo freagarrach airson a’ mhòr-chuid de thagraidhean Node.JS. Ach dè ma tha, mar eisimpleir, feum agad air ìomhaigh JVM airson pròiseact le sganair Sonar togte a-steach? Tha saorsa agad na pàirtean a dh’ fheumas tu airson an togail a thaghadh.

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/

Tha sinn air an àrainneachd togail a mhìneachadh, ach dè tha Jenkins a’ ciallachadh leis? Faodaidh riochdairean Jenkins obrachadh leis na h-ìomhaighean Docker seo agus togail annta.

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

Stiùireadh agent a’ cleachdadh na seilbhe docker, far am faod thu sònrachadh:

ainm a’ chiste-chruinneachaidh a rèir do phoileasaidh ainmeachaidh;
argamaidean a tha a dhìth gus an soitheach togail a ruith, far a bheil sinn nar cùis-ne a’ cur suas an eòlaire làithreach mar eòlaire taobh a-staigh an t-soithich.

Agus anns na ceumannan togail, bidh sinn a’ sònrachadh dè na h-òrdughan a ruitheas sinn taobh a-staigh àidseant togail Docker. Faodaidh seo a bhith na rud sam bith, agus mar sin bidh mi cuideachd a’ ruith cleachdaidhean aplacaidean le Ansible.

Gu h-ìosal tha mi airson faidhle Jenkins coitcheann a shealltainn as urrainn tagradh Node.JS sìmplidh a thogail.

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

}

Agus dè thachair?

A’ cleachdadh an dòigh seo, fhuair sinn fuasgladh air na duilgheadasan a leanas:

tha an ùine a bheir e airson an àrainneachd togail a rèiteachadh air a lùghdachadh gu 10–15 mionaidean gach pròiseact;
àrainneachd togail aplacaidean a ghabhas ath-aithris gu tur, oir faodar a thogail air coimpiutair ionadail cuideachd;
chan eil duilgheadasan ann le còmhstri eadar diofar dhreachan de innealan togail;
àite-obrach glan an-còmhnaidh nach fàs ro thrang.

Tha am fuasgladh fhèin sìmplidh agus follaiseach, agus chan eil ann ach buannachdan. Tha, tha an cnap-starra inntrigidh beagan nas àirde na le òrdughan togail sìmplidh, ach a-nis tha gealladh ann gun obraich an togail an-còmhnaidh, agus faodaidh an leasaiche a h-uile dad a dh’ fheumas iad airson a’ phròiseas togail aca a thaghadh.

Faodaidh tu an dealbh a chuir mi ri chèile a chleachdadh cuideachd. Jenkins + DockerTha na stòran uile fosgailte agus suidhichte air rmuhamedgaliev/jenkins_docker.

Fhad ’s a bha an artaigil seo ga sgrìobhadh, bha deasbad ann mu bhith a’ cleachdadh riochdairean air frithealaichean iomallach gus nach biodh am prìomh nód air a luchdachadh le plugan. plugan-docaidhAch innsidh mi dhut mu dheidhinn seo san àm ri teachd.

Source: www.habr.com