Iwwerpréiwung vun Skaffold fir Kubernetes Entwécklung

Virun engem Joer an en halleft, de 5. Mäerz 2018, huet Google déi éischt Alpha Versioun vu sengem Open Source Projet fir CI / CD verëffentlecht genannt Skaffold, deem säin Zil war "einfach a widderhuelend Kubernetes Entwécklung" ze kreéieren, sou datt d'Entwéckler sech op d'Entwécklung konzentréieren anstatt d'Administratioun. Wat kéint iwwer Skaffold interessant sinn? Wéi et sech erausstellt, huet et e puer Tricken op der Hülse, déi et e mächtegt Tool fir den Entwéckler maachen, a vläicht souguer den Operatiounsingenieur. Loosst eis mam Projet a seng Fäegkeeten kennen léieren.

NB: Mir hunn iwwregens schonn kuerz iwwer Skaffold an eisem Generol geschwat Iwwerpréiwung vun Entwéckler Tools, deem säi Liewen mat Kubernetes verbonnen ass.

Theorie. Zweck a Fäegkeeten

Also, allgemeng geschwat, léist Skaffold de Problem fir den CI / CD-Zyklus ze automatiséieren (bei de Bau-, Push-, Deploystadien), den Entwéckler prompt Feedback ze bidden, d.h. d'Kapazitéit fir séier d'Resultat vun de spéider Code Ännerungen ze kréien - a Form vun enger aktualiséierter Applikatioun déi am Kubernetes Cluster leeft. An et kann a verschiddene Circuiten funktionnéieren (Dev, Bühn, Produktioun ...), fir déi Skaffold hëlleft fir déi entspriechend Pipelines fir d'Rollout ze beschreiwen.

De Quellcode vum Skaffold ass a Go geschriwwen, verdeelt duerch ënner der gratis Apache Lizenz 2.0 (GitHub).

Loosst eis d'Haaptfunktiounen a Fonctiounen kucken. Déi éischt enthalen déi folgend:

• Skaffold bitt Tools fir CI / CD Pipelines ze kreéieren.
• Erlaabt Iech Ännerungen am Quellcode am Hannergrond ze iwwerwaachen an en automatiséierte Prozess auszeféieren fir Code a Containerbiller ze sammelen, dës Biller an der Docker Registry ze publizéieren an se an de Kubernetes Cluster z'installéieren.
• Synchroniséiert Dateien am Repository mam Aarbechtsverzeechnes am Container.
• Automatesch Tester mat Container-Struktur-Test.
• Forward Häfen.
• Liest d'Logbicher vun enger Applikatioun déi an engem Container leeft.
• Hëlleft bei Debugging Uwendungen geschriwwen op Java, Node.js, Python, Go.

Elo iwwer d'Features:

• Skaffold selwer huet keng Stärekoup-Säit Komponente. Dat ass, et ass net néideg Kubernetes weider ze konfiguréieren fir dësen Utility ze benotzen.
• Verschidde Pipelines fir Är Applikatioun. Braucht Dir de Code op lokal Minikube ausrollen wärend Dir entwéckelt, an dann op d'Bühn oder d'Produktioun? Fir dësen Zweck ginn et Profiler a Benotzerkonfiguratiounen, Ëmfeldvariablen a Fändelen, déi Iech erlaben verschidde Pipelines fir eng Applikatioun ze beschreiwen.
• CLI. Nëmmen Konsol Utility a Konfiguratiounen am YAML. Um Internet fannt Dir Referenze fir Versich ze kreéieren experimentell GUI, awer, am Moment heescht dat héchstwahrscheinlech just datt een hien brauch, awer net wierklech.
• Modularitéit. Skaffold ass net e Standalone Harvester, awer zielt fir eenzel Moduler oder existent Léisunge fir spezifesch Aufgaben ze benotzen.

Illustratioun vun der leschter:

• Op der Montagestadium kënnt Dir benotzen:
  • Docker baut lokal, an engem Cluster mat Kaniko oder am Google Cloud Build;
  • Bazel lokal;
  • Jib Maven a Jib Gradle lokal oder am Google Cloud Build;
  • Benotzerdefinéiert Build Scripte lafen lokal. Wann Dir eng aner (méi flexibel/vertraut/...) Bauléisung ausféiere musst, gëtt se am Skript beschriwwen, sou datt Skaffold se lancéiert (Beispill aus Dokumentatioun). Dëst erlaabt Iech all Sammler ze benotzen, datt mat engem Skript genannt ginn;
• An der Testphase, déi schonn erwähnt Container-Struktur-Test;
• Fir den Ofbau ginn déi folgend virgesinn:
  • Kubectl;
  • Helm;
  • personaliséiere.

Dank dësem kann Skaffold eng eenzegaarteg genannt ginn Kader fir Gebai CI / CD. Hei ass e Beispill Workflow wann Dir et benotzt (aus der Projektdokumentatioun):

Wéi gesäit dem Skaffold seng Aarbecht allgemeng aus?

1. D'Utility iwwerwaacht Ännerungen am Quellcode-Verzeichnis. Wann Ännerungen op d'Dateien gemaach ginn, gi se mat der Applikatioun Pod am Kubernetes Cluster synchroniséiert. Wa méiglech, ouni d'Bild erëm ze montéieren. Soss gëtt en neit Bild zesummegesat.
2. Dat gesammelt Bild gëtt iwwerpréift mat Container-Struktur-Test, markéiert an an den Docker Registry geschéckt.
3. Duerno gëtt d'Bild ofgesat - am Kubernetes Cluster ofgesat.
4. Wann de Start mat dem Kommando initialiséiert gouf skaffold dev, da fänken mer Logbicher vun der Applikatioun ze kréien, a Skaffold waart op Ännerungen fir all d'Aktiounen erëm ze widderhuelen.

Illustratioun vun den Haaptstadien vun Skaffold Operatioun

Praxis. Probéieren Skaffold

Fir d'Benotzung vu Skaffold ze demonstréieren, huelen ech e Beispill aus GitHub Projet Repository. Iwwregens, do Dir kënnt vill aner Beispiller fannen déi verschidde Spezifizitéiten berücksichtegen. Ech wäert all Aktiounen lokal am Minikube Leeschtunge. Installatioun ass einfach an dauert e puer Minutten, an Dir braucht kubectl fir unzefänken.

Installéiert 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

Loosst eis dem Skaffold säi Repository mat den néidege Beispiller klone:

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

Ech hunn e Beispill mat zwee Pods gewielt, all mat enger klenger Go Applikatioun. Eng Applikatioun ass de Frontend (leeroy-Web), deen d'Ufro op déi zweet Applikatioun redirectéiert - de Backend (leeroy-App). Loosst eis kucken wéi et ausgesäit:

~/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 a leeroy-web enthalen Go Code an einfach Dockerfiles fir dëse Code lokal ze bauen:

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

Ech ginn den Uwendungscode net - et ass genuch dat ze wëssen leeroy-web akzeptéiert Ufroen a proxéiert hinnen leeroy-app. Dofir an de Fichieren Deployment.yaml et gëtt nëmmen e Service fir app (fir intern Routing). Pod port web mir wäerten et fir eis selwer weider fir séier Zougang zu der Applikatioun.

Gesäit sou äus 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

All déi uewe genannte Stadien ginn hei beschriwwen. Zousätzlech zu dëser Configuratioun gëtt et och e Fichier mat globalen Astellungen - ~/.skaffold/config. Et kann manuell oder iwwer den CLI geännert ginn - zum Beispill, sou:

skaffold config set --global local-cluster true

Dëse Kommando wäert d'global Variabel setzen local-cluster an Bedeitung true, no deem Skaffold net probéiert Biller an d'Remote Registry ze drécken. Wann Dir lokal entwéckelt, kënnt Dir dëse Kommando benotze fir Biller lokal ze bauen.

Zreck skaffold.yaml:

• Op der Bühn build mir spezifizéieren, datt Dir d'Bild lokal ze sammelen a späicheren muss. Nodeems de Bau fir d'éischte Kéier leeft, gesi mir déi folgend:

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

  Wéi Dir gesitt, huet Skaffold d'Biller selwer markéiert. Iwwregens, verschidde Tagging Politiken ginn ënnerstëtzt.

• Weider an der Configuratioun gëtt et uginn context: ./leeroy-app/, d.h. de Kontext an deem d'Bild gesammelt ass, gëtt uginn.
• An der Deploymentphase gëtt festgeluecht datt mir kubectl an eng Mask fir déi néideg Manifestatiounen benotzen.
• PortForward: ähnlech wéi mir normalerweis Ports weider benotzen kubectl port-forward, Mir ginn Instruktioune fir Skaffold fir dëse Kommando ze ruffen. An dësem Fall gëtt de lokale Port 9000 op 8080 an Deployment mam Numm weidergeleet leeroy-web.

Et ass Zäit fir ze starten skaffold dev: D'Equipe wäert eng lafend "Feedback Loop" erstellen, d.h. et wäert net nëmmen alles sammelen an et an de Cluster ofsetzen, mee wäert Iech och iwwer den Zoustand vun de Pods am Moment erzielen, Ännerungen iwwerwaachen an den Zoustand vun de Pods aktualiséieren.

Hei ass d'Startresultat skaffold dev --port-forward beim Réassemblement:

Als éischt kënnt Dir gesinn datt de Cache benotzt gëtt. Als nächst gëtt d'Applikatioun zesummegesat, ofgesat, an d'Ports ginn weidergeleet. Zënter uginn --port-forward, Skaffold huet den Hafen weidergeleet web, wéi hie gefrot gouf, awer hei app hie geheien op seng eegen Diskretioun (gewielt der noosten fräi ). Duerno kréie mir déi éischt Logbicher vun den Uwendungen.

Loosst eis kucken ob et funktionnéiert?

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

Änneren vun der Datei leeroy-app/app.go - e puer Sekonnen passéieren ... an:

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

Zur selwechter Zäit huet Skaffold selwer datselwecht an der Konsole gewisen wéi virdrun, mat Ausnam vun engem Punkt: et ass just erausgerappt leeroy-app, an net alles op eemol.

Méi Praxis

Et ass och derwäert ze ernimmen datt wann Dir en neie Projet erstellt, Konfiguratioune fir Skaffold kënne bootstrapped mam Kommando init, wat ganz bequem ass. Zousätzlech kënnt Dir verschidde Konfiguratioune schreiwen: Entwécklung op der Standardkonfiguratioun ausféieren, an dann op d'Bühn mat dem Kommando ausrollen run (selwechte Prozess wéi dev, iwwerwaacht just keng Ännerungen), mat enger anerer Configuratioun.

Op katacoda gëtt et Leadership Et ass nach méi einfach mat engem Beispill. Awer et bitt eng fäerdeg Sandkëscht mat Kubernetes, eng Applikatioun an Skaffold. Eng super Optioun wann Dir interesséiert sidd fir d'Basis selwer ze probéieren.

Ee méigleche Benotzungsfall fir Skaffold ass d'Entwécklung op engem Ferncluster ze féieren. Net jiddereen ass bequem mam Minikube op senger eegener Hardware ze lafen, dann d'Applikatioun auszerollen an ze erwaarden datt se adäquat funktionnéiert ... An dësem Fall léist Skaffold de Problem perfekt, wat zum Beispill vun Reddit Ingenieuren bestätegt ka ginn, wéi mir hunn schonn diskutéiert geschriwwen an eisem Blog.

An a vun dëser Publikatioun vu Weaveworks fannt Dir e Beispill fir eng Pipeline fir d'Produktioun ze kreéieren.

Konklusioun

Skaffold ass e praktescht Tool fir Pipelines ze bauen déi Uwendungen op Kubernetes ausrollen a sech haaptsächlech op Entwécklungsbedürfnisser fokusséieren. Et mécht et ganz einfach eng "kuerz" Pipeline ze kreéieren déi d'Basisbedierfnesser vum Entwéckler berücksichtegt, awer wann Dir wëllt, kënnt Dir méi grouss Prozesser organiséieren. Als ee vun de kloer Beispiller vun engem benotzen Skaffold an CI / CD Prozesser gëtt esou Test Projet vun 10 Mikroservicer mat de Fäegkeete vu Kubernetes, gRPC, Istio an OpenCensus Tracing.

Skaffold huet scho bal 8000+ Stären op GitHub, gëtt vu Google entwéckelt an ass Deel vun GoogleContainerTools - am Allgemengen, am Moment ass et all Grond ze gleewen, datt de Projet ëmmer glécklech wäert entwéckelen.

PS

Liest och op eisem Blog:

• «Tools fir Entwéckler vun Uwendungen déi op Kubernetes lafen";
• «werf - eisen Tool fir CI / CD zu Kubernetes (Iwwerbléck a Videobericht)";
• «Gaart v0.10.0: Äre Laptop brauch net Kubernetes";
• «Kubernetes Tipps & Tricks: iwwer lokal Entwécklung an Telepresence".

Source: will.com