Գնահատել նախագիծը
← Բոլոր հրապարակումները

DevOps ներկառուցված համակարգերի մշակման մեջ. ծրագրային և սարքային մասերի կապը

Այս հոդվածում շատ բան քննարկեցինք ներկառուցված համակարգերի մշակման DevOps-ի մասին։ Մենք հիմք դրեցինք՝ ցույց տալով, թե ինչպես այնպիսի գործիքներ, ինչպիսիք են Docker-ը, QEMU-ն, GitHub Actions-ը և Terraform-ը, կարող են կառուցվածք և ավտոմատացում բերել աշխատանքային հոսքին։

9 րոպե
DevOpsDockerՆերկառուցված համակարգերի մշակումGitHub Actions

Ներկառուցված համակարգերը վաղուց դիտվում են որպես հիմնական ծրագրային մշակումից առանձին աշխարհ, որը սովորաբար բնութագրվում է ձեռքով գործընթացներով, բարդ սարքային կախվածություններով և երկար թողարկման ցիկլերով։ Սակայն երբ ներկառուցված համակարգերը գնալով ավելի բարդ և փոխկապակցված են դառնում, DevOps-ի սկզբունքները՝ ավտոմատացման, համագործակցության և շարունակական մատակարարման իրենց շեշտադրմամբ, պարզվում է, որ ոչ միայն օգտակար են, այլև անփոխարինելի։

Այս հոդվածը հիմնված է Embedded Israel meetup-ում իմ առցանց ելույթի գաղափարների վրա։

Ինչու՞ DevOps ներկառուցվածի համար

Այն, ինչ DevOps-ը հիմնարար առումով խոստանում է՝ ավելի արագ հետադարձ կապի ցիկլեր, ավտոմատացված pipeline-ներ և ավելի մեծ հուսալիություն, ներկառուցված համակարգերի մշակման մեջ էլ ավելի կարևոր է։ Ի տարբերություն վեբ կամ մոբայլ հավելվածների՝ ներկառուցված համակարգերը ուղղակիորեն շփվում են ֆիզիկական սարքավորման հետ, ինչը բերում է իր առանձնահատուկ բարդությունները։ Firmware-ը ձեռքով թողարկելը, մալուխները միացնելն ու անջատելը և ֆիզիկական տախտակների վրա հետաձգված թեստավորումը կարող են զգալիորեն դանդաղեցնել մշակումը։

DevOps-ի ընդունումը թույլ է տալիս ավտոմատացնել այս ավանդաբար ձեռքով քայլերից շատերը։ Սա նշանակում է.

  • Ավելի արագ իտերացիա. կառուցել մեկ անգամ, թեստավորել հաճախ և ստանալ արագ հետադարձ կապ ոչ միայն կոդի փոփոխությունների, այլև այն մասին, թե սարքն իրականում ինչպես է վարվում։
  • Խնդիրների վաղ հայտնաբերում. գտնել խնդիրները մշակման ցիկլի սկզբում՝ նվազեցնելով դրանք հետագայում շտկելու արժեքն ու ջանքը։
  • Ավելի մեծ հուսալիություն և մասշտաբավորելիություն. ավտոմատացված թեստավորումն ու տեղակայումը հանգեցնում են ավելի կայուն արտադրանքի և թույլ են տալիս թիմերին ստանձնել ավելի մեծ, ավելի բարդ նախագծեր։

Առանձնահատուկ մարտահրավերների հաղթահարում

Առավելությունները ակնհայտ են, բայց ներկառուցված DevOps-ը բերում է նաև մարտահրավերների առանձնահատուկ շարք, որոնք պետք է լուծել.

  • Սարքային և ծրագրային մասերի ինտեգրում. կոդը պետք է անթերի աշխատի կոնկրետ սարքավորման հետ, ինչը դժվարացնում է սիմուլյացիան և ավտոմատացված թեստավորումը։
  • Սուղ ռեսուրսներ. միկրոկոնտրոլերները հաճախ խիստ սահմանափակ են պրոցեսորով, RAM-ով և պահոցով, ինչը պահանջում է օպտիմալացված կոդ և արդյունավետ toolchain-եր։
  • Իրական ժամանակի պահանջներ. ներկառուցված համակարգերից շատերը ենթակա են խիստ ժամանակային սահմանափակումների, և շարունակական ինտեգրման ու տեղակայման (CI/CD) կարգավորումները պետք է օգնեն դրանք ստուգել։
  • Անվտանգություն և հուսալիություն. կարևոր ոլորտներում, ինչպիսիք են ավտոմոբիլային կամ բժշկական, մանրակրկիտ թեստավորումն ու սերտիֆիկացումը առաջնային են։
  • Բազմազան սարքային հարթակներ. թիմերը հաճախ գործ ունեն մի քանի սարքային հարթակների հետ, որոնցից յուրաքանչյուրն ունի իր toolchain-երն ու վրիպազերծման ընթացակարգերը։

Հիմքի դրում. toolchain-ի և միջավայրի կառավարում

Build միջավայրը ինչպես կառավարելու որոշումը ներկառուցված աշխատանքային հոսքի առաջին հիմնական ընտրություններից է։

Native և վիրտուալացված build-եր

Փոքր նախագծերի համար native build-երը պարզ են, բայց միջավայրի շեղումը (drift) կարող է առաջացնել «իմ մեքենայի վրա աշխատում է» խնդիրներ։ Վիրտուալացված build-երը, մասնավորապես Docker-ի վրա հիմնվածները, ապահովում են համահունչ, վերարտադրելի միջավայր՝ ամրագրելով կոմպիլյատորի տարբերակները, կախվածությունները և build սկրիպտները։ Այսպիսի կայունությունը էական է CI/CD-ի և համատեղ մշակման համար։

Cross-compilation և static linking

Քանի որ ներկառուցված սարքերը հաճախ չունեն կոդը ինքնուրույն կոմպիլացնելու ռեսուրսներ, cross-compilation-ը էական է։ Կոդը կոմպիլացվում է ավելի հզոր host մեքենայի վրա՝ թիրախային ներկառուցված ճարտարապետության համար։ Բազմաթիվ մատակարարներ տրամադրում են պաշտոնական toolchain-եր, օրինակ՝ Espressif-ի ESP-IDF-ը ESP32-ի համար կամ ARM կոմպիլյատորները STM32-ի համար Buildroot-ի կամ Yocto-ի միջոցով, ինչը գործընթացը դարձնում է ավելի սահուն։

Static linking-ը նույնպես տարածված է. յուրաքանչյուր անհրաժեշտ գրադարան կապվում է ուղղակիորեն վերջնական binary-ի մեջ։ Սա հեշտացնում է տեղակայումը, քանի որ բացակայող գրադարանների խնդիրները վերանում են, թեև binary-ները կարող են ավելի մեծ ստացվել։

Էմուլյացիա QEMU-ով

QEMU-ն աշխատում է որպես վիրտուալիզատոր, որը թույլ է տալիս մշակողներին էմուլյացնել ներկառուցված համակարգեր (օրինակ՝ Raspberry Pi կամ STM32) իրենց host մեքենայի վրա։ Սա չափազանց օգտակար է հետևյալի համար.

  • Վաղ մշակում. ծրագրային ապահովումը փորձարկել մինչև ֆիզիկական սարքավորման գոյությունը։
  • CI/CD ինտեգրում. վիրտուալ թեստային գործարկումներ կատարել CI pipeline-ի ներսում։

QEMU-ն, սակայն, ունի սահմանափակումներ, մասնավորապես պերիֆերիկ սարքերի աջակցության առումով (օրինակ՝ SPI, I2C սենսորներ, custom GPIO)։ Այդուհանդերձ, այն դեռևս հզոր միջոց է վաղ մշակումն ու CI-ը արագացնելու համար։

Docker. խաղը փոխող գործիք ներկառուցված համակարգերի մշակման համար

Եվ հիմա իմ սիրելի մասը. այս օրերին Docker-ը փոխակերպում է մշակման յուրաքանչյուր տեսակ, հիմնականում այն պատճառով, որ շտկում է մեր առջև ծառացող ամենախառնաշփոթ խնդիրներից մի քանիսը՝ անհամահունչ toolchain-եր, բախվող կախվածություններ և ցավոտ onboarding։

Ահա երեք եղանակ, որով այն հեշտացնում է գործը.

  • Վերարտադրելի toolchain միջավայր. Docker image-ները միավորում են կոմպիլյատորի, linker-ի և SDK-ի ճշգրիտ տարբերակները՝ պահելով յուրաքանչյուր մշակման միջավայրը համահունչ։
  • Մեկուսացված cross-compilation թիրախներ. թիմերը կարող են կառուցել առանձին Docker image-ներ տարբեր տախտակների կամ ճարտարապետությունների համար (օրինակ՝ STM32, ESP32), ինչը կանխում է toolchain-երի բախումները։
  • CI/CD ինտեգրում և ավելի արագ onboarding. Docker image-ները սահուն միանում են CI/CD հարթակներին, ինչպիսին GitHub Actions-ն է, և նորեկները կարող են արագ սկսել աշխատել՝ պատրաստի միջավայրի շնորհիվ։

CI/CD GitHub Actions-ով

Git պահոցների հետ իր սահուն ինտեգրման և իր ճկունության շնորհիվ GitHub Actions-ը հիանալի է համապատասխանում ներկառուցված նախագծերին։ Workflow-ները, որոնք գրվում են որպես YAML ֆայլեր .github/workflows դիրեկտորիայում, հնարավոր են դարձնում ավտոմատացված build-երը, cross-compilation-ը և թեստավորումը։ Դրանք նկարագրում են ավտոմատացված քայլերի հաջորդականություն, օրինակ՝ կոդի build, թեստավորում կամ տեղակայում, որոնք գործարկվում են այնպիսի իրադարձություններով, ինչպիսիք են push-երը, pull request-ները կամ ժամանակացույցերը։

Ներկառուցված workflow-ների համար ամենակարևոր հնարավորություններն են.

  • buildx. Docker CLI plugin, որը թույլ է տալիս Docker image-ներ կառուցել մի քանի ներկառուցված ճարտարապետությունների համար հենց pipeline-ի ներսում։
  • QEMU runner-ներ. թույլ են տալիս GitHub Actions-ին էմուլյացնել թիրախային պրոցեսորներ՝ հնարավոր դարձնելով նշանակալի թեստավորում առանց ֆիզիկական սարքավորման։

GitHub runner-ներ. հանրային և self-hosted

Workflow-ները ինքնուրույն չեն աշխատում. դրանց պետք են runner-ներ, այսինքն՝ վիրտուալ կամ ֆիզիկական մեքենաներ, որոնց վրա job-երը իրականում կատարվում են։

Runner-ները երկու տեսակ են. GitHub hosted runner-ներ և self hosted runner-ներ։

Երբ թեստավորումը պետք է փոխազդի ֆիզիկական սարքավորման հետ, self-hosted runner-ները էական են։ Դրանք մասշտաբավորելը նշանակում է մի քանի instance կարգավորել՝ գործողությունները միաժամանակ մշակելու համար։

Ներկառուցված CI-ի մասշտաբավորում. label-ներ և matrix build-եր

CI/CD workflow-ներն ավելի ճկուն և մասշտաբավորելի դարձնելու համար GitHub Actions-ն առաջարկում է առաջադեմ կոնֆիգուրացիայի ընտրանքներ, որոնք թույլ են տալիս թիմերին հարմարեցնել իրենց ավտոմատացումը բարդ սարքային և ծրագրային պահանջներին։ Երկու առանձնապես օգտակար ընտրանք են.

  • Runner label-ներ. self-hosted runner-ներին կարելի է տալ label-ներ (օրինակ՝ arm64, lcd-test, usb-flash)։ Այնուհետև workflow-ները կարող են այդ label-ներով ընտրել կոնկրետ runner-ներ՝ job-երը ուղարկելով ճիշտ սարքավորման։
name: Flash Firmware

on:
  workflow_dispatch:

jobs:
  flash:
    runs-on: [self-hosted, arm64, usb-flash]
    steps:
      - uses: actions/checkout@v3

      - name: Flash firmware to device
        run: |
          ./scripts/flash.sh
  • Matrix build-եր. այս հզոր հնարավորությունը զուգահեռ աշխատեցնում է build-ի մի քանի տարբերակ։ Matrix-ը կարելի է, օրինակ, կարգավորել՝ միաժամանակ կառուցելու firmware տարբեր տախտակների (օրինակ՝ STM32, ESP32) և ռեժիմների (օրինակ՝ debug, release) համար՝ կրճատելով թեստավորման ցիկլերը։
name: Build Firmware

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        board: [stm32, esp32]
        mode: [debug, release]
    steps:
      - uses: actions/checkout@v3

      - name: Build ${{ matrix.board }} firmware in ${{ matrix.mode }} mode
        run: |
          make BOARD=${{ matrix.board }} MODE=${{ matrix.mode }}

Ձեր ներկառուցված CI pipeline-ի օպտիմալացում

Լավ օպտիմալացված ներկառուցված CI pipeline-ը build է անում ավելի արդյունավետ և կրճատում է հետադարձ կապի ժամանակը, ինչը թույլ է տալիս ավելի արագ իտերացիա և ավելի լավ կոդի որակ։ Կենտրոնացեք ավելորդ քայլերը հեռացնելու, քեշավորումն օգտագործելու և առաջադրանքները, որտեղ հնարավոր է, զուգահեռ աշխատեցնելու վրա։

Դրա հետ մեկտեղ, համոզվեք, որ զգայուն տվյալները, ինչպիսիք են credentials-ը և API բանալիները, անվտանգ պահվում են environment փոփոխականներով կամ գաղտնիքների կառավարման գործիքներով։ Պարբերաբար ստուգեք ձեր pipeline-ը խոցելիությունների համար և հետևեք անվտանգության լավագույն պրակտիկաներին՝ հնարավոր խախտումներից խուսափելու համար։

Քեշավորում

Ներկառուցված toolchain-երը հակված են մեծ լինելու։ Toolchain-երի և build արդյունքների քեշավորումը կարող է զգալիորեն կրճատել build-ի ժամանակները՝ խուսափելով կրկնվող ներբեռնումներից և կոմպիլյացիայից։

Ստորև բերված են action cache-ով քեշավորման մի քանի օրինակ։

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Cache ARM GCC Toolchain
        uses: actions/cache@v4
        with:
          path: ~/.toolchains/gcc-arm-none-eabi
          key: ${{ runner.os }}-arm-gcc-${{ hashFiles('toolchain-install-script.sh') }}
          restore-keys: |
            ${{ runner.os }}-arm-gcc-

      - name: Install Toolchain
        run: ./toolchain-install-script.sh

Այստեղ սկրիպտը տեղադրում է ARM toolchain-ը միայն այն դեպքում, երբ այն արդեն քեշում չէ։ hashFiles-ի շնորհիվ քեշը անվավեր է դառնում ամեն անգամ, երբ սկրիպտը փոխվում է։

Կախվածությունների մաքրում

Ստուգեք pipeline-ները այն կախվածությունների համար, որոնք ձեզ պետք չեն, և տեղադրման ժամանակ փոխանցեք այնպիսի flag-եր, ինչպիսին no-install-recommends-ն է, որպեսզի կոնտեյներները փոքր մնան, իսկ build-երն ավելի արագ աշխատեն։

Անվտանգ pipeline-ներ

Զգայուն տվյալները (ստորագրման բանալիներ, token-ներ, Wi-Fi գաղտնաբառեր) վերաբերվեք որպես գաղտնիքների։ Credentials-ը կոդի մեջ հարդկոդ անելու փոխարեն հենվեք GitHub Actions-ի secrets-ի և permissions-ի վրա։ Ավելացրեք կոդի սկանավորման action-ներ՝ թաքնված բանալիները, հնացած գրադարանները և խոցելի GitHub Actions տարբերակները հայտնաբերելու համար։

Ահա թե ինչպես կարելի է գաղտնի բանալին օգտագործել ձեր GitHub Action-ում.

name: Secure Firmware Upload

on:
  push:
    branches: [main]

permissions:
  contents: read
  id-token: write

jobs:
  upload:
    runs-on: [self-hosted, usb-flash]

    steps:
      - uses: actions/checkout@v3

      - name: Decrypt firmware signing key
        run: |
          echo "${{ secrets.SIGNING_KEY }}" | gpg --batch --import
[...]

Վերջում, անվտանգության առումով, լավ գաղափար է ավելացնել GitHub Actions, որոնք սկանավորում են ձեր կոդը թաքնված բանալիների, հնացած գրադարանների և նույնիսկ GitHub Actions-ի այն տարբերակների համար, որոնք հնացել են և թարմացման կարիք ունեն։

Ստորև բերված օրինակը ցույց է տալիս, թե ինչպես վերլուծել ձեր կոդը Codeql action-ով։

security-scan:
    name: Code & Dependency Scan
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # GitHub's built-in code scanning with CodeQL
      - name: Initialize CodeQL
        uses: github/codeql-action/init@v3
        with:
          languages: cpp

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v3

Թեստավորման ռազմավարություններ. unit-ից մինչև սարքավորում

Ներկառուցված համակարգերի թեստավորումը ավելի հեռու է գնում, քան պարզապես կոդը կոմպիլացնելը։ Մենք սովորաբար թեստավորումը բաժանում ենք երեք մակարդակի՝ unit, integration և hardware-in-the-loop (HIL) թեստեր։

Unit թեստեր.

Դրանք աշխատում են host համակարգի վրա և կենտրոնանում են տրամաբանության ճշտության վրա։ Դրանք արագ են և շատ հեշտ ավտոմատացվող։

Integration թեստեր.

Դրանք միավորում են տարբեր մոդուլներ և կարող են cross-compile արվել՝ աշխատելու կա՛մ էմուլյատորների վրա, ինչպիսին QEMU-ն է, կա՛մ ուղղակիորեն թիրախային տախտակների վրա։

Hardware-in-the-Loop (HIL) թեստեր.

Այս մակարդակում կոդն աշխատում է իրական սարքավորման վրա։ HIL թեստավորումը պահանջում է ավելի բարդ կարգավորում, բայց DevOps-ի սկզբունքները կարող են ավտոմատացնել դրա էական մասերը, ինչպիսիք են սարքերի flash անելը, թեստերի գործարկումը և արդյունքների հավաքումը։ Այն հաճախ պահանջում է ֆիզիկական կապ թիրախային տախտակի և self-hosted CI runner-ի միջև, սովորաբար USB-ի, UART-ի կամ GPIO-ի միջոցով։ Կախված այն բանից, թե թեստերին ինչ է պետք, կարող են անհրաժեշտ լինել լրացուցիչ բաղադրիչներ, ինչպիսիք են ռելեները, չափիչ սարքերը կամ նույնիսկ տեսախցիկները (էկրանի ելքը թեստավորելու համար)։

Այսպիսով, թեև DevOps գործիքները թեստավորման աշխատանքային հոսքը սահուն են դարձնում, հիմքում ընկած ենթակառուցվածքն ու մալուխավորումը միշտ պետք է կառուցվեն և սպասարկվեն։ Երբ դա արված է, այս հիմքը թույլ է տալիս հզոր, կրկնվող թեստավորում հենց այն սարքավորման վրա, որն օգտագործելու են ձեր հաճախորդները։

Infrastructure as Code (IaC)

Ենթակառուցվածքը (օրինակ՝ ամպային ռեսուրսները, CI/CD միջավայրերը) որպես կոդ նկարագրելը այնպիսի գործիքներով, ինչպիսիք են Terraform-ը կամ Pulumi-ն, բերում է բազմաթիվ օգուտներ։

Դեկլարատիվ գործիքները երաշխավորում են, որ ենթակառուցվածքը միշտ ստեղծվում է նույն կերպ՝ վերացնելով մարդկային սխալը, որն ուղեկցում է ամպային ռեսուրսները ձեռքով ստեղծելուն։ Սա նաև պարզեցնում է կարգավորումը. ամպային ռեսուրսները ինչպես կարգավորել մտածելու փոխարեն դուք պարզապես հայտարարում եք դրանք և տրամադրում անհրաժեշտ պարամետրերը, ինչպիսիք են անունները, հասցեների տիրույթները կամ չափերը։

Ձեր թիրախային ենթակառուցվածքը Terraform-ով նկարագրելը և առաջին միջավայրը կարգավորելը կարող է որոշ ժամանակ խլել, բայց յուրաքանչյուր հաջորդ միջավայր կստեղծվի շատ ավելի արագ։ Ավելին՝ Infrastructure as Code-ով (IaC) նկարագրված բոլոր միջավայրերում փոփոխություն տարածելը կպահանջի ընդամենը մեկ մոդուլի փոփոխություն և Terraform կոդի կիրառում։

Ամփոփում

Այս հոդվածում շատ բան քննարկեցինք ներկառուցված համակարգերի մշակման DevOps-ի մասին, և այնուամենայնիվ հազիվ մակերեսին ենք դիպել։ Թեման խորն է՝ ընդգրկելով ծրագրային ապահովումը, սարքավորումը, ենթակառուցվածքը, թեստավորումը, տեղակայումը և անվտանգությունը։ Մենք հիմք դրեցինք՝ ցույց տալով, թե ինչպես այնպիսի գործիքներ, ինչպիսիք են Docker-ը, QEMU-ն, GitHub Actions-ը և Terraform-ը, կարող են կառուցվածք և ավտոմատացում բերել աշխատանքային հոսքին։ Նպատակը ոչ միայն մշակումն արագացնելն է, այլ նաև վերարտադրելիությունը, մասշտաբավորելիությունը և հուսալիությունը բարելավելը, նույնիսկ երբ ցիկլում իրական սարքավորում կա։

Այս պրակտիկաների ներդրումը ժամանակ և կարգապահություն է պահանջում, բայց երկարաժամկետ հեռանկարում դրանք մեծ առավելություն են տալիս ձեր թիմին, ձեր արտադրանքի որակին և ձեր հաճախորդներին։ Մենք տեսանք, թե ինչ կարող է անել DevOps-ը. հիմա ժամանակն է գործելու։ Կարիք չկա միանգամից վերակառուցել ձեր ամբողջ գործընթացը։ Սկսեք փոքր քայլերով. օրինակ՝ ձեր toolchain-ը դրեք Docker-ի մեջ կամ ստեղծեք հիմնական GitHub workflow։ Կենտրոնացեք վերարտադրելիության և հետադարձ կապի վրա և սարքավորումը ձեր pipeline-ի մեջ ներառեք առաջին օրվանից՝ այն հետո մտածված բանի պես վերաբերվելու փոխարեն։

Ամենից առաջ՝ մի գնացեք այս ճանապարհով միայնակ։ Կիսվեք ձեր կարգավորումներով, գրեք ներքին փաստաթղթեր և նպաստեք գործիքակազմին։ Որքան հեշտացնենք ներկառուցված DevOps-ի ընդունումը, այնքան ավելի ուժեղ կդառնան մեր թիմերն ու արտադրանքները։ Այն այլևս nice-to-have չէ. դա մրցակցային անհրաժեշտություն է։