🥇Skaffold-ի ակնարկ Kubernetes Development-ի համար

Skaffold-ի վերանայում Kubernetes-ի զարգացման համար

Մեկուկես տարի առաջ՝ 5 թվականի մարտի 2018-ին, Google-ը թողարկեց իր բաց կոդով CI/CD նախագծի առաջին ալֆա տարբերակը, որը կոչվում էր… Սկավառակ, որի նպատակն էր ստեղծել «պարզ և վերարտադրելի մշակում Kubernetes-ի համար», որպեսզի մշակողները կարողանային կենտրոնանալ մշակման վրա, այլ ոչ թե կառավարման վրա: Ի՞նչը կարող է հետաքրքիր լինել Skaffold-ի մեջ: Պարզվում է, որ այն ունի մի քանի առավելություններ, որոնց շնորհիվ այն կարող է դառնալ հզոր գործիք մշակողի, և գուցե նույնիսկ գործառնությունների ինժեների համար: Եկեք ծանոթանանք նախագծին և դրա հնարավորություններին:

NBԻ դեպ, մենք արդեն համառոտ խոսել ենք Սկաֆոլդի մասին մեր ընդհանուր մշակողի գործիքների ակնարկ, որոնց կյանքը կապված է Կուբեռնետեսի հետ։

Տեսություն։ Նպատակ և հնարավորություններ

Այսպիսով, ընդհանուր առմամբ, Skaffold-ը լուծում է CI/CD ցիկլի ավտոմատացման խնդիրը (կառուցման, գործարկման, տեղակայման փուլերում), մշակողին առաջարկելով արագ հետադարձ կապ, այսինքն՝ հնարավորություն արագորեն ստանալու հաջորդ կոդի փոփոխությունների արդյունքը՝ Kubernetes կլաստերում աշխատող թարմացված ծրագրի տեսքով: Եվ այն կարող է աշխատել տարբեր սխեմաներում (մշակում, փուլ, արտադրություն ...), որոնց համար Skaffold-ը օգնում է նկարագրել տեղակայման համար համապատասխան խողովակաշարերը:

Skaffold-ի սկզբնական կոդը գրված է Go լեզվով, տարածվում է անվճար Apache License 2.0 (GitHub) լիցենզիայի պայմաններին համապատասխան։

Եկեք դիտարկենք հիմնական գործառույթներն ու հնարավորությունները։ Առաջինները ներառում են հետևյալը.

Skaffold-ը առաջարկում է գործիքներ CI/CD խողովակաշարեր ստեղծելու համար։
Թույլ է տալիս հետևել ձեր սկզբնական կոդի փոփոխություններին ֆոնային ռեժիմով և գործարկել կոդը կոնտեյներային պատկերների մեջ կառուցելու, այդ պատկերները Docker գրանցամատյանում հրապարակելու և դրանք Kubernetes կլաստերում տեղակայելու ավտոմատացված գործընթաց։
Համաժամեցնում է պահոցի ֆայլերը կոնտեյների աշխատանքային գրացուցակի հետ։
Ավտոմատ կերպով թեստավորում է container-structure-test-ի միջոցով։
Առաջ է տանում նավահանգիստները։
Կարդում է կոնտեյների մեջ աշխատող ծրագրի գրանցամատյանները։
Օգնում է Java, Node.js, Python, Go լեզուներով գրված հավելվածների վրիպազերծման հարցում։

Հիմա՝ առանձնահատկությունների մասին.

Սկաֆոլդն ինքնին կլաստերային կողմի բաղադրիչներ չունի։Այսինքն, այս օգտակար ծրագիրը օգտագործելու համար Kubernetes-ը լրացուցիչ կարգավորելու կարիք չկա։
Ձեր կիրառման համար տարբեր խողովակաշարեր. Արդյո՞ք անհրաժեշտ է կոդը տեղակայել տեղական Minikube-ի վրա մշակման ընթացքում, ապա բեմադրել կամ արտադրել։ Կան պրոֆիլներ և օգտատիրոջ կոնֆիգուրացիաներ, միջավայրի փոփոխականներ և դրոշներ, որոնք թույլ են տալիս նկարագրել տարբեր խողովակաշարեր մեկ ծրագրի համար։
CLIՄիայն կոնսոլի օգտակար ծրագրեր և YAML կոնֆիգուրացիաներ։ Կարող եք գտնել հղումներ ստեղծելու փորձերի վերաբերյալ։ փորձարարական գրաֆիկական ինտերֆեյս, բայց այս պահին սա, ամենայն հավանականությամբ, նշանակում է, որ ինչ-որ մեկին դա պետք է, բայց ոչ շատ։
ՄոդուլյարությունSkaffold-ը ինքնուրույն կոմբայն չէ, այլ նպատակ ունի օգտագործել առանձին մոդուլներ կամ առկա լուծումներ որոշակի խնդիրների համար։

Վերջինի նկարազարդումը՝

Հավաքման փուլում կարող եք օգտագործել.
- docker-ը կարող է կառուցվել տեղական, կլաստերում՝ kaniko-ի միջոցով, կամ Google Cloud Build-ում։
- Բազել տեղական մակարդակով;
- Jib Maven-ը և Jib Gradle-ը տեղական կամ Google Cloud Build-ում։
- Տեղականորեն գործարկվող հատուկ կառուցման սկրիպտներ։ Եթե անհրաժեշտ է գործարկել մեկ այլ (ավելի ճկուն/ծանոթ/…) կառուցման լուծում, այն նկարագրված է սկրիպտում, որպեսզի Skaffold-ը գործարկի այն (օրինակ փաստաթղթերիցՍա թույլ է տալիս օգտագործել ցանկացած կոլեկցիոներ, որը կարող է կանչվել սկրիպտի միջոցով։
Փորձարկման փուլում արդեն նշվածը աջակցվում է կոնտեյներ-կառուցվածք-փորձարկում;
Տեղակայման համար տրամադրվում են հետևյալները.
- Կուբեկտլ;
- Սաղավարտ;
- հարմարեցնել։

Սա Սկաֆոլդին դարձնում է յուրահատուկ CI/CD կառուցման շրջանակԱհա աշխատանքային հոսքի օրինակ՝ դրա օգտագործման ժամանակ (նախագծի փաստաթղթերից).

Skaffold-ի վերանայում Kubernetes-ի զարգացման համար

Ինչպիսի՞ն է Սկաֆոլդի աշխատանքն ընդհանուր առմամբ։

Գործիքը հետևում է սկզբնական կոդի գրացուցակում տեղի ունեցող փոփոխություններին։ Եթե ֆայլերում փոփոխություններ են կատարվում, դրանք համաժամեցվում են Kubernetes կլաստերի հավելվածի պոդի հետ։ Հնարավորության դեպքում՝ առանց պատկերը վերակառուցելու։ Հակառակ դեպքում կառուցվում է նոր պատկեր։
Կառուցված պատկերը փորձարկվում է container-structure-test-ի միջոցով, պիտակավորվում և ուղարկվում է Docker Registry:
Դրանից հետո պատկերը տեղակայվում է - տեղակայված է Kubernetes կլաստերում:
Եթե մեկնարկը սկսվել է հրամանի միջոցով skaffold dev, ապա մենք սկսում ենք ստանալ գրանցամատյաններ հավելվածից, և Skaffold-ը սպասում է փոփոխությունների՝ բոլոր գործողությունները կրկին կրկնելու համար։

Skaffold-ի վերանայում Kubernetes-ի զարգացման համար
Սկաֆոլդի աշխատանքի հիմնական փուլերի նկարազարդում

Պրակտիկա։ Սկաֆոլդի փորձ

Սկաֆոլդի օգտագործումը ցույց տալու համար ես օրինակ կբերեմ Նախագծի GitHub պահոցներըԻ դեպ, առանձին Կարող եք գտնել բազմաթիվ այլ օրինակներ, որոնք հաշվի են առնում տարբեր առանձնահատկություններ: Ես բոլոր գործողությունները կկատարեմ տեղական՝ Minikube-ում: Տեղադրումը պարզ է և կտևի մի քանի րոպե, և սկսելու համար ձեզ անհրաժեշտ կլինի kubectl-ը:

Եկեք տեղադրենք Skaffold-ը։

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin
skaffold version
v0.37.1

Եկեք կլոնավորենք Սկաֆոլդի պահոցը՝ օգտագործելով անհրաժեշտ օրինակները։

git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservices

Ես ընտրեցի երկու պոդով օրինակ, որոնցից յուրաքանչյուրը պարունակում է մեկ փոքր Go հավելված։ Մեկ հավելվածը frontend-ն է (leeroy-web), որը հարցումը փոխանցում է երկրորդ հավելվածին՝ backend-ին (leeroy-app): Տեսնենք, թե ինչ տեսք ունի այն։

~/skaffold/examples/microservices # tree
.
├── leeroy-app
│   ├── app.go
│   ├── Dockerfile
│   └── kubernetes
│       └── deployment.yaml
├── leeroy-web
│   ├── Dockerfile
│   ├── kubernetes
│   │   └── deployment.yaml
│   └── web.go
├── README.adoc
└── skaffold.yaml
 
4 directories, 8 files

leeroy-app-ը և leeroy-web-ը պարունակում են Go կոդ և պարզ Dockerfiles՝ այս կոդի տեղական հավաքման համար։

~/skaffold/examples/microservices # cat leeroy-app/Dockerfile
FROM golang:1.12.9-alpine3.10 as builder
COPY app.go .
RUN go build -o /app .
 
FROM alpine:3.10
CMD ["./app"]
COPY --from=builder /app .

Ես չեմ տրամադրի ծրագրի կոդը՝ բավական է իմանալ դա leeroy-web ընդունում է հարցումները և լիազորում դրանք leeroy-appՀետևաբար, ֆայլերում Deployment.yaml Ծառայությունը գործում է միայն դրա համար app (ներքին երթուղավորման համար): Պոդի միացք web Մենք այն կուղարկենք ինքներս մեզ՝ հավելվածին արագ մուտք գործելու համար։

Նայում է skaffold.yaml:

~/skaffold/examples/microservices # cat skaffold.yaml
apiVersion: skaffold/v1beta13
kind: Config
build:
  artifacts:
    - image: leeroy-web
      context: ./leeroy-web/
    - image: leeroy-app
      context: ./leeroy-app/
deploy:
  kubectl:
    manifests:
      - ./leeroy-web/kubernetes/*
      - ./leeroy-app/kubernetes/*
portForward:
  - resourceType: deployment
    resourceName: leeroy-web
    port: 8080
    localPort: 9000

Վերը նշված բոլոր փուլերը նկարագրված են այստեղ։ Այս կարգավորումից բացի, կա նաև գլոբալ կարգավորումներով ֆայլ՝ ~/.skaffold/configԱյն կարող է խմբագրվել ձեռքով կամ CLI-ի միջոցով՝ օրինակ, այսպես՝

skaffold config set --global local-cluster true

Այս հրամանը կսահմանի գլոբալ փոփոխական local-cluster իմաստի մեջ true, որից հետո Skaffold-ը չի փորձի պատկերներ տեղափոխել հեռակա գրանցամատյան: Եթե մշակումը կատարվում է տեղական եղանակով, կարող եք օգտագործել այս հրամանը՝ պատկերները տեղական եղանակով ծալելու համար:

Հետ դեպի skaffold.yaml:

Բեմում build Մենք նշում ենք, որ պատկերը պետք է կառուցվի և պահպանվի տեղային եղանակով։ Կառուցումն առաջին անգամ գործարկելուց հետո մենք կտեսնենք հետևյալը՝

// т.к. Minikube создает кластер в отдельной виртуальной машине,
// придется проникнуть внутрь, чтобы найти образы
# minikube ssh
$ docker images
REPOSITORY                                TAG                                                                IMAGE ID            CREATED             SIZE 
leeroy-app                                7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e   7d55a5080359        4 hours ago         13MB 
leeroy-app                                v0.37.1-171-g0270a0c-dirty                                         7d55a5080359        4 hours ago         13MB
leeroy-web                                5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681   5063bfb29d98        5 hours ago         13.1MB
leeroy-web                                v0.37.1-171-g0270a0c-dirty                                         5063bfb29d98        5 hours ago         13.1MB

Ինչպես տեսնում եք, Սկաֆոլդն ինքն է պիտակավորել պատկերները։ Ի դեպ, աջակցվում են պիտակավորման մի քանի քաղաքականություններ։

Կարգավորման մեջ հետագայում նշված է context: ./leeroy-app/, այսինքն՝ նշված է այն համատեքստը, որում պատկերը հավաքվում է։
Տեղակայման փուլում որոշվում է, որ մենք կօգտագործենք kubectl-ը և դիմակը պահանջվող մանիֆեստների համար։
PortForwardնման է նրան, թե ինչպես ենք մենք սովորաբար փոխանցում պորտերը՝ օգտագործելով kubectl port-forward, մենք Skaffold-ին հրահանգներ ենք տալիս կանչել այս հրամանը։ Այս դեպքում, տեղային 9000 պորտը վերահասցեագրվում է 8080-ին Deployment անունով leeroy-web.

Ժամանակն է մեկնարկելու skaffold devհրամանը կստեղծի շարունակական «հետադարձ կապի ցիկլ», այսինքն՝ այն ոչ միայն կհավաքի ամեն ինչ և կտեղակայի կլաստերում, այլև կտեղեկացնի ձեզ պոդերի ներկայիս վիճակի մասին, կհսկի փոփոխությունները և կթարմացնի պոդերի վիճակը։

Ահա մեկնարկի արդյունքը skaffold dev --port-forward վերամոնտաժման ժամանակ՝

Skaffold-ի վերանայում Kubernetes-ի զարգացման համար

Նախ, պարզ է, որ քեշն օգտագործվում է։ Հաջորդը, ծրագիրը կառուցվում, տեղակայվում է և պորտերը վերահասցեագրվում են։ Քանի որ --port-forward, Սկաֆոլդը նավահանգիստը փոխանցեց դեպի web, ինչպես նրան խնդրեցին, բայց այստեղ app Նա այն փոխանցեց իր հայեցողությամբ (ընտրեց ամենամոտ անվճարը): Դրանից հետո մենք ստանում ենք հավելվածներից առաջին գրանցամատյանները:

Եկեք ստուգենք ֆունկցիոնալությունը;

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-6998dfcc95-2nxvf   1/1     Running   0          103s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          103s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy app!!!

Ֆայլի փոփոխում leeroy-app/app.go — անցնում է մի քանի վայրկյան... և.

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-ffd79d986-l6nwp    1/1     Running   0          11s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          4m59s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy Habr!!!

Միևնույն ժամանակ, Skaffold-ը ինքնին նույն բանը արտածեց կոնսոլ, ինչպես նախկինում, մեկ բացառությամբ. այն միայն դուրս եկավ leeroy-app, և ոչ բոլորը միանգամից։

Ավելի շատ պրակտիկա

Նաև հարկ է նշել, որ նոր նախագիծ ստեղծելիս Skaffold-ի համար կարգավորումները կարող են բեռնավորվել հրամանի միջոցով։ init, որը շատ հարմար է։ Բացի այդ, դուք կարող եք գրել մի քանի կոնֆիգուրացիաներ՝ մշակել լռելյայն կոնֆիգուրացիայի վրա, ապա գործարկել բեմում հրամանի միջոցով։ run (նույն գործընթացը, ինչ dev, բայց չի հետևում փոփոխություններին), օգտագործելով այլ կոնֆիգուրացիա։

Կատակոդայի վրա կա մեկը ղեկավարությունը Օրինակով ավելի հեշտ է։ Բայց այն առաջարկում է պատրաստի ավազարկղ՝ Kubernetes-ով, հավելվածով և Skaffold-ով։ Հիանալի տարբերակ է, եթե ցանկանում եք ինքներդ փորձել հիմունքները։

Skaffold-ի օգտագործման հնարավոր տարբերակներից մեկը հեռակա կլաստերի վրա մշակումն է: Ոչ բոլորն են հարմարավետ Minikube-ը սեփական սարքավորման վրա աշխատեցնելով, այնուհետև ծրագիրը գործարկելով և սպասելով, որ այն ճիշտ աշխատի... Այս դեպքում Skaffold-ը կատարելապես լուծում է խնդիրը, ինչը կարող են հաստատել, օրինակ, Reddit-ի ինժեներները, որոնց մասին մենք արդեն խոսել ենք: писали մեր բլոգում։

Եվ այս հրապարակումը Արտադրության համար խողովակաշար ստեղծելու օրինակ կարող եք գտնել Weaveworks-ից։

Ամփոփում

Skaffold-ը հարմար գործիք է Kubernetes-ում հավելվածների տեղակայման և հիմնականում զարգացման կարիքների վրա կենտրոնացած խողովակաշարեր կառուցելու համար: Բավականին հեշտ է ստեղծել «կարճ» խողովակաշար, որը հաշվի է առնում մշակողի հիմնական կարիքները, բայց ցանկության դեպքում կարող եք կազմակերպել ավելի մեծ գործընթացներ: Որպես Skaffold-ի CI/CD գործընթացներում օգտագործման պատկերազարդ օրինակներից մեկը՝ տրված է այդպիսի փորձարկման նախագիծ 10 միկրոսերվիսներից, որոնք օգտագործում են Kubernetes, gRPC, Istio և OpenCensus Tracing համակարգերը։

Skaffold-ը արդեն ստացել է գրեթե 8000+ աստղ GitHub-ում, մշակվել է Google-ի կողմից և մաս է կազմում Google Container Tools — ընդհանուր առմամբ, այս պահին կան բոլոր հիմքերը հավատալու, որ նախագիծը կզարգանա երկար և երջանիկ։