របៀបប្រមូលគម្រោងនៅក្នុង Jenkins ប្រសិនបើអ្នកត្រូវការបរិយាកាសខុសៗគ្នាជាច្រើន។

មានអត្ថបទជាច្រើននៅលើ Habre អំពី Jenkins ប៉ុន្តែមានមនុស្សតិចណាស់ដែលពិពណ៌នាអំពីវិធីដែល Jenkins និងភ្នាក់ងារ docker ធ្វើការ។ ឧបករណ៍សាងសង់គម្រោងពេញនិយមទាំងអស់ដូចជា Drone.io, បំពង់ Bitbucket, GitLab, សកម្មភាព GitHub និងអ្នកផ្សេងទៀតអាចប្រមូលអ្វីគ្រប់យ៉ាងនៅក្នុងធុង។ ប៉ុន្តែចុះ Jenkins វិញ?

ថ្ងៃនេះមានដំណោះស្រាយចំពោះបញ្ហា៖ Jenkins 2 ពូកែធ្វើការជាមួយ ភ្នាក់ងារ Docker. នៅក្នុងអត្ថបទនេះ ខ្ញុំចង់ចែករំលែកបទពិសោធន៍របស់ខ្ញុំ និងបង្ហាញពីរបៀបដែលអ្នកអាចធ្វើវាដោយខ្លួនឯងបាន។

ហេតុអ្វីបានជាខ្ញុំចាប់ផ្តើមដោះស្រាយបញ្ហានេះ?

ចាប់តាំងពីយើងនៅក្នុងក្រុមហ៊ុន ស៊ីតូនីញ៉ូម ដោយសារយើងប្រើបច្ចេកវិទ្យាផ្សេងៗគ្នាជាច្រើន យើងត្រូវរក្សាកំណែផ្សេងគ្នានៃ Node.JS, Gradle, Ruby, JDK និងផ្សេងទៀតនៅលើម៉ាស៊ីនដំឡើង។ ប៉ុន្តែជារឿយៗការប៉ះទង្គិចនៃកំណែមិនអាចជៀសវាងបានទេ។ បាទ/ចាស អ្នកនឹងនិយាយត្រូវប្រសិនបើអ្នកនិយាយថាមានកម្មវិធីគ្រប់គ្រងកំណែផ្សេងៗដូចជា nvm, rvm ប៉ុន្តែមិនមែនអ្វីៗទាំងអស់គឺរលូនជាមួយពួកគេទេ ហើយដំណោះស្រាយទាំងនេះមានបញ្ហា៖

• ចំនួនដ៏ច្រើននៃពេលវេលារត់ដែលអ្នកអភិវឌ្ឍន៍ភ្លេចសម្អាត។
• មានការប៉ះទង្គិចរវាងកំណែផ្សេងគ្នានៃពេលវេលាដំណើរការដូចគ្នា;
• អ្នកអភិវឌ្ឍន៍គ្រប់រូបត្រូវការសំណុំសមាសភាគផ្សេងគ្នា។

មានបញ្ហាផ្សេងទៀត ប៉ុន្តែខ្ញុំសូមប្រាប់អ្នកអំពីដំណោះស្រាយ។

Jenkins នៅ Docker

ដោយសារឥឡូវនេះ Docker ត្រូវបានបង្កើតឡើងយ៉ាងល្អនៅក្នុងពិភពអភិវឌ្ឍន៍ ស្ទើរតែអ្វីៗទាំងអស់អាចដំណើរការបានដោយប្រើ Docker ។ ដំណោះស្រាយរបស់ខ្ញុំគឺត្រូវមាន Jenkins នៅក្នុង Docker ហើយអាចដំណើរការ Docker containers ផ្សេងទៀត។ សំណួរ​នេះ​ចាប់​ផ្ដើម​សួរ​ម្ដង​ទៀត​ក្នុង​ឆ្នាំ ២០១៣ ក្នុង​អត្ថបទ “ឥឡូវនេះ Docker អាចដំណើរការនៅក្នុង Docker"។

និយាយឱ្យខ្លីអ្នកគ្រាន់តែត្រូវដំឡើង Docker ខ្លួនវានៅក្នុងកុងតឺន័រធ្វើការហើយម៉ោនឯកសារ /var/run/docker.sock.

នេះគឺជាឧទាហរណ៍ Dockerfile ដែលបានប្រែក្លាយសម្រាប់ 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

ដូច្នេះហើយ យើងទទួលបាន Docker container ដែលអាចប្រតិបត្តិពាក្យបញ្ជា Docker នៅលើម៉ាស៊ីនម៉ាស៊ីន។

បង្កើតការដំឡើង

មិនយូរប៉ុន្មាន Jenkins ទទួលបានឱកាសដើម្បីពិពណ៌នាអំពីច្បាប់របស់វាដោយប្រើ បំពង់បង្ហូរ វាក្យសម្ព័ន្ធ ដែលធ្វើឱ្យវាងាយស្រួលក្នុងការផ្លាស់ប្តូរស្គ្រីបសាងសង់ និងរក្សាទុកវានៅក្នុងឃ្លាំង។

ដូច្នេះ ចូរយើងដាក់ Dockerfile ពិសេសមួយនៅក្នុងឃ្លាំងខ្លួនវា ដែលនឹងមានបណ្ណាល័យទាំងអស់ដែលចាំបាច់សម្រាប់ការសាងសង់។ វិធីនេះ អ្នកអភិវឌ្ឍន៍ខ្លួនឯងអាចរៀបចំបរិស្ថានដែលអាចធ្វើម្តងទៀតបាន ហើយនឹងមិនចាំបាច់ស្នើសុំឱ្យ OPS ដំឡើងកំណែជាក់លាក់នៃ Node.JS នៅលើម៉ាស៊ីននោះទេ។

FROM node:12.10.0-alpine

RUN npm install yarn -g

រូបភាពបង្កើតនេះគឺសមរម្យសម្រាប់កម្មវិធី Node.JS ភាគច្រើន។ ចុះបើជាឧទាហរណ៍ អ្នកត្រូវការរូបភាពសម្រាប់គម្រោង JVM ដែលមានម៉ាស៊ីនស្កេន Sonar រួមបញ្ចូលនៅខាងក្នុង? អ្នកមានសេរីភាពក្នុងការជ្រើសរើសសមាសធាតុដែលអ្នកត្រូវការសម្រាប់ការជួបប្រជុំគ្នា។

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/

យើងបានពិពណ៌នាអំពីបរិយាកាសនៃការជួបប្រជុំគ្នា ប៉ុន្តែតើ Jenkins ត្រូវធ្វើអ្វីជាមួយវា? ហើយភ្នាក់ងារ Jenkins អាចធ្វើការជាមួយរូបភាព Docker និងបង្កើតវានៅខាងក្នុង។

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

សេចក្តីណែនាំ agent ប្រើប្រាស់ទ្រព្យសម្បត្តិ dockerកន្លែងដែលអ្នកអាចបញ្ជាក់៖

• ឈ្មោះរបស់កុងតឺន័រដំឡើងតាមគោលការណ៍ដាក់ឈ្មោះរបស់អ្នក;
• អាគុយម៉ង់ដែលត្រូវការដើម្បីដំណើរការ build container ដែលក្នុងករណីរបស់យើង យើងម៉ោនថតបច្ចុប្បន្នជាថតនៅខាងក្នុងកុងតឺន័រ។

ហើយនៅក្នុងជំហានសាងសង់រួចហើយ យើងចង្អុលបង្ហាញថាពាក្យបញ្ជាណាដែលត្រូវប្រតិបត្តិនៅខាងក្នុង Docker build agent។ នេះអាចជាអ្វីក៏បាន ដូច្នេះខ្ញុំក៏ចាប់ផ្តើមការដាក់ឱ្យប្រើប្រាស់កម្មវិធីដោយប្រើ ansible ។

ខាងក្រោមនេះខ្ញុំចង់បង្ហាញឯកសារ Jenkins ទូទៅដែលកម្មវិធី Node.JS សាមញ្ញអាចបង្កើតបាន។

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

}

តើមានអ្វីកើតឡើង?

សូមអរគុណចំពោះវិធីសាស្ត្រនេះ យើងបានដោះស្រាយបញ្ហាដូចខាងក្រោមៈ

• ពេលវេលាកំណត់រចនាសម្ព័ន្ធការប្រមូលផ្តុំបរិស្ថានត្រូវបានកាត់បន្ថយមកត្រឹម 10 - 15 នាទីក្នុងមួយគម្រោង។
• បរិស្ថានបង្កើតកម្មវិធីដែលអាចធ្វើម្តងទៀតបានទាំងស្រុង ចាប់តាំងពីអ្នកអាចបង្កើតវាតាមវិធីនេះនៅលើកុំព្យូទ័រក្នុងតំបន់របស់អ្នក។
• មិនមានបញ្ហាជាមួយនឹងការប៉ះទង្គិចរវាងកំណែផ្សេងគ្នានៃឧបករណ៍ជួបប្រជុំគ្នា;
• តែងតែជាកន្លែងធ្វើការស្អាត ដែលមិនមានការស្ទះ។

ដំណោះស្រាយដោយខ្លួនវាគឺសាមញ្ញ និងជាក់ស្តែង ហើយអនុញ្ញាតឱ្យអ្នកទទួលបានអត្ថប្រយោជន៍មួយចំនួន។ បាទ កម្រិតចូលបានកើនឡើងបន្តិចបើប្រៀបធៀបទៅនឹងពាក្យបញ្ជាសាមញ្ញសម្រាប់ការជួបប្រជុំគ្នា ប៉ុន្តែឥឡូវនេះមានការធានាថាវានឹងត្រូវបានសាងសង់ជានិច្ច ហើយអ្នកអភិវឌ្ឍន៍ខ្លួនឯងអាចជ្រើសរើសអ្វីគ្រប់យ៉ាងដែលចាំបាច់សម្រាប់ដំណើរការសាងសង់របស់គាត់។

អ្នកក៏អាចប្រើរូបភាពដែលខ្ញុំបានប្រមូលបានផងដែរ។ Jenkins + Docker. ប្រភពទាំងអស់ត្រូវបានបើកនិងមានទីតាំងនៅ rmuhamedgaliev/jenkins_docker.

ពេលកំពុងសរសេរអត្ថបទនេះ ការពិភាក្សាមួយបានកើតឡើងអំពីការប្រើប្រាស់ភ្នាក់ងារនៅលើម៉ាស៊ីនមេពីចម្ងាយ ដើម្បីកុំឱ្យផ្ទុកថ្នាំងមេដោយប្រើកម្មវិធីជំនួយ docker-plugin. ប៉ុន្តែខ្ញុំនឹងនិយាយអំពីរឿងនេះនៅពេលអនាគត។

ប្រភព: www.habr.com