Bruke Helm og Kubernetes

1. Oversikt

Helm er en pakkeleder for Kubernetes-applikasjoner. I denne opplæringen vil vi forstå det grunnleggende om Helm og hvordan de danner et kraftig verktøy for å jobbe med Kubernetes-ressurser.

I løpet av de siste årene har Kubernetes vokst enormt, og det har også økosystemet som støtter det. Nylig har Helm blitt kunngjort som et inkubasjonsprosjekt av Cloud Native Computing Foundation (CNCF), som viser sin økende popularitet blant Kubernetes-brukere.

2. Bakgrunn

Selv om disse vilkårene er ganske vanlige i disse dager, spesielt blant de som jobber med skyteknologier, la oss gå gjennom dem raskt for de som ikke er klar over:

Container: Container refererer til virtualisering på operativsystemnivå. Flere containere kjøres i et operativsystem i isolerte brukerområder. Programmer som kjører i en container har kun tilgang til ressurser som er tilordnet containeren.
Docker: Docker er et populært program for å lage og kjøre containere. Den kommer med Docker Daemon, som er hovedprogrammet for administrering av containere. Docker Daemon gir tilgang til funksjonene sine via Docker Engine API, som brukes av Docker Command-Line Interface (CLI). Se denne artikkelen for en mer detaljert beskrivelse av Docker.
Kubernetes: Kubernetes er et populært program for containerorkestrering. Selv om det er designet for å fungere med forskjellige containere, brukes Docker oftest. Det tilbyr et bredt utvalg av funksjoner, inkludert automatisering av distribusjon, skalering og operasjoner på tvers av en gruppe kamper. Det er utmerket dekning av Kubernetes i denne artikkelen for nærmere referanse.

3. Rorarkitektur

Helm har en ganske enkel arkitektur, som består av en klient og en in-cluster server:

Tiller Server: Helm administrerer Kubernetes-applikasjonen gjennom en komponent som heter Tiller Server installert i en Kubernates-klynge. Tiller samhandler med Kubernetes API-server for å installere, oppgradere, spørre og fjerne Kubernetes-ressurser.
Helm-klient: Helm gir et kommandolinjegrensesnitt for brukere å jobbe med Helm Charts. Helm Client er ansvarlig for å samhandle med Tiller Server for å utføre forskjellige operasjoner som installasjon, oppgradering og tilbakestilling av diagrammer.

4. Roretabeller

Helm administrerer Kubernetes ressurspakker gjennom Charts.

Vi ser mer om diagrammer når vi oppretter dem snart, men foreløpig er et diagram ikke annet enn et sett med informasjon som er nødvendig for å opprette et Kubernetes-program, gitt en Kubernetes-klynge:

EN diagrammet er en samling av filer organisert i en bestemt katalogstruktur
Konfigurasjonsinformasjonen knyttet til et diagram administreres i konfigurasjonen
Endelig, en løpende forekomst av et diagram med en bestemt konfigurasjon kalles en utgivelse

5. Oppsett

Vi trenger et par ting som skal settes opp på forhånd for at vi skal kunne utvikle vårt første roretabell.

For det første, for å begynne å jobbe med Helm, trenger vi en Kubernetes-klynge. For denne opplæringen bruker vi Minikube, som tilbyr en utmerket måte å jobbe med en Kubernetes-klynge med én node lokalt. På Windows er det nå mulig å bruke Hyper-V som den opprinnelige Hypervisor for å kjøre Minikube. Se denne artikkelen for å forstå hvordan du konfigurerer Minikube i flere detaljer.

Og vi trenger et grunnleggende program for å administrere i Kubernetes-klyngen. For denne opplæringen bruker vi en enkel Spring Boot-applikasjon pakket som en Docker-container. For en mer detaljert beskrivelse av hvordan du pakker et slikt program som en Docker-container, se denne artikkelen.

6. Installere ror

Det er flere måter å installere Helm på, som er pent beskrevet på den offisielle installasjonssiden på Helm. Den raskeste måten å installere ror på Windows på er å bruke Chocolaty, en pakkebehandling for Windows-plattformer.

Ved hjelp av Chocolaty er det en enkel en-linjekommando å installere Helm:

choco installere kubernetes-helm

Dette installerer Helm-klienten lokalt.

Nå må vi initialisere Helm CLI, som effektivt også installerer Tiller Server på en Kubernetes-klynge som identifisert gjennom Kubernetes-konfigurasjonen. Vær så snill sørg for at Kubernetes-klyngen kjører og er tilgjengelig gjennom kubectl før du initialiserer Helm:

kubectl cluster-info

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

rorinit

7. Utvikling av vårt første diagram

Nå er vi klare til å utvikle vårt første hjelmdiagram med maler og verdier.

7.1. Lage et diagram

Helm CLI, som vi installerte tidligere, er ganske nyttig for å lage et diagram:

ror skape hei-verden

Vær oppmerksom på at navnet på diagrammet som er gitt her vil være navnet på katalogen der diagrammet er opprettet og lagret.

La oss raskt se katalogstrukturen som er opprettet for oss:

hallo-verden / Chart.yaml-verdier.yaml-maler / diagrammer / .helmignore

La oss forstå relevansen av disse filene og mappene som er opprettet for oss:

Chart.yaml: Dette er hovedfilen som inneholder beskrivelsen av diagrammet vårt
verdier.yaml: dette er filen som inneholder standardverdiene for diagrammet vårt
maler: Dette er katalogen der Kubernetes ressurser er definert som maler
diagrammer: Dette er en valgfri katalog som kan inneholde underkart
.helmignore: Dette er hvor vi kan definere mønstre å ignorere når vi pakker (ligner konseptet på .gitignore)

7.2. Opprette mal

Hvis vi ser inne i malkatalogen, vil vi merke det noen maler for vanlige Kubernetes-ressurser er allerede opprettet for oss:

hallo-verden / maler / deployment.yaml service.yaml ingress.yaml ......

Vi trenger kanskje noen av disse og muligens andre ressurser i applikasjonen vår, som vi må lage selv som maler.

For denne opplæringen oppretter vi distribusjon og en tjeneste for å avsløre distribusjonen. Vær oppmerksom på at vekten her ikke er å forstå Kubernetes i detalj. Derfor vil vi holde disse ressursene så enkle som mulig.

La oss redigere filen distribusjon.yaml inne i maler katalog for å se ut:

apiVersion: apps / v1 type: Implementeringsmetadata: navn: {{inkluderer "hallo-world.fullname". }} etiketter: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} helm.sh/chart: {{inkluderer "hallo-world.chart". }} app.kubernetes.io/instance: {{.Release.Name}} app.kubernetes.io/managed-by: {{.Release.Service}} spec: replikaer: {{.Values.replicaCount}} velger: matchLabels: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} app.kubernetes.io/instance: {{.Release.Name}} mal: metadata: labels: app.kubernetes.io/name: {{include "hello-world.name". }} app.kubernetes.io/instance: {{.Release.Name}} spesifikasjon: containere: - navn: {{.Chart.Name}} bilde: "{{.Values.image.repository}}: {{. Values.image.tag}} "imagePullPolicy: {{.Values.image.pullPolicy}} porter: - navn: http containerPort: 8080 protokoll: TCP

På samme måte, la oss redigere filen service.yaml å se ut som:

apiVersion: v1 type: Tjenestemetadata: navn: {{inkluderer "hallo-world.fullname". }} etiketter: app.kubernetes.io/name: {{inkluderer "hello-world.name". }} helm.sh/chart: {{inkluderer "hallo-world.chart". }} app.kubernetes.io/instance: {{.Release.Name}} app.kubernetes.io/managed-by: {{.Release.Service}} spesifikasjon: type: {{.Values.service.type}} porter: - port: {{.Values.service.port}} targetPort: http-protokoll: TCP-navn: http velger: app.kubernetes.io/navn: {{inkluderer "hallo-verden.navn". }} app.kubernetes.io/instance: {{.Release.Name}}

Nå, med vår kunnskap om Kubernetes, ser disse malfilene ganske kjent ut, med unntak av noen underlige ting. Legg merke til den liberale bruken av tekst i doble parenteser {{}}. Dette er det som kalles et maldirektiv.

Helm benytter Go mal-språket og utvider det til noe som kalles Helm mal-språk. Under evalueringen sendes hver fil i malkatalogen til malgjengivelsesmotoren. Det er her maldirektivet injiserer faktiske verdier i malene.

7.3. Gi verdier

I forrige underavsnitt så vi hvordan man bruker maldirektivet i malene våre. Nå, la oss forstå hvordan vi kan overføre verdier til malgjengivelsesmotoren. Vi sender vanligvis verdier gjennom innebygde objekter i roret.

Det er mange slike objekter tilgjengelig i Helm, som utgivelse, verdier, diagram og filer.

Vi kan bruke filen verdier.yaml i diagrammet vårt for å overføre verdier til malgjengivelsesmotoren gjennom de innebygde objektverdiene. La oss endre verdier.yaml å se ut som:

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

Vær imidlertid oppmerksom på hvordan disse verdiene er tilgjengelige i maler ved hjelp av prikker som skiller navneområder. Vi har brukt bildelageret og taggen som “hei-verden” og “1.0”, dette må samsvare med docker-bildekoden vi opprettet for vår Spring Boot-applikasjon.

8. Forstå rorkommandoer

Med alt gjort så langt, er vi nå klare til å spille med diagrammet vårt. La oss se hva som er forskjellige kommandoer som er tilgjengelige i Helm CLI for å gjøre dette morsomt!

8.1. Helm Lint

For det første er dette en enkel kommando som tar veien til et diagram og kjører et batteri med tester for å sikre at diagrammet er velformet:

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

8.2 Rormal

Vi har også denne kommandoen for å gjengi malen lokalt, uten Tiller Server, for rask tilbakemelding:

rormal ./hello-world --- # Kilde: hallo-verden / maler / service.yaml apiVersjon: v1 type: Tjenestemetadata: navn: utgivelsesnavn-hallo-verden etiketter: app.kubernetes.io/navn: hallo -world helm.sh/chart: hallo-world-0.1.0 app.kubernetes.io/instance: release-name app.kubernetes.io/managed-by: Tiller spec: type: NodePort porter: - port: 80 targetPort: http-protokoll: TCP-navn: http selector: app.kubernetes.io/name: hallo-world app.kubernetes.io/instance: release-name --- # Kilde: hallo-world / templates / deployment.yaml apiVersion: apps / v1 type: Distribusjonsmetadata: navn: utgivelsesnavn-hallo-verdensetiketter: app.kubernetes.io/navn: hallo-world helm.sh/chart: hallo-world-0.1.0 app.kubernetes.io/instance: release -navn app.kubernetes.io/managed-by: Tiller spec: replikaer: 1 selector: matchLabels: app.kubernetes.io/name: hallo-world app.kubernetes.io/instance: release-name template: metadata: labels: app.kubernetes.io/name: hallo-world app.kubernetes.io/instance: release-name spec: containere: - na meg: hallo-world image: "hallo-world: 1.0" imagePullPolicy: IfNotPresent porter: - navn: http containerPort: 8080 protokoll: TCP

8.3. Rorinstallasjon

Når vi har bekreftet at diagrammet er bra, kan vi til slutt kjøre denne kommandoen for å installere diagrammet i Kubernetes-klyngen:

helm install - name hallo-world ./hello-world NAVN: hallo-world SISTE DEPLOYERT: man feb 25 15:29:59 2019 NAMESPACE: standard STATUS: DEPLOYED RESOURCES: ==> v1 / Service NAME TYPE CLUSTER-IP EXTERNAL -IP PORT (S) AGE hallo-world NodePort 10.110.63.169 80: 30439 / TCP 1s ==> v1 / Implementering NAVN ØNSKET AKTUELL OPPDATERING TILGJENGELIG ALDER Hello-world 1 0 0 0 1s ==> v1 / Pod (relatert) NAVN KLAR STATUS RESTARTER ALDER hallo-world-7758b9cdf8-cs798 0/1 Venter 0 0s

Til slutt, merk at vi har kalt utgivelsen av dette diagrammet med flagg-navnet. Kommandoen svarer med sammendraget av Kubernetes-ressurser som ble opprettet i prosessen.

8.4. Helm Get

Nå vil vi se hvilke diagrammer som er installert som utgivelse. Denne kommandoen lar oss spørre om de navngitte utgivelsene:

helm ls --all NAVN REVISJON OPPDATERT STATUS CHART APP VERSION NAMESPACE hallo-world 1 Mon Feb 25 15:29:59 2019 DEPLOYDET hallo-world-0.1.0 1.0 standard

8.5. Roroppgradering

Hva om vi har endret diagrammet vårt og trenger å installere den oppdaterte versjonen? Denne kommandoen hjelper oss med å oppgradere en utgivelse til en spesifisert eller aktuell versjon av diagrammet eller konfigurasjonen:

helm upgrade hallo-world ./hello-world Utgivelsen "hallo-world" har blitt oppgradert. Happy Helming! SISTE DEPLOJERTE: Man 25 feb 15:36:04 2019 NAMESPACE: standard STATUS: DEPLOYED RESOURCES: ==> v1 / Service NAME TYPE CLUSTER-IP EXTERNAL-IP PORT (S) AGE hallo-world NodePort 10.110.63.169 80: 30439 / TCP 6m5s ==> v1 / Implementeringsnavnet ØNSKET AKTUELL OPPDATERT TILGJENGELIG ALDER hallo-world 1 1 1 1 6m5s ==> v1 / Pod (relatert) NAVNE KLAR STATUS RESTARTS AGE hallo-world-7758b9cdf8-cs798 1/1 Kjører 0 6m4s

8.6. Helm Rollback

Det kan alltid skje at en utgivelse gikk galt og må tas tilbake. Dette er kommandoen for å tilbakestille en utgivelse til forrige versjon:

helm rollback hallo-world 1 Rollback var en suksess! Glad Helming!

8.7. Helm Delete

Selv om det er mindre sannsynlig, vil vi kanskje slette en utgivelse fullstendig. Vi kan bruke denne kommandoen til å slette en utgivelse fra Kubernetes:

helm delete - purge hallo-world utgivelse "hallo-world" slettet

Dette er bare noen av kommandoene som er tilgjengelige for å jobbe med diagrammer og utgivelser i Helm.

9. Distribusjon av diagrammer

Selv om mal er et kraftig verktøy som Helm bringer til verden for å administrere Kubernetes-ressurser, er det ikke den eneste fordelen med å bruke Helm. Som vi så i forrige avsnitt, fungerer Helm som en pakkeleder for Kubernetes-applikasjonen og gjør installering, spørring, oppgradering og sletting av utgivelser ganske sømløse.

I tillegg til denne, Helm kommer med kommandoer som en del av sin CLI for å pakke, publisere og hente Kubernetes-applikasjoner som diagrammer:

9.1. Rorpakke

For det første må vi pakke kartene vi har laget for å kunne distribuere dem. Dette er kommandoen for å lage versjonerte arkivfiler i diagrammet:

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

Merk at den produserer et arkiv på maskinen din som kan distribueres manuelt eller gjennom offentlige eller private kartoppbevaringssteder.

9.2. Helm Repo

Til slutt trenger vi en mekanisme for å samarbeide med delte arkiver for å samarbeide. Repo pakker en rekke kommandoer som vi kan bruke til å legge til, fjerne, liste opp eller indeksere diagrammer. La oss se hvordan vi kan bruke dem.

Vi kan opprette et git-arkiv og bruke det til å fungere som vårt kartlager. Det eneste kravet er at det skal ha en index.yaml fil.

Vi kan skape index.yaml for kartoversikten vår:

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

Dette genererer index.yaml fil, som vi skal skyve til depotet sammen med kartarkivene.

Etter å ha opprettet kartdatabasen, kan vi deretter legge til denne repoen eksternt:

helm repo legg til my-repo //my-pages.github.io/my-repo

Nå skal vi kunne installere diagrammer fra repoen vår direkte:

helm install my-repo / hallo-world --name = hallo-world

Det er ganske mange verktøyskommandoer tilgjengelig for å jobbe med kartregister.

10. Konklusjon

For å oppsummere, i denne opplæringen, diskuterte vi kjernekomponentene til Helm, en pakkeleder for Kubernetes-applikasjoner. Vi forsto alternativene for å installere Helm. Videre gikk vi gjennom å lage et eksempeldiagram og maler med verdier.

Deretter gikk vi gjennom flere kommandoer tilgjengelig som en del av Helm CLI for å administrere Kubernetes-applikasjonen som en Helm-pakke.

Til slutt diskuterte vi alternativene for å distribuere Helm-pakker gjennom arkiver.

streamalism.org