Brug af Helm og Kubernetes

1. Oversigt

Helm er en pakkehåndtering til Kubernetes-applikationer. I denne vejledning forstår vi det grundlæggende i Helm, og hvordan de danner et kraftfuldt værktøj til at arbejde med Kubernetes-ressourcer.

I løbet af de sidste år er Kubernetes vokset enormt, og økosystemet støtter det også. For nylig er Helm blevet annonceret som et inkubationsprojekt af Cloud Native Computing Foundation (CNCF), der viser sin voksende popularitet blandt Kubernetes-brugere.

2. Baggrund

Selvom disse udtryk er ret almindelige i disse dage, især blandt dem, der arbejder med skyteknologier, lad os gå igennem dem hurtigt for de uvidende:

Beholder: Container henviser til virtualisering af operativsystemniveau. Flere containere kører i et operativsystem i isolerede brugerrum. Programmer, der kører i en container, har kun adgang til ressourcer, der er tildelt containeren.
Docker: Docker er et populært program til at oprette og køre containere. Den leveres med Docker Daemon, som er det vigtigste program, der administrerer containere. Docker Daemon giver adgang til dets funktioner gennem Docker Engine API, som bruges af Docker Command-Line Interface (CLI). Se denne artikel for en mere detaljeret beskrivelse af Docker.
Kubernetes: Kubernetes er et populært program til containerorkestrering. Selvom det er designet til at arbejde med forskellige containere, bruges Docker oftest. Det tilbyder et bredt udvalg af funktioner, herunder automatisering af implementering, skalering og operationer på tværs af en klynge af værter. Der er fremragende dækning af Kubernetes i denne artikel til yderligere reference.

3. Rorarkitektur

Helm har en ret simpel arkitektur, der består af en klient og en in-cluster-server:

Tiller Server: Helm administrerer Kubernetes-applikationen gennem en komponent kaldet Tiller Server installeret i en Kubernates-klynge. Tiller interagerer med Kubernetes API-server for at installere, opgradere, forespørge og fjerne Kubernetes-ressourcer.
Helm-klient: Helm giver en kommandolinjegrænseflade, som brugerne kan arbejde med Helm Charts. Helm Client er ansvarlig for at interagere med Tiller Server for at udføre forskellige operationer som installation, opgradering og tilbagevendende diagrammer.

4. Roretabeller

Helm administrerer Kubernetes ressourcepakker gennem diagrammer.

Vi ser mere om diagrammer, når vi opretter dem kort tid, men for nu er et diagram intet andet end et sæt information, der er nødvendigt for at oprette en Kubernetes-applikation givet en Kubernetes-klynge:

EN diagram er en samling af filer organiseret i en bestemt katalogstruktur
Konfigurationsoplysningerne relateret til et diagram styres i konfigurationen
Langt om længe, en kørende forekomst af et diagram med en bestemt konfiguration kaldes en frigivelse

5. Opsætning

Vi har brug for et par ting, der skal opsættes på forhånd, for at vi kan udvikle vores første rordiagram.

For det første har vi brug for en Kubernetes-klynge for at begynde at arbejde med Helm. Til denne tutorial bruger vi Minikube, som tilbyder en fremragende måde at arbejde med en enkelt-node Kubernetes-klynge lokalt. På Windows er det nu muligt at bruge Hyper-V som den native Hypervisor til at køre Minikube. Se denne artikel for at forstå opsætningen af Minikube i flere detaljer.

Og vi har brug for en grundlæggende applikation til at administrere inden for Kubernetes-klyngen. Til denne vejledning bruger vi en simpel Spring Boot-applikation pakket som en Docker-container. For en mere detaljeret beskrivelse af, hvordan man pakker en sådan applikation som en Docker-container, henvises til denne artikel.

6. Installation af ror

Der er flere måder at installere Helm på, der er pænt beskrevet på den officielle installationsside på Helm. Den hurtigste måde at installere ror på Windows på er at bruge Chocolaty, en pakkehåndtering til Windows-platforme.

Ved hjælp af Chocolaty er det en simpel en-linjekommando at installere Helm:

choco installere kubernetes-helm

Dette installerer Helm-klienten lokalt.

Nu er vi nødt til at initialisere Helm CLI, som effektivt også installerer Tiller Server på en Kubernetes-klynge som identificeret gennem Kubernetes-konfigurationen. Vær venlig sikre, at Kubernetes-klyngen kører og er tilgængelig igennem kubectl inden du initialiserer Helm:

kubectl klynge-info

Og så kan vi initialisere Helm gennem selve Helm CLI:

ror init

7. Udvikling af vores første diagram

Nu er vi klar til at udvikle vores første hjelmdiagram med skabeloner og værdier.

7.1. Oprettelse af et diagram

Helm CLI, som vi installerede tidligere, er ret praktisk til at oprette et diagram:

ror skaber hej-verden

Bemærk, at navnet på kortet, der er angivet her, er navnet på den mappe, hvor diagrammet oprettes og gemt.

Lad os hurtigt se katalogstrukturen oprettet for os:

hej-verden / Chart.yaml-værdier.yaml-skabeloner / charts / .helmignore

Lad os forstå relevansen af disse filer og mapper oprettet for os:

Chart.yaml: Dette er hovedfilen, der indeholder beskrivelsen af vores diagram
værdier.yaml: dette er den fil, der indeholder standardværdierne for vores diagram
skabeloner: Dette er det bibliotek, hvor Kubernetes-ressourcer er defineret som skabeloner
diagrammer: Dette er en valgfri mappe, der kan indeholde underkort
.helmignore: Det er her, vi kan definere mønstre, der skal ignoreres, når vi pakker (ligner konceptet .gitignore)

7.2. Opretter skabelon

Hvis vi ser inde i skabelonkataloget, bemærker vi det få skabeloner til almindelige Kubernetes-ressourcer er allerede oprettet for os:

hej-verden / skabeloner / deployment.yaml service.yaml ingress.yaml ......

Vi har muligvis brug for nogle af disse og muligvis andre ressourcer i vores applikation, som vi bliver nødt til at oprette selv som skabeloner.

Til denne vejledning opretter vi implementering og en tjeneste, der udsætter implementeringen. Bemærk, at vægten her ikke er at forstå Kubernetes i detaljer. Derfor holder vi disse ressourcer så enkle som muligt.

Lad os redigere filen deployment.yaml inde i skabeloner katalog til at se ud:

apiVersion: apps / v1 kind: Implementeringsmetadata: navn: {{inkluderer "hello-world.fullname". }} etiketter: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} helm.sh/chart: {{inkluderer "hej-world.chart". }} app.kubernetes.io/instance: {{.Release.Name}} app.kubernetes.io/managed-by: {{.Release.Service}} spec: replikaer: {{.Values.replicaCount}} vælger: matchLabels: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} app.kubernetes.io/instance: {{.Release.Name}} skabelon: metadata: labels: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} app.kubernetes.io/instance: {{.Release.Name}} spec: containere: - navn: {{.Chart.Name}} billede: "{{.Values.image.repository}}: {{. Values.image.tag}} "imagePullPolicy: {{.Values.image.pullPolicy}} porte: - navn: http containerPort: 8080 protokol: TCP

Lad os ligeledes redigere filen service.yaml at se ud som:

apiVersion: v1 kind: Service metadata: name: {{include "hello-world.fullname". }} etiketter: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} helm.sh/chart: {{inkluderer "hej-world.chart". }} app.kubernetes.io/instance: {{.Release.Name}} app.kubernetes.io/managed-by: {{.Release.Service}} spec: type: {{.Values.service.type}} porte: - port: {{.Values.service.port}} targetPort: http-protokol: TCP-navn: http-vælger: app.kubernetes.io/navn: {{inkluderer "hello-world.name". }} app.kubernetes.io/instance: {{.Release.Name}}

Nu, med vores viden om Kubernetes, ser disse skabelonfiler ret velkendte ud med undtagelser. Bemærk den liberale brug af tekst inden for dobbelte parenteser {{}}. Dette kaldes et skabelondirektiv.

Helm gør brug af Go-skabelonsproget og udvider det til noget, der kaldes Helm-skabelonsprog. Under evalueringen sendes hver fil i skabelonkataloget til skabelon-gengivelsesmotoren. Det er her, skabelondirektivet injicerer faktiske værdier i skabelonerne.

7.3. Tilvejebringelse af værdier

I det forrige underafsnit så vi, hvordan vi bruger skabelondirektivet i vores skabeloner. Lad os nu forstå, hvordan vi kan overføre værdier til skabelonretningsmotoren. Vi sender typisk værdier gennem indbyggede objekter i roret.

Der er mange sådanne objekter tilgængelige i Helm, som frigivelse, værdier, diagram og filer.

Vi kan bruge filen værdier.yaml i vores diagram for at overføre værdier til skabelon-gengivelsesmotoren gennem de indbyggede objektværdier. Lad os ændre værdier.yaml at se ud som:

replicaCount: 1 image: repository: "hello-world" tag: "1.0" pullPolicy: IfNotPresent service: type: NodePort port: 80

Bemærk dog, hvordan disse værdier er åbnet i skabeloner ved hjælp af prikker, der adskiller navneområder. Vi har brugt billedopbevaringsstedet og tagget som "hej-verden" og "1.0", dette skal matche det docker-billedtag, vi oprettede til vores Spring Boot-applikation.

8. Forståelse af rorkommandoer

Med alt gjort indtil videre er vi nu klar til at spille med vores diagram. Lad os se, hvad de forskellige kommandoer er tilgængelige i Helm CLI for at gøre dette sjovt!

8.1. Helm Lint

For det første er dette en simpel kommando, der tager stien til et diagram og kører et batteri af tests for at sikre, at diagrammet er velformet:

helm lint ./hello-world ==> Linting ./hello-world 1 diagram (er) fnugget, ingen fejl

8.2 Hjelmskabelon

Vi har også denne kommando til at gengive skabelonen lokalt uden en Tiller Server for hurtig feedback:

helm-skabelon ./hello-world --- # Kilde: hello-world / templates / service.yaml apiVersion: v1 kind: Service metadata: name: release-name-hello-world labels: app.kubernetes.io/name: hej -world helm.sh/chart: hello-world-0.1.0 app.kubernetes.io/instance: release-name app.kubernetes.io/managed-by: Tiller spec: type: NodePort porte: - port: 80 targetPort: http-protokol: TCP-navn: http-vælger: app.kubernetes.io/navn: hello-world app.kubernetes.io/instance: release-name --- # Kilde: hello-world / templates / deployment.yaml apiVersion: apps / v1 kind: Implementeringsmetadata: navn: release-name-hello-world labels: app.kubernetes.io/name: hello-world helm.sh/chart: hello-world-0.1.0 app.kubernetes.io/instance: release -navn app.kubernetes.io/managed-by: Tiller spec: replikaer: 1 vælger: matchLabels: app.kubernetes.io/name: hej-world app.kubernetes.io/instance: release-name skabelon: metadata: labels: app.kubernetes.io/name: hello-world app.kubernetes.io/instance: release-name spec: containere: - na mig: hello-world image: "hello-world: 1.0" imagePullPolicy: IfNotPresent porte: - navn: http containerPort: 8080 protokol: TCP

8.3. Rorinstallation

Når vi først har verificeret, at diagrammet er fint, kan vi endelig køre denne kommando for at installere diagrammet i Kubernetes-klyngen:

rorinstallation --navn hej-verden ./hello-world NAVN: hej-verden SIDST ANVENDT: Man Feb 25 15:29:59 2019 NAVNOMRÅDE: standard STATUS: UDFYLDTE RESSOURCER: ==> v1 / Service NAVN TYPE CLUSTER-IP EKSTERN -IP PORT (S) AGE hello-world NodePort 10.110.63.169 80: 30439 / TCP 1s ==> v1 / Implementering NAVN ØNSKET LØBENDE UPT-DATE TILGÆNGELIG ALDER hello-world 1 0 0 0 1s ==> v1 / Pod (relateret) NAVN KLAR STATUS RESTARTS ALDER hello-world-7758b9cdf8-cs798 0/1 Afventer 0 0s

Endelig bemærk, at vi har navngivet frigivelsen af dette diagram med flagnavnet. Kommandoen svarer med resuméet af Kubernetes-ressourcer oprettet i processen.

8.4. Helm Get

Nu vil vi gerne se, hvilke diagrammer der er installeret som hvilken udgivelse. Denne kommando giver os mulighed for at forespørge på de navngivne udgivelser:

helm ls - alle NAVN REVISION OPDATERET STATUS CHART APP VERSION NAMESPACE hello-world 1 Mon Feb 25 15:29:59 2019 DEPLOYED hello-world-0.1.0 1.0 standard

8.5. Roropgradering

Hvad hvis vi har ændret vores diagram og har brug for at installere den opdaterede version? Denne kommando hjælper os med at opgradere en frigivelse til en specificeret eller aktuel version af diagrammet eller konfigurationen:

helm-opgradering hello-world ./hello-world Udgivelse "hello-world" er blevet opgraderet. Happy Helming! SIDSTE OPLYSNINGER: Man 25 feb 15:36:04 2019 NAVNSTED: standard STATUS: AFFYLDTE RESSOURCER: ==> v1 / Tjeneste NAVN TYPE CLUSTER-IP EKSTERN-IP-PORT (ER) ALDER Hello-world NodePort 10.110.63.169 80: 30439 / TCP 6m5s ==> v1 / Implementering NAVN ØNSKET AKTUELT OP-TIL DATUM TILGÆNGELIG ALDER hej-verden 1 1 1 1 6m5s ==> v1 / Pod (relateret) NAVN KLAR STATUS OMSTART ALDER hello-world-7758b9cdf8-cs798 1/1 Kører 0 6m4s

8.6. Ror tilbageslag

Det kan altid ske, at en frigivelse gik galt og skal tages tilbage. Dette er kommandoen til at tilbageføre en frigivelse til den tidligere version:

helm rollback hello-world 1 Rollback var en succes! Happy Helming!

8.7. Helm Delete

Selvom det er mindre sandsynligt, vil vi måske slette en udgivelse fuldstændigt. Vi kan bruge denne kommando til at slette en frigivelse fra Kubernetes:

helm delete - purge hello-world release "hallo-world" slettet

Dette er kun nogle af de kommandoer, der er tilgængelige for at arbejde med diagrammer og udgivelser i Helm.

9. Distribuering af diagrammer

Mens skabeloner er et kraftfuldt værktøj, som Helm bringer til en verden af administration af Kubernetes-ressourcer, er det ikke den eneste fordel ved at bruge Helm. Som vi så i det forrige afsnit, fungerer Helm som en pakkehåndtering for Kubernetes-applikationen og gør installation, forespørgsel, opgradering og sletning af udgivelser ret problemfri.

Ud over dette, Helm leveres med kommandoer som en del af sin CLI til at pakke, udgive og hente Kubernetes-applikationer som diagrammer:

9.1. Rorpakke

For det første skal vi pakke de diagrammer, vi har oprettet, for at kunne distribuere dem. Dette er kommandoen til at oprette versionerede arkivfiler i diagrammet:

helm-pakke ./hello-world Pakket diagram og gemt det til: \ hello-world \ hello-world-0.1.0.tgz

Bemærk, at det producerer et arkiv på din maskine, der kan distribueres manuelt eller gennem offentlige eller private kortopbevaringssteder.

9.2. Helm Repo

Endelig har vi brug for en mekanisme til at arbejde med delte arkiver for at samarbejde. Repo samler en række kommandoer, som vi kan bruge til at tilføje, fjerne, liste eller indeksere diagramopbevaringssteder. Lad os se, hvordan vi kan bruge dem.

Vi kan oprette et git-arkiv og bruge det til at fungere som vores diagramregister. Det eneste krav er, at det skal have en index.yaml fil.

Vi kan skabe index.yaml til vores diagram repo:

helm repo index my-repo / --url //.github.io/my-repo

Dette genererer index.yaml fil, som vi skal skubbe til arkivet sammen med diagramarkiverne.

Efter vellykket oprettelse af diagramopbevaringsområdet kan vi efterfølgende tilføje denne repo eksternt:

helm repo tilføj my-repo //my-pages.github.io/my-repo

Nu skal vi være i stand til at installere kortene fra vores repo direkte:

ror installerer min-repo / hej-verden - navn = hej-verden

Der er en række hjælpekommandoer til rådighed til at arbejde med kortopbevaringssteder.

10. Konklusion

For at opsummere diskuterede vi i denne vejledning kernekomponenterne i Helm, en pakkehåndtering til Kubernetes-applikationer. Vi forstod mulighederne for at installere Helm. Desuden gennemgik vi oprettelse af et eksempeldiagram og skabeloner med værdier.

Derefter gennemgik vi flere tilgængelige kommandoer som en del af Helm CLI for at administrere Kubernetes-applikationen som en Helm-pakke.

Endelig diskuterede vi mulighederne for at distribuere Helm-pakker gennem arkiver.

streamalism.org