BuildKit: Docker's Hidden Gem dy't hast alles kin bouwe

BuildKit: Docker's ferburgen gem dy't hast alles kin bouwe

De measte ûntwikkelders kenne Docker as de kontener-runtime dy't feroare hoe't software wurdt ferstjoerd. Folle minder witte oer de motor dy't rêstich ûnder it oerflak fan elke moderne Docker-build bromt - BuildKit, it folgjende-generaasje bousysteem dat sûnt ferzje 18.09 mei Docker is ferstjoerd en de standertbackend waard yn Docker 23.0. Wylst yngenieurs einleaze stride oer Kubernetes-konfiguraasjes en mikroservicepatroanen, is BuildKit stadichoan evoluearre ta ien fan 'e machtichste, fleksibelste bousystemen yn it DevOps-ekosysteem. As jo ​​it behannele hawwe as gewoan in rappere docker build, litte jo enoarme mooglikheden op 'e tafel litte. Bedriuwen dy't CI/CD-pipelines mei hege trochslach hawwe, hawwe de boutiden mei 50–70% besunige troch gewoan te begripen wat BuildKit eins biedt - en dat is mar it begjin.

Wat makket BuildKit fûneminteel oars fan 'e klassike bouwer

De orizjinele Docker-buildmotor hat Dockerfile-ynstruksjes sequentieel útfierd, ien laach foar ien, sûnder bewust te wêzen fan hokker wurk feilich parallel koe barre. BuildKit ferfangt dat lineêre útfieringsmodel mei in rjochte acyclyske grafyk (DAG) - in ôfhinklikheidsgrafyk dy't begrypt hokker boustappen op elkoar fertrouwe en hokker net. Unôfhinklike stadia wurde tagelyk útfierd, net brûkte stadia wurde folslein oerslein, en de heule build wurdt in deklarative beskriuwing fan wat jo wolle ynstee fan in ymperatyf folchoarder fan stappen dy't jo yn 'e juste folchoarder moatte recitearje.

Dizze arsjitektoanyske ferskowing hat praktyske gefolgen dy't boppe snelheid geane. Wannear't in multi-stage Dockerfile kompilearret in Go binary yn ien etappe, downloads Node.js ôfhinklikens yn in oar, en sammelet in produksje ôfbylding yn in tredde, BuildKit kin rinne de earste twa stadia tagelyk. In bou dy't earder fjouwer minuten naam op in krêftige CI-loper is no yn minder dan njoggentich sekonden foltôge. Stripe, Shopify, en skoares fan oare heechskalige yngenieurteams hawwe ferlykbere winsten dokumintearre yn har ynterne tooling retrospectives. It DAG-model betsjuttet ek dat BuildKit heul krekte bouwmetadata kin generearje - in basis foar funksjes lykas herkomstattesters en software bill of materials (SBOM) generaasje dy't enoarm wichtich binne foar supply chain feiligens.

D'r is ek in konseptuele ferskowing yn hoe't cache-ûnjildigens wurket. De klassike bouwer hat elke laach ûnder elke feroare ynstruksje ûnjildich makke. BuildKit folget ynhâld-hashes by elke ynfier, dus it feroarjen fan in opmerking yn in Dockerfile blaast gjin cache-yngong fuort dy't tritich minuten fan kompilaasje fertsjintwurdiget. As jo build-cache it ferskil is tusken in feedback-loop fan fiif minuten en in fjirtich minuten foar jo yngenieursteam, is dizze presyzje folle mear fan belang dan it yn earste ynstânsje liket.

Multi-Platform Builds: Ien kommando, elke arsjitektuer

BuildKit's --platfoarm flagge en QEMU-yntegraasje transformearje wat eartiids in pynlik multi-systeem koördinaasjeprobleem wie yn ien kommando. It útfieren fan docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 . produseart trije produksje-ree ôfbyldings parallel fan in inkele build-oanrop. Dizze mooglikheid is kritysk wurden om't de yndustry ferskowt nei ARM - AWS Graviton3-eksimplaren leverje konsekwint 40% bettere priisprestaasjes op wurkloads lykas webserving en gegevensferwurking, en Apple Silicon hat ARM de standertûntwikkelingsmasine makke foar miljoenen yngenieurs.

Foardat de multi-platfoarmstipe fan BuildKit ryp waard, wie it behâld fan aparte boupipelines foar ferskate arsjitektuer in wirklik kostensintrum. Teams either maintained multiple Dockerfiles, ran separate CI pipelines on differently-architected runners, or simply shipped x86 images everywhere and paid the performance penalty on ARM infrastructure. Mei BuildKit definiearje jo jo build ien kear en lit it systeem arsjitektuer-spesifike kompilaasje transparant behannelje. Rustprojekten dy't cross-kompilaasje nedich binne, Go-projekten mei CGO-ôfhinklikens, Python-pakketten mei C-útwreidingen - BuildKit behannelet de emulaasjelaach sûnder dat jo de details fan elk doelplatfoarm moatte begripe.

De praktyske saaklike wearde is hjir mjitber. In team dat 200 konteners draait op AWS Graviton-eksimplaren op $ 0,04 per vCPU-oere tsjin it lykweardige x86-eksimplaar op $ 0,056 per vCPU-oere, besparret jierliks ​​sawat $ 11,520 per 100 vCPU's - suver fan it kiezen fan 'e juste arsjitektuer. Dy kar tagonklik meitsje sûnder werynrjochting is krekt it soarte fan ynfrastruktueroptimalisaasje dy't him daliks betellet.

Geheim behear sûnder lekken yn byldlagen

Ien fan 'e meast ûnderskatte BuildKit-funksjes is de geheimen API. De klassike Docker-bouwer hie gjin skjinne manier om referinsjes yn in build troch te jaan sûnder dat dizze referinsjes mooglik yn in ôfbyldingslaach einigje. Ûntwikkelers wurken om dit hinne mei multi-stage builds, ARG ynstruksjes, en soarchfâldige oardering - mar it risiko fan tafallich bakt in API-kaai of privee SSH-kaai yn in ferstjoerd ôfbylding bleau ûngemaklik heech. Feiligensscanners fine regelmjittich hurdkodearre bewiisbrieven yn kontenerôfbyldings publisearre yn iepenbiere registers, en in protte fan dy lekkages komme direkt werom nei ûnhandige geheime ôfhanneling by builds.

BuildKit's --secret-flagge monteart gefoelige gegevens yn 'e build-omjouwing as in tydlik bestânssysteempaad dat allinich bestiet foar de doer fan 'e spesifike RUN-ynstruksje dy't it nedich hat en nea in ôfbyldingslaach oanrekket. In Dockerfile-ynstruksje lykas RUN --mount=type=secret,id=npmrc cat /run/secrets/npmrc > ~/.npmrc && npm-ynstallaasje jout it bouproses tagong ta privee npm-credentials sûnder dat dy bewiisbrieven oait ferskine yn 'e definitive ôfbylding of in tuskenlizzende laach. Itselde patroan wurket foar PyPI-bewizen, Maven-ynstellingen, SSH-kaaien foar privee Git-repositories, en elk oar gefoelich materiaal dat jo bouproses fereasket.

Foar teams dy't software bouwe dy't regele yndustry oanreitsje - sûnenssoarchplatfoarms, fintech-produkten, HR-software - is it ferskil tusken "credentials miskien yn 'e ôfbylding" en "credentials kinne blykber net yn' e ôfbylding wêze" is it ferskil tusken it trochjaan fan in befeiligingskontrôle en it besteegjen fan trije wiken oan it remedearjen fan befinings. Platfoarms lykas Mewayz, dy't saaklike operaasjes foar mear as 138.000 brûkers machtigje oer yndustry lykas lean, HR, en fakturearring, binne ôfhinklik fan krekt dit soarte fan bewiisbere feiligensposysje yn har bou- en ynsetpipelines om it fertrouwen te behâlden dat dizze klanten útwreidzje nei har gefoelige finansjele en personielsgegevens.

Cache-eksporten: CI-pipelines wirklik fluch meitsje

CI-pipelines binne wêr't bouprestaasjes it meast wichtich binne en wêr't de standert Docker-buildûnderfining histoarysk it meast pynlik west hat. Frisse CI-runners begjinne typysk mei lege caches, wat betsjuttet dat elke pipeline-run alles fanôf it begjin opnij kompilearret. Foar in Java-tsjinst mei hûnderten Maven-ôfhinklikens, in Rust-projekt, of in Python-applikaasje mei swiere native útwreidingen, betsjut dit boutiden mjitten yn tsientallen minuten ynstee fan sekonden. De saaklike kosten fan trage CI binne enoarm - fermindere ynsetfrekwinsje, langere feedbacklussen, en yngenieurs dy't stil sitte te wachtsjen op pipelines om te foltôgjen foardat se kinne gearfoegje en trochgean.

BuildKit's cache-eksportfunksje lost dit op mei eksportbere cache-manifesten. Mei --cache-to type=registry,ref=myregistry/myapp:cache en --cache-from type=registry,ref=myregistry/myapp:cache, triuwt BuildKit in detaillearre cache-snapshot nei in register nei elke build en lûkt it oan it begjin fan de folgjende. De cache is ynhâld-adressearre, dus allinich echt feroare lagen wurde opnij ophelle. Teams dy't dit patroan brûke yn GitHub Actions, GitLab CI, en CircleCI snije regelmjittich pipelinetiden fan fyftjin minuten nei ûnder trije op folgjende runs. GitHub's eigen dokumintaasje oer avansearre Docker build workflows rekommandearret dit patroan sterk oan om krekt dizze reden.

De rapste build is dejinge dy't jo noait wer hoege te rinnen. BuildKit's lagen, ynhâld-adressearre cachesysteem fersnelt net allinich builds - it makket it heule konsept fan in "build" tûker, en feroaret in werhelle kompilaasje yn in inkrementeel ferskil fan krekt wat feroare is.

Cache-eksporten yntegrearje ek skjin mei branch-basearre ûntwikkelingswurkflows. Jo kinne jo CI-pipeline konfigurearje om werom te fallen fan in branch-spesifike cache nei de haadtûke-cache as der gjin branch-cache bestiet, wat betsjuttet dat nije tûken daliks profitearje fan de waarme cache dy't sammele is troch jo haadûntwikkelingsline. Yngenieurs krije rappe feedback fan har alderearste tawijing oan in nije tûke yn stee fan te wachtsjen troch in kâlde-start-boete.

BuildKit Frontends: Building Beyond Dockerfiles

Miskien is de minst bekende mooglikheid fan BuildKit dat Dockerfiles mar ien mooglik ynfierformaat binne - net de ienige. BuildKit hat in pluggable frontend-arsjitektuer dy't folslein oanpaste build-definysjetalen en formaten mooglik makket. It frontend wurdt oantsjutte troch de # syntax=-rjochtline boppe oan jo build-bestân, dy't BuildKit fertelt om in bepaalde frontendôfbylding te lûken en it te brûken om de rest fan it bestân te parsearjen en út te fieren.

Dizze arsjitektuer hat ferskate twingende projekten mooglik makke. Buildpacks-yntegraasje lit BuildKit kontenerôfbyldings bouwe fan tapassingsboarnekoade sûnder Dockerfile - it detektearret de taal, kiest passende basisôfbyldings, en sammelet automatysk in produksje-klear kontener. HPC and scientific computing communities have used custom frontends to describe builds in domain-specific languages that compile down to BuildKit's internal LLB (Low-Level Build) representation. De docker/dockerple:labs-syntaksis-frontend eksperimintearret mei funksjes lykas heredoc-stipe, --netwurk-kontrôle per ynstruksje, en ferbettere cache-hints foardat se yn stabile Dockerfile-syntaksis lânje.

De mooglikheid om jo eigen frontend te definiearjen betsjut ek dat organisaasjes mei ûngewoane bouweasken net hoege te kiezen tusken "shoehorn alles yn Dockerfile-syntaksis" en "konteners hielendal ferlitte." In teambuilding fan FPGA-firmware, ynbêde systeemôfbyldings, of spesjalisearre ML-modelkonteners kinne har build beskriuwe yn termen dy't sin meitsje foar har domein, wylst se noch standert OCI-konforme kontenerôfbyldings produsearje dy't oeral ynsette konteners rinne. Dizze útwreidzjen is in echt arsjitektoanysk foardiel boppe bouwsystemen dy't har ynfierformaat as fêst behannelje.

Herkomst en SBOM: Bouwe foar de Post-SolarWinds World

Feiligens fan software-oanbodketen ferhuze fan teoretyske soarch nei prioriteit op bestjoersnivo nei de SolarWinds-ynbreuk yn 2020 en de kwetsberens fan Log4Shell yn 2021. De Executive Order 14028 fan 'e Amerikaanske regearing oer cybersecurity, útjûn yn maaie 2021, ferplichte softwarekontrakten foar federale materialen. De herkomstattestaasjes fan BuildKit en SBOM-generaasjefunksjes binne in direkte reaksje op dit regeljouwing- en feiligenslânskip.

Mei --provenance=true en --sbom=true-flaggen genereart BuildKit kryptografysk ûndertekene attestaasjes dy't krekt beskriuwe wat der yn in kontenerôfbylding gie - hokker basisôfbyldings waarden brûkt, hokker Dockerfile-ynstruksjes útfierden, hokker boarnebestannen oanwêzich wiene en hokker eksterne ôfhinklikens waarden ophelle. Dizze attestaasjes folgje it SLSA (Supply-chain Levels for Software Artifacts) ramt en it in-toto attestation-formaat, wêrtroch't se masine-ferifiearber binne troch beliedsmotoren lykas Sigstore's Cosign en OPA (Open Policy Agent).

De praktyske workflow dy't dit mooglik makket, sjocht der sa út:

1. Utwikkelder triuwt koade; CI-pipeline triggert in BuildKit-build mei provenance ynskeakele.
2. BuildKit genereart in ûndertekene SBOM mei alle komponinten en har ferzjes.
3. De SBOM wurdt publisearre nei it kontenerregister neist it byldmanifest.
4. Tagongskontrôlers yn it Kubernetes-kluster ferifiearje de herkomst foardat se ynset tastean.
5. Kwetsberensscanners freegje de SBOM om beynfloede ôfbyldings te identifisearjen as nije CVE's wurde iepenbierre.

Teams dy't dizze folsleine pipeline ymplementearje kinne reagearje op kwetsberens iepenbieringen yn oeren ynstee fan dagen, om't se in krekte, masine-lêsbere kaart hawwe fan elke komponint yn elke rinnende kontener. Foar bedriuwen lykas Mewayz dy't djip yntegrearje yn 'e operasjonele workflows fan klanten - it útfieren fan lean, it behearen fan floatgegevens, it ferwurkjen fan faktueren - is de mooglikheid om in strange, kontrolearbere supply chain te demonstrearjen hieltyd mear in betingst foar bedriuwsferkeapkonversaasjes, net allinich in noflike te hawwen.

Begjinne: fan standertbou oant avansearre pipelines

BuildKit rint al yn jo Docker-omjouwing as jo in resinte ferzje brûke - Docker 23.0 en letter ynskeakelje it standert. De earste praktyske stap foar de measte teams is it ynskeakeljen fan de Docker Buildx-plugin, dy't de folsleine funksjeset fan BuildKit bleatstelt fia it subkommando docker buildx. It útfieren fan docker buildx create --use set in BuildKit-bouwer-eksimplaar op mei mear mooglikheden dan de standertbestjoerder. Fanôf dêrút is inkrementele oannimmen fan avansearre funksjes logysk ynstee fan besykje alles yn ien kear oan te nimmen.

In ridlik oannimmingspaad foar in team dat op it stuit basale docker build-oanroppen docht liket earst cache-eksporten ta te foegjen oan CI - dit leveret direkte, mjitbere snelheidsferbetterings mei minimale konfiguraasjeferoaring. Multi-platfoarm builds wurde weardefol as it team begjint te rjochtsjen op ARM-ynfrastruktuer. Geheime mounting is it wurdich om elk momint oan te nimmen as partikuliere pakketregistraasjes as SSH-kaaien ferskine yn build-kontekst. Herkomstattesters binne sinfol om yn te skeakeljen as neilibjenseasken of easken fan ûndernimmersklanten nedich meitsje fan supply chain dokumintaasje.

De djippere les fan BuildKit giet oer bewust bouwen. Oft jo in kontener ferstjoere foar in mikrotsjinst, in einpunt fan masine-learen, of in kompleks platfoarm lykas Mewayz's suite fan 207 bedriuwsmodules, it bouproses is gjin formaliteit wêrmei jo op 'e wei nei ynset haasten - it is in technysk artefakt dat de kwaliteit, feiligensposysje en operasjonele folwoeksenheid reflektearret fan alles dat derút ferstjoerd wurdt. BuildKit jout jo de ark om dat artefakt poerbêst te meitsjen. De fraach is gewoan oft jo de tiid nimme om se te brûken.

Faak stelde fragen

Wat is BuildKit en hoe is it oars fan it klassike Docker-buildsysteem?

BuildKit is de folgjende-generaasje buildmotor fan Docker, yntrodusearre yn Docker 18.09 en makke de standert yn Docker 23.0. Oars as de klassike bouwer, stipet BuildKit útfiering fan parallelle lagen, avansearre cachingstrategyen, montage fan geheimen, en cross-platform builds. It behannelet it bouproses as in rjochte acyclyske grafyk (DAG), wêrtroch tûkere ôfhinklikensresolúsje en dramatysk rappere boutiden mooglik is foar komplekse Dockerfiles yn meardere etappe.

Moat ik wat ekstra ynstallearje om BuildKit mei Docker te brûken?

Gjin ekstra ynstallaasje is nedich as jo Docker 23.0 of letter útfiere - BuildKit is standert ynskeakele. Op âldere ferzjes kinne jo it aktivearje troch de omjouwingsfariabele DOCKER_BUILDKIT=1 yn te stellen foardat jo bouwkommando's útfiere. Foar avansearre gebrûksgefallen lykas remote build caches of multi-platfoarm builds, kinne jo in tawijd Buildx builder eksimplaar konfigurearje mei docker buildx create.

Kin BuildKit brûkt wurde om artefakten te bouwen dan standert kontenerôfbyldings?

Ja, en dit is ien fan de meast ûnderskatte mooglikheden fan BuildKit. Mei gebrûk fan oanpaste frontends en de flagge --output, kin BuildKit rûge binaries, tarballs, statyske websiden, en oare willekeurige triemartefakten produsearje - net allinich OCI-ôfbyldings. Dit makket it in algemiene boumotor dy't natuerlik past yn polyglot monorepos en komplekse CI-pipelines wêr't ferskate teams ferskate útfierformaten nedich binne fan in ferienige toolchain.

Hoe past BuildKit yn in breder DevOps-platfoarm neist ark lykas Mewayz?

BuildKit behannelet de boulaach op leech nivo, mar moderne ûntwikkelingsteams moatte ek saaklike workflows, klantlevering en operasjonele prosessen beheare. Platfoarms lykas Mewayz - in bedriuwssysteem mei 207 modules begjinnend by $ 19/mo - komplementearje ynfrastruktuerark troch de operasjonele kant fan softwarebedriuwen te dekken. It keppeljen fan effisjinte boupipelines oandreaun troch BuildKit mei in alles-yn-ien platfoarm lykas Mewayz jout teams in folsleine stapel fan koade-artefakt oant levering fan klanten.