Oorsig van Skaffold vir Kubernetes-ontwikkeling

'n Jaar en 'n half gelede, op 5 Maart 2018, het Google die eerste alfa-weergawe van sy Open Source-projek vir CI/CD vrygestel genaamd Skaffold, wie se doel was om "eenvoudige en herhaalbare Kubernetes-ontwikkeling" te skep sodat ontwikkelaars op ontwikkeling eerder as administrasie kon fokus. Wat kan interessant wees oor Skaffold? Soos dit blyk, het dit 'n paar truuks op sy mou wat dit 'n kragtige hulpmiddel vir die ontwikkelaar kan maak, en miskien selfs die bedryfsingenieur. Kom ons maak kennis met die projek en sy vermoëns.

NB: Terloops, ons het reeds kortliks oor Skaffold in ons generaal gepraat hersiening van ontwikkelaarnutsgoed, wie se lewens met Kubernetes verbind word.

Teorie. Doel en vermoëns

Dus, oor die algemeen, los Skaffold die probleem op om die CI/CD-siklus te outomatiseer (by die bou-, druk-, ontplooifases), en bied die ontwikkelaar vinnige terugvoer, d.w.s. die vermoë om vinnig die resultaat van die daaropvolgende kodeveranderings te ontvang - in die vorm van 'n opgedateerde toepassing wat in die Kubernetes-groepering loop. En dit kan in verskillende stroombane werk (dev, stadium, produksie...), waarvoor Skaffold help om die ooreenstemmende pyplyne vir ontplooiing te beskryf.

Skaffold se bronkode is geskryf in Go, versprei deur onder die gratis Apache-lisensie 2.0 (GitHub).

Kom ons kyk na die hooffunksies en kenmerke. Die eerste sluit die volgende in:

• Skaffold bied gereedskap vir die skep van CI/CD-pyplyne.
• Laat jou toe om veranderinge in die bronkode op die agtergrond te monitor en 'n outomatiese proses uit te voer om kode in houerbeelde saam te stel, hierdie beelde in die Docker-register te publiseer en dit na die Kubernetes-groepering te ontplooi.
• Sinkroniseer lêers in die bewaarplek met die werkgids in die houer.
• Toets outomaties met behulp van houerstruktuurtoets.
• Stuur hawens aan.
• Lees die logs van 'n toepassing wat in 'n houer loop.
• Help met ontfouting van toepassings wat in Java, Node.js, Python, Go geskryf is.

Nou oor die kenmerke:

• Skaffold self het geen troskantkomponente nie. Dit wil sê, dit is nie nodig om Kubernetes verder op te stel om hierdie nutsprogram te gebruik nie.
• Verskillende pyplyne vir jou toepassing. Moet jy die kode na plaaslike Minikube uitrol terwyl jy ontwikkel, en dan na verhoog of produksie? Vir hierdie doel is daar profiele en gebruikerskonfigurasies, omgewingsveranderlikes en vlae, wat jou toelaat om verskillende pyplyne vir een toepassing te beskryf.
• CLI. Slegs konsole nut en konfigurasies in YAML. Op die internet kan jy verwysings vind na pogings om te skep eksperimentele GUI, egter, op die oomblik beteken dit heel waarskynlik net dat iemand hom nodig het, maar nie regtig nie.
• Modulariteit. Skaffold is nie 'n selfstandige stroper nie, maar streef daarna om individuele modules of bestaande oplossings vir spesifieke take te gebruik.

Illustrasie van laasgenoemde:

• Tydens die samestelling kan u gebruik maak van:
  • docker bou plaaslik, in 'n cluster met behulp van kaniko of in Google Cloud Build;
  • Bazel plaaslik;
  • Jib Maven en Jib Gradle plaaslik of in Google Cloud Build;
  • pasgemaakte bouskrifte plaaslik uitgevoer word. As jy nog 'n (meer buigsame/bekende/...) bouoplossing moet gebruik, word dit in die skrif beskryf sodat Skaffold dit begin (voorbeeld uit dokumentasie). Dit laat jou toe om enige versamelaar te gebruik wat met 'n skrif genoem kan word;
• Op die toets stadium, die reeds genoemde houer-struktuur-toets;
• Vir ontplooiing word die volgende verskaf:
  • Kubectl;
  • Roer;
  • pasmaak.

Danksy dit kan Skaffold 'n unieke genoem word raamwerk vir die bou van CI/CD. Hier is 'n voorbeeld van werkvloei wanneer dit gebruik word (uit die projekdokumentasie):

Hoe lyk Skaffold se werk in algemene terme?

1. Die hulpprogram monitor veranderinge in die bronkodegids. As wysigings aan die lêers aangebring word, word dit gesinchroniseer met die toepassingspod in die Kubernetes-kluster. Indien moontlik, sonder om die beeld weer aanmekaar te sit. Andersins word 'n nuwe beeld saamgestel.
2. Die saamgestelde beeld word nagegaan met behulp van houerstruktuur-toets, gemerk en na die Docker-register gestuur.
3. Hierna word die beeld ontplooi - in die Kubernetes-groepering ontplooi.
4. As die bekendstelling geïnisialiseer is met die opdrag skaffold dev, dan begin ons logs van die toepassing ontvang, en Skaffold wag vir veranderinge om al die aksies weer te herhaal.

Illustrasie van die hoofstadia van Skaffold-operasie

Oefen. Skaffold probeer

Om die gebruik van Skaffold te demonstreer, sal ek 'n voorbeeld neem uit GitHub-projekbewaarplek. Terloops, daar Jy kan baie ander voorbeelde vind wat verskeie besonderhede in ag neem. Ek sal alle aksies plaaslik in Minikube uitvoer. Installasie is eenvoudig en neem 'n paar minute, en jy sal kubectl nodig hê om te begin.

Installeer 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

Kom ons kloon Skaffold se bewaarplek met die nodige voorbeelde:

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

Ek het 'n voorbeeld gekies met twee peule, wat elkeen een klein Go-toepassing bevat. Een toepassing is die voorkant (leeroy-web), wat die versoek herlei na die tweede toepassing - die agterkant (leeroy-toepassing). Kom ons kyk hoe dit lyk:

~/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 en leeroy-web bevat Go-kode en eenvoudige Docker-lêers om hierdie kode plaaslik te bou:

~/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 .

Ek sal nie die aansoekkode gee nie - dit is genoeg om dit te weet leeroy-web aanvaar versoeke en volmag dit aan leeroy-app. Daarom in die lêers Deployment.yaml daar is slegs 'n Diens vir app (vir interne roetering). Podpoort web ons sal dit aan onsself aanstuur vir vinnige toegang tot die toepassing.

Dit lyk soos 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

Al die stadiums hierbo genoem word hier beskryf. Benewens hierdie konfigurasie, is daar ook 'n lêer met globale instellings - ~/.skaffold/config. Dit kan met die hand of via die CLI geredigeer word - byvoorbeeld, soos volg:

skaffold config set --global local-cluster true

Hierdie opdrag sal die globale veranderlike stel local-cluster tot betekenis true, waarna Skaffold nie sal probeer om beelde na die afgeleë register te stoot nie. As jy plaaslik ontwikkel, kan jy hierdie opdrag gebruik om beelde plaaslik te bou.

Terug na skaffold.yaml:

• Op die verhoog build ons spesifiseer dat jy die prent plaaslik moet versamel en stoor. Nadat die bou vir die eerste keer uitgevoer is, sal ons die volgende sien:

  // т.к. 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

  Soos jy kan sien, het Skaffold die beelde self gemerk. Terloops, verskeie merkbeleide word ondersteun.

• Verder in die konfigurasie word dit aangedui context: ./leeroy-app/, d.w.s. die konteks waarin die beeld versamel word, word gespesifiseer.
• By die ontplooiingstadium word bepaal dat ons kubectl en 'n masker sal gebruik vir die nodige manifeste.
• PortForward: soortgelyk aan hoe ons gewoonlik poorte aanstuur met behulp van kubectl port-forward, gee ons instruksies aan Skaffold om hierdie opdrag te noem. In hierdie geval word plaaslike poort 9000 na 8080 in Ontplooiing aangestuur met die naam leeroy-web.

Dit is tyd om te begin skaffold dev: Die span sal 'n deurlopende "terugvoerlus" skep, m.a.w. dit sal nie net alles versamel en dit na die groepering ontplooi nie, maar sal jou ook vertel van die toestand van die peule op die oomblik, veranderinge monitor en die toestand van die peule opdateer.

Hier is die bekendstellingresultaat skaffold dev --port-forward by hermontering:

Eerstens kan jy sien dat die kas gebruik word. Vervolgens word die toepassing saamgestel, ontplooi en poorte word aangestuur. Sedert gespesifiseer --port-forward, het Skaffold die hawe aangestuur na web, soos hy gevra is, maar hier app hy het na eie goeddunke gegooi (die naaste vry een gekies). Hierna ontvang ons die eerste logs van die toepassings.

Kom ons kyk of dit werk?

~/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!!!

Wysiging van die lêer leeroy-app/app.go - 'n paar sekondes gaan verby... en:

~/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!!!

Terselfdertyd het Skaffold self dieselfde ding in die konsole vertoon as voorheen, met die uitsondering van een punt: dit het net uitgerol leeroy-app, en nie alles op een slag nie.

Meer oefening

Dit is ook die moeite werd om te noem dat wanneer 'n nuwe projek geskep word, konfigurasies vir Skaffold met behulp van die opdrag stewel kan word init, wat baie gerieflik is. Daarbenewens kan jy verskeie konfigurasies skryf: ontwikkel ontwikkeling op die verstek konfigurasie, en rol dan uit na die verhoog met die opdrag run (dieselfde proses as dev, monitor net nie veranderinge nie), met behulp van 'n ander konfigurasie.

Op katacoda is daar leierskap Dit is selfs makliker met 'n voorbeeld. Maar dit bied 'n klaargemaakte sandbox met Kubernetes, 'n toepassing en Skaffold. 'n Goeie opsie as jy daarin belangstel om self die basiese beginsels uit te probeer.

Een moontlike gebruiksgeval vir Skaffold is om ontwikkeling op 'n afgeleë groepering uit te voer. Nie almal is gemaklik om Minikube op hul eie hardeware te laat loop, dan die toepassing uit te rol en te verwag dat dit voldoende sal funksioneer nie... In hierdie geval los Skaffold die probleem perfek op, wat byvoorbeeld deur Reddit-ingenieurs bevestig kan word, soos ons het reeds bespreek писали in ons blog.

En in hierdie publikasie van Weaveworks kan jy 'n voorbeeld vind van die skep van 'n pyplyn vir produksie.

Gevolgtrekking

Skaffold is 'n gerieflike hulpmiddel vir die bou van pyplyne wat die uitrol van toepassings na Kubernetes behels en hoofsaaklik op ontwikkelingsbehoeftes gefokus is. Dit maak dit redelik maklik om 'n "kort" pyplyn te skep wat die basiese behoeftes van die ontwikkelaar in ag neem, maar as jy wil, kan jy groter prosesse organiseer. As een van die duidelike voorbeelde van die gebruik van Skaffold in CI/CD-prosesse is gegee sulke toets projek van 10 mikrodienste wat die vermoëns van Kubernetes, gRPC, Istio en OpenCensus Tracing gebruik.

Skaffold het reeds byna 8000+ sterre op GitHub, is ontwikkel deur Google en is deel van GoogleContainerTools — in die algemeen is daar op die oomblik alle rede om te glo dat die projek vir ewig en gelukkig sal ontwikkel.

PS

Lees ook op ons blog:

• «Gereedskap vir ontwikkelaars van toepassings wat op Kubernetes loop»;
• «werf - ons hulpmiddel vir CI / CD in Kubernetes (oorsig en videoverslag)»;
• «Tuin v0.10.0: Jou skootrekenaar het nie Kubernetes nodig nie»;
• «Kubernetes wenke en truuks: oor plaaslike ontwikkeling en Telepresence".

Bron: will.com