ការប្រើប្រាស់ docker multi-stage ដើម្បីបង្កើតរូបភាព windows

សួស្តី​អ្នក​ទាំងអស់គ្នា! ខ្ញុំឈ្មោះ Andrey ហើយខ្ញុំធ្វើការជាវិស្វករ DevOps នៅ Exness ក្នុងក្រុមអភិវឌ្ឍន៍។ សកម្មភាពចម្បងរបស់ខ្ញុំគឺទាក់ទងនឹងការកសាង ការដាក់ពង្រាយ និងគាំទ្រកម្មវិធីនៅក្នុង docker ក្រោមប្រព័ន្ធប្រតិបត្តិការលីនុច (ហៅកាត់ថា OS)។ មិនយូរប៉ុន្មាន ខ្ញុំមានកិច្ចការដែលមានសកម្មភាពដូចគ្នា ប៉ុន្តែ OS គោលដៅនៃគម្រោងគឺ Windows Server និងសំណុំនៃគម្រោង C++ ។ សម្រាប់ខ្ញុំ នេះគឺជាអន្តរកម្មជិតស្និទ្ធលើកដំបូងជាមួយ docker containers នៅក្រោម Windows OS ហើយជាទូទៅជាមួយនឹងកម្មវិធី C++ ។ អរគុណចំពោះបញ្ហានេះ ខ្ញុំមានបទពិសោធន៍គួរឱ្យចាប់អារម្មណ៍មួយ ហើយបានសិក្សាអំពីភាពស្មុគ្រស្មាញមួយចំនួននៃកម្មវិធីផ្ទុកក្នុង Windows ។

នៅក្នុងអត្ថបទនេះ ខ្ញុំចង់ប្រាប់អ្នកពីការលំបាកដែលខ្ញុំត្រូវប្រឈមមុខ និងរបៀបដែលខ្ញុំគ្រប់គ្រងដើម្បីដោះស្រាយពួកគេ។ ខ្ញុំសង្ឃឹមថាវាមានប្រយោជន៍សម្រាប់បញ្ហាប្រឈមនាពេលបច្ចុប្បន្ន និងអនាគតរបស់អ្នក។ សូមរីករាយអាន!

ហេតុអ្វីបានជាធុង?

ក្រុមហ៊ុនមានហេដ្ឋារចនាសម្ព័ន្ធដែលមានស្រាប់សម្រាប់ក្រុមតន្រ្តីកុងតឺន័រ Hashicorp Nomad និងសមាសធាតុពាក់ព័ន្ធ - កុងស៊ុល និងតុដេក។ ដូច្នេះ ការ​ដាក់​កុងតឺន័រ​កម្មវិធី​ត្រូវ​បាន​ជ្រើសរើស​ជា​វិធីសាស្ត្រ​បង្រួបបង្រួម​សម្រាប់​ការ​ផ្តល់​ដំណោះស្រាយ​ពេញលេញ។ ដោយសារហេដ្ឋារចនាសម្ព័ន្ធរបស់គម្រោងមាន docker hosts ជាមួយ Windows Server Core OS កំណែ 1803 និង 1809 វាចាំបាច់ត្រូវបង្កើតកំណែដាច់ដោយឡែកនៃរូបភាព docker សម្រាប់ 1803 និង 1809។ នៅក្នុងកំណែ 1803 វាជាការសំខាន់ដែលត្រូវចងចាំថាលេខកែប្រែនៃ build docker host ត្រូវតែផ្គូផ្គងលេខកែប្រែនៃរូបភាព docker មូលដ្ឋាន និងម៉ាស៊ីនដែលកុងតឺន័រពីរូបភាពនេះនឹងត្រូវបានដាក់ឱ្យដំណើរការ។ កំណែ 1809 មិនមានគុណវិបត្តិបែបនេះទេ។ អ្នកអាចអានបន្ថែម នៅទីនេះ.

ហេតុអ្វីបានជាពហុដំណាក់កាល?

វិស្វករក្រុមអភិវឌ្ឍន៍មិនមាន ឬមានកម្រិតខ្លាំងក្នុងការចូលដំណើរការបង្កើតម៉ាស៊ីនទេ វាមិនមានវិធីដើម្បីគ្រប់គ្រងសំណុំនៃសមាសធាតុសម្រាប់បង្កើតកម្មវិធីនៅលើម៉ាស៊ីនទាំងនេះបានឆាប់រហ័សទេ ឧទាហរណ៍ ដំឡើងឧបករណ៍បន្ថែម ឬបន្ទុកការងារសម្រាប់ Visual Studio ជាដើម។ ដូច្នេះហើយ យើងបានសម្រេចចិត្តដំឡើងសមាសធាតុទាំងអស់ដែលចាំបាច់សម្រាប់បង្កើតកម្មវិធីទៅក្នុង build Docker image។ បើចាំបាច់ អ្នកអាចផ្លាស់ប្តូរតែឯកសារ dockerfile ហើយបើកដំណើរការបំពង់សម្រាប់បង្កើតរូបភាពនេះ។

ពីទ្រឹស្តីទៅសកម្មភាព

នៅក្នុងការស្ថាបនារូបភាពពហុដំណាក់កាល Docker ដ៏ល្អ បរិយាកាសសម្រាប់បង្កើតកម្មវិធីត្រូវបានរៀបចំក្នុងស្គ្រីប Dockerfile ដូចគ្នានៅពេលដែលកម្មវិធីខ្លួនវាត្រូវបានបង្កើតឡើង។ ប៉ុន្តែនៅក្នុងករណីរបស់យើង តំណភ្ជាប់កម្រិតមធ្យមមួយត្រូវបានបន្ថែម ពោលគឺជំហាននៃការបង្កើតរូបភាព docker បឋមជាមួយនឹងអ្វីគ្រប់យ៉ាងដែលចាំបាច់សម្រាប់បង្កើតកម្មវិធី។ នេះត្រូវបានធ្វើដោយសារតែខ្ញុំចង់ប្រើមុខងារ docker cache ដើម្បីកាត់បន្ថយពេលវេលាដំឡើងនៃរាល់ភាពអាស្រ័យទាំងអស់។

សូមក្រឡេកមើលចំណុចសំខាន់ៗនៃស្គ្រីប dockerfile សម្រាប់ការបង្កើតរូបភាពនេះ។

ដើម្បីបង្កើតរូបភាពនៃកំណែ OS ផ្សេងៗគ្នា អ្នកអាចកំណត់អាគុយម៉ង់មួយនៅក្នុង dockerfile ដែលលេខកំណែត្រូវបានឆ្លងកាត់កំឡុងពេលបង្កើត ហើយវាក៏ជាស្លាកនៃរូបភាពមូលដ្ឋានផងដែរ។

បញ្ជីពេញលេញនៃស្លាករូបភាពម៉ាស៊ីនមេ Microsoft Windows អាចត្រូវបានរកឃើញ នៅទីនេះ.

ARG WINDOWS_OS_VERSION=1809
FROM mcr.microsoft.com/windows/servercore:$WINDOWS_OS_VERSION

តាមលំនាំដើមពាក្យបញ្ជានៅក្នុងការណែនាំ RUN នៅខាងក្នុង dockerfile នៅលើ Windows OS ពួកគេត្រូវបានប្រតិបត្តិនៅក្នុងកុងសូល cmd.exe ។ ដើម្បីភាពងាយស្រួលនៃការសរសេរស្គ្រីប និងពង្រីកមុខងារនៃពាក្យបញ្ជាដែលបានប្រើ យើងនឹងកំណត់ឡើងវិញនូវកុងសូលប្រតិបត្តិពាក្យបញ្ជានៅក្នុង Powershell តាមរយៈការណែនាំ SHELL.

SHELL ["powershell", "-Command", "$ErrorActionPreference = 'Stop';"]

ជំហានបន្ទាប់គឺត្រូវដំឡើងកម្មវិធីគ្រប់គ្រងកញ្ចប់សូកូឡា និងកញ្ចប់ចាំបាច់៖

COPY chocolatey.pkg.config .
RUN Set-ExecutionPolicy Bypass -Scope Process -Force ;
    [System.Net.ServicePointManager]::SecurityProtocol = 
    [System.Net.ServicePointManager]::SecurityProtocol -bor 3072 ;
    $env:chocolateyUseWindowsCompression = 'true' ;
    iex ((New-Object System.Net.WebClient).DownloadString( 
      'https://chocolatey.org/install.ps1')) ;
    choco install chocolatey.pkg.config -y --ignore-detected-reboot ;
    if ( @(0, 1605, 1614, 1641, 3010) -contains $LASTEXITCODE ) { 
      refreshenv; } else { exit $LASTEXITCODE; } ;
    Remove-Item 'chocolatey.pkg.config'

ដើម្បីដំឡើងកញ្ចប់ដោយប្រើសូកូឡា អ្នកគ្រាន់តែអាចហុចពួកវាជាបញ្ជីមួយ ឬដំឡើងវាម្តងមួយៗ ប្រសិនបើអ្នកត្រូវការឆ្លងកាត់ប៉ារ៉ាម៉ែត្រពិសេសសម្រាប់កញ្ចប់នីមួយៗ។ នៅក្នុងស្ថានភាពរបស់យើង យើងបានប្រើឯកសារ manifest ជាទម្រង់ XML ដែលមានបញ្ជីកញ្ចប់ដែលត្រូវការ និងប៉ារ៉ាម៉ែត្ររបស់វា។ ខ្លឹមសាររបស់វាមើលទៅដូចនេះ៖

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="python" version="3.8.2"/>
  <package id="nuget.commandline" version="5.5.1"/>
  <package id="git" version="2.26.2"/>
</packages>

បន្ទាប់មក យើងដំឡើងបរិស្ថានបង្កើតកម្មវិធី ពោលគឺ MS Build Tools 2019 - នេះគឺជាកំណែស្រាលនៃ Visual Studio 2019 ដែលមានសំណុំសមាសភាគដែលត្រូវការអប្បបរមាសម្រាប់ការចងក្រងកូដ។
ដើម្បីដំណើរការយ៉ាងពេញលេញជាមួយគម្រោង C ++ របស់យើង យើងនឹងត្រូវការសមាសធាតុបន្ថែមដូចជា៖

• ឧបករណ៍ផ្ទុកការងារ C ++
• ឧបករណ៍ប្រើប្រាស់ v141
• Windows 10 SDK (10.0.17134.0)

អ្នកអាចដំឡើងសំណុំឧបករណ៍បន្ថែមដោយស្វ័យប្រវត្តិដោយប្រើឯកសារកំណត់រចនាសម្ព័ន្ធជាទម្រង់ JSON ។ មាតិកាឯកសារកំណត់រចនាសម្ព័ន្ធ៖

បញ្ជីពេញលេញនៃសមាសធាតុដែលមានអាចរកបាននៅលើគេហទំព័រឯកសារ Microsoft Visual Studio.

{
  "version": "1.0",
  "components": [
    "Microsoft.Component.MSBuild",
    "Microsoft.VisualStudio.Workload.VCTools;includeRecommended",
    "Microsoft.VisualStudio.Component.VC.v141.x86.x64",
    "Microsoft.VisualStudio.Component.Windows10SDK.17134"
  ]
}

dockerfile ដំណើរការស្គ្រីបដំឡើង ហើយសម្រាប់ភាពងាយស្រួល បន្ថែមផ្លូវទៅកាន់ឧបករណ៍បង្កើតឯកសារដែលអាចប្រតិបត្តិបានទៅអថេរបរិស្ថាន PATH. វាត្រូវបានណែនាំឱ្យយកឯកសារ និងថតឯកសារដែលមិនចាំបាច់ចេញ ដើម្បីកាត់បន្ថយទំហំរូបភាព។

COPY buildtools.config.json .
RUN Invoke-WebRequest 'https://aka.ms/vs/16/release/vs_BuildTools.exe' 
      -OutFile '.vs_buildtools.exe' -UseBasicParsing ;
    Start-Process -FilePath '.vs_buildtools.exe' -Wait -ArgumentList 
      '--quiet --norestart --nocache --config C:buildtools.config.json' ;
    Remove-Item '.vs_buildtools.exe' ;
    Remove-Item '.buildtools.config.json' ;
    Remove-Item -Force -Recurse 
      'C:Program Files (x86)Microsoft Visual StudioInstaller' ;
    $env:PATH = 'C:Program Files (x86)Microsoft Visual Studio2019BuildToolsMSBuildCurrentBin;' + $env:PATH; 
    [Environment]::SetEnvironmentVariable('PATH', $env:PATH, 
      [EnvironmentVariableTarget]::Machine)

នៅដំណាក់កាលនេះ រូបភាពរបស់យើងសម្រាប់ការចងក្រងកម្មវិធី C++ គឺរួចរាល់ហើយ ហើយយើងអាចបន្តដោយផ្ទាល់ទៅការបង្កើត docker multi-stage build នៃកម្មវិធី។

សកម្មភាពច្រើនដំណាក់កាល

យើងនឹងប្រើរូបភាពដែលបានបង្កើតជាមួយនឹងឧបករណ៍ទាំងអស់នៅលើយន្តហោះជារូបភាពសាងសង់ ដូចនៅក្នុងស្គ្រីប dockerfile មុន យើងនឹងបន្ថែមសមត្ថភាពក្នុងការបញ្ជាក់លេខកំណែ/ស្លាករូបភាពដោយថាមវន្ត ដើម្បីភាពងាយស្រួលនៃការប្រើប្រាស់កូដឡើងវិញ។ វាចាំបាច់ក្នុងការបន្ថែមស្លាក as builder ទៅរូបភាពនៃការដំឡើងនៅក្នុងការណែនាំ FROM.

ARG WINDOWS_OS_VERSION=1809
FROM buildtools:$WINDOWS_OS_VERSION as builder

ឥឡូវនេះដល់ពេលបង្កើតកម្មវិធីហើយ។ អ្វីគ្រប់យ៉ាងនៅទីនេះគឺសាមញ្ញណាស់៖ ចម្លងកូដប្រភព និងអ្វីគ្រប់យ៉ាងដែលភ្ជាប់ជាមួយវា ហើយចាប់ផ្តើមដំណើរការចងក្រង។

COPY myapp .
RUN nuget restore myapp.sln ;
    msbuild myapp.sln /t:myapp /p:Configuration=Release

ដំណាក់កាលចុងក្រោយនៃការបង្កើតរូបភាពចុងក្រោយគឺត្រូវបញ្ជាក់រូបភាពមូលដ្ឋាននៃកម្មវិធី ដែលវត្ថុបុរាណចងក្រង និងឯកសារកំណត់រចនាសម្ព័ន្ធទាំងអស់នឹងស្ថិតនៅ។ ដើម្បីចម្លងឯកសារដែលបានចងក្រងពីរូបភាពដំឡើងកម្រិតមធ្យម អ្នកត្រូវតែបញ្ជាក់ប៉ារ៉ាម៉ែត្រ --from=builder នៅក្នុងការណែនាំ COPY.

FROM mcr.microsoft.com/windows/servercore:$WINDOWS_OS_VERSION

COPY --from=builder C:/x64/Release/myapp/ ./
COPY ./configs ./

ឥឡូវនេះអ្វីដែលនៅសល់គឺត្រូវបន្ថែមភាពអាស្រ័យចាំបាច់សម្រាប់កម្មវិធីរបស់យើងដើម្បីដំណើរការ និងបញ្ជាក់ពាក្យបញ្ជាបើកដំណើរការតាមរយៈការណែនាំ ENTRYPOINT ឬ CMD.

សេចក្តីសន្និដ្ឋាន

នៅក្នុងអត្ថបទនេះ ខ្ញុំបាននិយាយអំពីរបៀបបង្កើតបរិយាកាសចងក្រងពេញលេញសម្រាប់កម្មវិធី C++ នៅខាងក្នុង Windows container និងរបៀបប្រើសមត្ថភាពនៃ docker multi-stage builds ដើម្បីបង្កើតរូបភាពពេញលេញនៃកម្មវិធីរបស់យើង។

ប្រភព: www.habr.com