توسعه را با خطوط لوله جنکینز و ادغام مداوم بهینه کنید

توسعه و انتشار نسخه‌های نرم‌افزار جدید یک فرآیند مداوم است که نیازمند توجه دقیق به جزئیات است. داشتن توانایی ردیابی و تجزیه و تحلیل کل فرآیند، حتی به صورت گذشته نگر، برای شناسایی هرگونه مشکل و انجام اقدامات اصلاحی ضروری است.

اینجاست که مفهوم ادغام پیوسته به چشم می خورد.

با اتخاذ رویکرد یکپارچه سازی مستمر، می توانیم به طور موثر مراحل مختلف فرآیند توسعه نرم افزار را رصد کرده و نتایج را تجزیه و تحلیل کنیم. این به ما کمک می کند تا هر گونه مشکل بالقوه را شناسایی کنیم، آنها را تجزیه و تحلیل کنیم و تنظیمات لازم را برای بهبود روند توسعه کلی انجام دهیم.

در این پست وبلاگ، مفهوم یکپارچه سازی مداوم و مزایای آن را بررسی خواهیم کرد. ما در مورد چگونگی دستیابی به یکپارچگی مداوم با استفاده از Jenkins بحث خواهیم کرد و بینشی در مورد اینکه چگونه این رویکرد می تواند به شما در ساده سازی فرآیند توسعه نرم افزار کمک کند، ارائه خواهیم داد.

آیا می خواهید آموزش تمرینی در مورد ادغام مداوم و جنکینز انجام دهید؟
از شما دعوت شده است که نگاهی به دوره ای که من ایجاد کرده ام بیاندازید، جایی که با راهنمایی من یک خط لوله کامل در AWS بر اساس اصول SDLC می نویسید.
یکپارچه سازی مداوم و خطوط لوله جنکینز در AWS

چه چیزی باعث ادغام مداوم از دیدگاه تیم توسعه می شود؟

تیم توسعه با فشار دادن تغییرات کد به مخزن کد، یکپارچگی مداوم را آغاز می کند. این اقدام یک خط لوله خودکار را راه‌اندازی می‌کند که نسخه نرم‌افزار به‌روز شده را می‌سازد، آزمایش می‌کند و به کار می‌گیرد.

مفهوم گردش کار ساختاریافته ایجاد نظم استاندارد شده ای از عملیات است که توسعه دهندگان بر آن توافق دارند و آنها را قادر می سازد تا اطمینان حاصل کنند که نسخه های بعدی آنها مطابق با چرخه عمر توسعه نرم افزار (SDLC) تعریف شده توسط مدیریت ساخته شده است. اکنون برخی از مزایای اصلی ادغام پیوسته را بررسی می کنیم:

تاریخچه نسخه – توسعه دهندگان به راحتی می توانند نسخه های تولیدی خود را ردیابی کنند و عملکرد نسخه های مختلف را در طول توسعه مقایسه کنند. علاوه بر این، آنها می توانند در صورت بروز هرگونه مشکل تولید، به سرعت به نسخه قبلی برگردند.

تست کیفیت – توسعه‌دهندگان می‌توانند نسخه‌های خود را روی یک محیط مرحله‌بندی آزمایش کنند تا نشان دهند که نسخه جدید چگونه در محیطی مشابه تولید عمل می‌کند. آنها می توانند به جای اجرای نسخه بر روی ماشین محلی خود، که ممکن است با محیط واقعی قابل مقایسه نباشد، مجموعه ای از تست ها را تعریف کنند، مانند تست های واحد، تست های یکپارچه سازی و موارد دیگر، که نسخه جدید خود را از طریق یک گردش کار از پیش تعریف شده طی می کند. این فرآیند تست به عنوان امضای آنها عمل می کند و اطمینان حاصل می کند که نسخه جدید برای استقرار در یک محیط تولید ایمن است.

شروع برنامه – توسعه‌دهندگان دیگر نیازی به راه‌اندازی دستی خط لوله خود یا تعریف خط لوله جدید برای هر پروژه جدید ندارند. به عنوان یک تیم DevOps، مسئولیت ما ایجاد یک سیستم قوی است که خط لوله خود را به هر پروژه متصل کند. خواه یک خط لوله معمولی با تغییرات جزئی برای مطابقت با پروژه یا همان خط لوله باشد، توسعه دهندگان می توانند روی نوشتن کد تمرکز کنند در حالی که ادغام مداوم بقیه موارد را انجام می دهد. برنامه ریزی یک راه اندازی خودکار، به عنوان مثال، هر روز صبح یا عصر، تضمین می کند که کد فعلی در Github همیشه برای انتشار آماده است.

جنکینز در عصر ادغام مستمر

برای دستیابی به جریان کاری خط لوله مورد نظر، جنکینز را مستقر می کنیم و خط لوله جامعی ایجاد می کنیم که کنترل نسخه، آزمایش خودکار و راه اندازی ها را در اولویت قرار می دهد.

پیش نیازها:

• ماشین مجازی با موتور داکر

جنکینز را کانتینری کنید
ما جنکینز را در یک کانتینر داکر مستقر خواهیم کرد تا استقرار خطوط لوله CI/CD خود را ساده کنیم.

بیایید جنکینز را مستقر کنیم:

docker run -d \
        --name jenkins -p 8080:8080 -u root -p 50000:50000 \
        -v /var/run/docker.sock:/var/run/docker.sock \
        naturalett/jenkins:2.387-jdk11-hello-world

اعتبار کانتینر جنکینز:

docker ps | grep -i jenkins

رمز عبور اولیه جنکینز را بازیابی کنید:

docker exec jenkins bash -c -- 'cat /var/jenkins_home/secrets/initialAdminPassword'

در لوکال هاست به جنکینز متصل شوید

ساخت یک خط لوله یکپارچه سازی پیوسته

من استفاده از Groovy را در خطوط لوله جنکینز انتخاب کردم زیرا چندین مزیت را ارائه می دهد:

• Groovy یک زبان برنامه نویسی است که یادگیری و استفاده از آن آسان است
• Groovy ویژگی هایی را برای نوشتن کد مختصر، خوانا و قابل نگهداری ارائه می دهد
• سینتکس Groovy شبیه جاوا است و استفاده از آن را برای توسعه دهندگان جاوا آسان تر می کند
• Groovy پشتیبانی بسیار خوبی برای کار با فرمت های داده ای دارد که معمولاً در توسعه نرم افزار استفاده می شود
• Groovy یک راه کارآمد و موثر برای ایجاد خطوط لوله CI/CD قوی و انعطاف پذیر در Jenkins ارائه می دهد. خط لوله ما از چهار فاز تشکیل شده است:

فاز 1 – عامل

برای اطمینان از اینکه کد همانطور که انتظار می رود بدون وابستگی ناسازگار ساخته می شود، هر خط لوله به یک محیط مجازی نیاز دارد. ما در مرحله زیر یک عامل (محیط مجازی) را در ظرف Docker ایجاد می کنیم. از آنجایی که جنکینز در یک کانتینر داکر نیز اجرا می شود، سوکت داکر را برای فعال کردن اجرای عامل نصب می کنیم.

pipeline {
    agent {
        docker {
            image 'docker:19.03.12'
            args '-v /var/run/docker.sock:/var/run/docker.sock'
        }
    }
...
...
...
}

فاز 2- تاریخچه نسخه ها

نسخه‌سازی یک عمل ضروری است که به توسعه‌دهندگان اجازه می‌دهد تا تغییرات کد خود را ردیابی کنند و عملکرد نرم‌افزار را با هم مقایسه کنند، و به آنها امکان می‌دهد درباره بازگشت به نسخه قبلی یا انتشار نسخه جدید تصمیم‌گیری آگاهانه بگیرند. در مرحله بعد، یک تصویر Docker از کد خود ایجاد می کنیم و بر اساس مجموعه ای از تعاریف از پیش تعیین شده به آن تگ اختصاص می دهیم.

به عنوان مثال: تاریخ – شماره ساخت جنکینز – Commit Hash

pipeline {
    agent {
...
    }
    stages {
        stage('Build') {
            steps {
                script {
                  def currentDate = new java.text.SimpleDateFormat("MM-dd-yyyy").format(new Date())
                  def shortCommit = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
                  customImage = docker.build("naturalett/hello-world:${currentDate}-${env.BUILD_ID}-${shortCommit}")
                }
            }
        }
    }
}

پس از تکمیل فاز قبلی، یک تصویر Docker از کد ما ایجاد شد و اکنون می‌توان در محیط محلی ما به آن دسترسی داشت.

docker image | grep -i hello-world

مرحله 3- آزمون

آزمایش یک گام مهم برای اطمینان از اینکه نسخه جدید نسخه جدید تمام تست های عملکردی و الزامات را برآورده می کند، یک مرحله مهم است. در مرحله بعد، آزمایش هایی را بر روی تصویر Docker تولید شده در مرحله قبل انجام می دهیم که حاوی پتانسیل انتشار بعدی است.

pipeline {
    agent {
...
    }
    stages {
        stage('Test') {
            steps {
                script {
                    customImage.inside {
                        sh """#!/bin/bash
                        cd /app
                        pytest test_*.py -v --junitxml="test-results.xml""""
                    }
                }
            }
        }
    }
}

فاز 4- محرک زمانبندی

خودکار کردن راه‌انداز خط لوله به توسعه‌دهندگان اجازه می‌دهد تا روی کدنویسی تمرکز کنند و در عین حال ثبات و آمادگی برای نسخه بعدی را تضمین کنند. برای رسیدن به این هدف، یک برنامه صبحگاهی تعریف می کنیم که با شروع روز تیم توسعه، خط لوله را به طور خودکار راه اندازی می کند.

pipeline {
    agent {
...
    }
    triggers {
        // https://crontab.guru
        cron '00 7 * * *'
    }
    stages {
...
    }
}

خط لوله سرتاسر فرآیند
برای اجرای خط لوله خود، یک خط لوله از پیش تعریف شده را در جنکینز قرار داده ایم. برای شروع، به سادگی کار جنکینز “خط لوله من” را آغاز کنید.

• عامل – یک محیط مجازی است که برای خط لوله استفاده می شود
• ماشه – برای برنامه ریزی خودکار در خط لوله استفاده می شود
• مرحله کلون – مسئولیت شبیه سازی مخزن پروژه را بر عهده دارد
• مرحله ساخت – شامل ایجاد تصویر Docker برای پروژه برای دسترسی به آخرین commit و سایر ویژگی های Git است، ما بسته Git را نصب می کنیم
• مرحله آزمایش – شامل انجام آزمایشات روی تصویر داکر ما است

pipeline {
    agent {
        docker {
            image 'docker:19.03.12'
            args '-v /var/run/docker.sock:/var/run/docker.sock'
        }
    }
    triggers {
        // https://crontab.guru
        cron '00 7 * * *'
    }
    stages {
        stage('Clone') {
            steps {
                git branch: 'main', url: 'https://github.com/naturalett/hello-world.git'
            }
        }
        stage('Build') {
            steps {
                script {
                  sh 'apk add git'
                  def currentDate = new java.text.SimpleDateFormat("MM-dd-yyyy").format(new Date())
                  def shortCommit = sh(returnStdout: true, script: "git log -n 1 --pretty=format:'%h'").trim()
                  customImage = docker.build("naturalett/hello-world:${currentDate}-${env.BUILD_ID}-${shortCommit}")
                }
            }
        }
        stage('Test') {
            steps {
                script {
                    customImage.inside {
                        sh """#!/bin/bash
                        cd /app
                        pytest test_*.py -v --junitxml="test-results.xml""""
                    }
                }
            }
        }
    }
}

خلاصه کنید
ما درک درستی از نحوه ادغام پیوسته در کار روزانه ما و همچنین برخی از گردش‌های کاری خط لوله کلیدی که دست اول امتحان کرده‌ایم، به دست آورده‌ایم.

اگر علاقه مند به بررسی بیشتر سناریوهای مختلف خط لوله و یادگیری مهارت های عملی تولید برای اجرای یکپارچگی مداوم در کار خود هستید، دوره من را بررسی کنید:

تسلط عملی بر DevOps – CI و Jenkins Container Pipelines