En venlig introduktion til Kubernetes

Kubernetes er en af ​​de mest spændende teknologier i DevOps verden i disse dage. Det har vakt stor opmærksomhed i løbet af de sidste par år. Årsagen til dets øjeblikkelige berømmelse er de mægtige containere .

Docker Inc. bragte containere til kalklyset med deres upåklagelige markedsføring af et fantastisk produkt. Docker lagde grundlaget for den udbredte brug af containere, skønt containerteknologi forældet det. Men på grund af Docker er brugen af ​​Linux-containere blevet mere udbredt og cementerer fundamentet for containerorkestrationsmotorer.

Indtast Kubernetes - udviklet af Google med mange års erfaring med at køre en infrastruktur i verdensklasse på milliarder containere. Kubernetes var et øjeblikkeligt hit, og med start i år har Docker Inc. pakket Kubernetes som en ekstra orkestrationsmotor sammen med Docker Swarm.

Fra nu af vil Kubernetes være en del af Docker-samfundet og Docker Enterprise Edition. Det lyder ret sejt, ikke? Det bedste fra begge verdener pakket sammen som en enkelt binær.

Bird's Eye Oversigt

Kubernetes, k8s eller kube er en open source-platform, der automatiserer containeroperationer. Det eliminerer de fleste af de eksisterende manuelle processer, der involverer implementering, skalering og styring af containeriserede applikationer. Pis! det er meget arbejde.

Med Kubernetes kan du klynge grupper af værter, der kører containere sammen. Kubernetes hjælper dig med at styre disse klynger. Disse klynger kan spænde over de offentlige, private og hybrid skyer - og hvem ved, Star War-universet en dag.

Kubernetes blev udviklet og designet af ingeniørteamet hos Google. Google har længe været en bidragyder til containerteknologi. Udover at være vokal om brugen af ​​containerteknologi er Kubernetes teknologien bag Googles cloud-tjenester.

Google indsætter mere end 2 milliarder containere om ugen. Alt drevet af en intern platform kaldet Borg (lyder mere som en Orc-krigsherre fra Mordor, men nej). Borg var forgængeren til Kubernetes. De erfaringer, som Google arbejdede med Borg i årenes løb, blev den ledende kraft bag Kubernetes.

Kubernetes gør alt, der er forbundet med implementering og styring af containeriserede applikationer, til en glæde. Kubernetes automatiserer udrulninger, tilbageførsler og overvåger sundheden for implementerede tjenester. Dette forhindrer dårlige udrulninger, før tingene faktisk går dårligt.

Derudover kan Kubernetes skalere tjenester op eller ned baseret på brug, hvilket sikrer, at du kun kører det, du har brug for, når du har brug for det, hvor som helst du har brug for det. Ligesom containere tillader Kubernetes os at administrere klynger, hvilket gør det muligt at opsætte versionskontrolleret og replikeret.

Dette var et fugleperspektiv, men stop ikke her. Der er mere til Kubernetes end det ser ud til (og det er derfor, jeg skriver dette i første omgang).

Hvordan fungerer Kubernetes?

Kubernetes er et meget komplekst system sammenlignet med Dockers orkestrationsløsning, Docker Swarm. For at forstå hvordan Kubernetes fungerer, er vi nødt til at forstå dens underliggende begreber og principper.

Den Ønskede Stat

Ønsket tilstand er et af kernebegreberne i Kubernetes. Du er fri til at definere en tilstand til udførelse af containere inde i Pods. Hvis containeren holder op med at køre på grund af en eller anden fejl, genskaber Kubernetes Pod'en baseret på linjerne i den ønskede tilstand.

Kubernetes sikrer nøje, at alle containere, der kører på tværs af klyngen, altid er i den ønskede tilstand. Dette håndhæves af Kubernetes Master, som er en del af Kubernetes Control Plane. Du kan bruge den, kubectlder interagerer direkte med klyngen, til at indstille eller ændre den ønskede tilstand via Kubernetes API.

Kubernetes objekter

Som defineret i Kubernetes-dokumentationen:

Et Kubernetes-objekt er en "hensigtsregistrering" - når du opretter objektet, vil Kubernetes-systemet konstant arbejde for at sikre, at objektet eksisterer. Ved at oprette et objekt fortæller du effektivt Kubernetes-systemet, hvordan du vil have din klynges arbejdsbyrde til at se ud; dette er din klynges ønskede tilstand.

Enhedernes tilstand i systemet på et givet tidspunkt er repræsenteret af Kubernetes Objects. Kubernetes Objects fungerer også som et ekstra abstraktionslag over containergrænsefladen. Du kan nu direkte interagere med forekomster af Kubernetes Objects i stedet for at interagere med containere. De grundlæggende Kubernetes-objekter er som følger:

  • Poder den mindste implementerbare enhed på en node . Det er en gruppe containere, der skal køre sammen. Ganske ofte, men ikke nødvendigvis, indeholder en Pod normalt en container.
  • Servicebruges til at definere et logisk sæt Podsog relaterede politikker, der bruges til at få adgang til dem.
  • Binder i det væsentlige et bibliotek, der er tilgængeligt for alle containere, der kører i en Pod.
  • Navneområderer virtuelle klynger bakket op af den fysiske klynge.

Der er et antal controllere leveret af Kubernetes. Disse controllere er bygget på de grundlæggende Kubernetes-objekter og giver yderligere funktioner. Kubernetes Controllers inkluderer:

  • ReplicaSetsikrer, at et bestemt antal Pod-replikaer kører på et givet tidspunkt.
  • Implementering bruges til at ændre den aktuelle tilstand til den ønskede tilstand.
  • StatefulSetbruges til at sikre kontrol over implementeringsbestilling og adgang til diskenheder osv.
  • DaemonSetbruges til at køre en kopi af en Pod på alle noder i en klynge eller på specificerede noder.
  • Jobbruges til at udføre en opgave og afslutte efter at have fuldført deres arbejde eller efter en given periode.

Kubernetes kontrolplan

Den Kubernetes Kontrol Plane arbejder på at gøre klyngens nuværende tilstand matche dit ønskede tilstand. For at gøre dette udfører Kubernetes automatisk en række opgaver - for eksempel start eller genstart af containere, skalering af antallet af replikaer af en given applikation og meget mere.

Som defineret i Kubernetes-dokumentationen:

De forskellige dele af Kubernetes Control Plane, såsom Kubernetes Master og kubelet- processer, styrer, hvordan Kubernetes kommunikerer med din klynge. Kontrolplanet registrerer alle Kubernetes-objekter i systemet og kører kontinuerlige kontrolsløjfer for at styre objektets tilstand. Kontrolplanens kontrolsløjfer reagerer på ethvert givet tidspunkt på ændringer i klyngen og arbejder på at få den faktiske tilstand for alle objekterne i systemet til at matche den ønskede tilstand, du definerede.

Kubernetes Control Plane udfører opgaven med at opretholde den ønskede tilstand på tværs af klyngen. Det registrerer objekttilstanden og kører kontinuerligt en kontrolsløjfe for at kontrollere, om objektets aktuelle tilstand matcher den ønskede tilstand. Du kan tænke på det som regeringen, der fører staten.

Kubernetes Master

Som en del af Kubernetes-kontrolplanet arbejder Kubernetes-masteren kontinuerligt med at opretholde den ønskede tilstand i hele din klynge. Den kubectlkommando er et interface til at kommunikere med klyngens Kubernetes mester gennem Kubernetes API. Tænk på det som politiet, der er ansvarligt for at opretholde lov og orden.

Som defineret i Kubernetes-dokumentationen:

”Master” refererer til en samling af processer, der styrer klyngetilstanden. Typisk køres disse processer alle på en enkelt node i klyngen, og denne node kaldes også master. Masteren kan også replikeres for tilgængelighed og redundans.

De Kubernetes Master kontroller og koordinater alle knuder i klyngen ved hjælp af tre processer, der kører på en eller flere master-noder i klyngen. Hver Kubernetes-mester i din klynge kører disse tre processer:

  1. kube-apiserver : det eneste ledelsespunkt for hele klyngen. API-serveren implementerer en RESTful interface til kommunikation med værktøjer og biblioteker. Den kubectlkommando direkte interagerer med API-serveren.
  2. kube-controller-manager : regulerer klyngens tilstand ved at styre de forskellige typer controllere.
  3. kube-scheduler : planlægger arbejdsbelastningerne på tværs af de tilgængelige noder i klyngen.

Kubernetes noder

Kubernetes-noder er dybest set arbejdsmaskiner (VM'er, fysiske, bare metal-servere osv.) I en klynge, der kører dine arbejdsbelastninger. Knudepunkterne styres af Kubernetes master og overvåges kontinuerligt for at opretholde den ønskede tilstand af applikationen. Tidligere var de kendt som håndlangere (ikke den lille sjove gule loyale hær fra Gru). Svarende til masteren kører hver Kubernetes-node i din klynge to processer:

  1. kubelet er en kommunikationsgrænseflade mellem noden og Kubernetes Master.
  2. kube-proxy er en netværksproxy, der afspejler tjenester som defineret i Kubernetes API på hver node. Det kan også udføre simpel TCP- og UDP-videresendelse af strøm.

Stemmeappen

Lad os komme op til hastighed ved faktisk at køre en applikation på Kubernetes. Men inden du kan komme et skridt videre i den fantastiske verden af ​​Kubernetes, skal du først installere og køre Kubernetes lokalt. Så lad os starte med det. Spring dette over, hvis du har installeret Kubernetes og MiniKube.

Installation af Kubernetes

Kubernetes kommer nu ud af kassen med Docker Community Edition til version 17.12. +. Hvis du ikke har Community Edition installeret, kan du downloade den her.

Installation af MiniKube

For at køre Kubernetes lokalt skal du installere MiniKube. Det opretter en lokal VM og kører en enkelt node-klynge. Tænk ikke engang på at køre din produktionsklynge på den. Det bruges bedst til udviklings- og testformål.

Enkeltknudeklyngen

For at køre en enkelt node-klynge skal vi bare køre minikube startkommandoen. Voilà, en VM, en klynge og Kubernetes kører.

$ minikube start Starting local Kubernetes v1.10.0 cluster... Starting VM... Getting VM IP address... Moving files into cluster... Setting up certs... Connecting to cluster... Setting up kubeconfig... Starting cluster components... Kubectl is now configured to use the cluster. Loading cached images from config file.

For at kontrollere, at din opsætning var vellykket, skal du køre for kubectl versionat kontrollere, om Kubernetes-versionen kører på din maskine.

$ kubectl version Client Version: version.Info{Major:"1", Minor:"9", GitVersion:"v1.9.1", GitCommit:"3a1c9449a956b6026f075fa3134ff92f7d55f812", GitTreeState:"clean", BuildDate:"2018-01-04T20:00:41Z", GoVersion:"go1.9.2", Compiler:"gc", Platform:"darwin/amd64"} Server Version: version.Info{Major:"1", Minor:"10", GitVersion:"v1.10.0", GitCommit:"fc32d2f3698e36b93322a3465f63a14e9f0eaead", GitTreeState:"clean", BuildDate:"2018-03-26T16:44:10Z", GoVersion:"go1.9.3", Compiler:"gc", Platform:"linux/amd64"}

Afstemningsappen Endelig

Spol frem til afstemningsappen, nu når du har installeret Kubernetes på din lokale maskine. Dette er en simpel applikation baseret på mikrotjenestearkitektur, der består af 5 enkle tjenester.

  1. Voting-App : Frontend af applikationen skrevet i Python, brugt af brugere til at afgive deres stemmer.
  2. Redis : In-memory database, der bruges som mellemlagring.
  3. Arbejdstager : .Net-tjeneste, bruges til at hente stemmer fra Redis og gemme i Postgres-databasen.
  4. DB : PostgreSQL-database, der bruges som database.
  5. Result-App: Frontend of the application written in Node.js, displays the voting results.

Git clone and cd into the voting app repo.

dockersamples/example-voting-app

example-voting-app — Example Docker Compose appgithub.com

The folder “k8s-specifications” contains the Kubernetes yaml specifications of the Voting App’s services. For each service it has two yaml files: a service file and a deployment file. The service file defines a logical set of pods and the policies around them. Below is the resulting service file from the voting app.

apiVersion: v1 kind: Service metadata: name: result spec: type: NodePort ports: - name: "result-service" port: 5001 targetPort: 80 nodePort: 31001 selector: app: result

A Deployment file is used to define the desired state of your application, such as the number of replicas that should be running at any given point of time. Below is the resulting deployment file from the voting app.

apiVersion: extensions/v1beta1 kind: Deployment metadata: name: result spec: replicas: 1 template: metadata: labels: app: result spec: containers: - image: dockersamples/examplevotingapp_result:before name: result

Time to create the service and deployment objects — piece of cake.

$ kubectl create -f k8s-specifications/ deployment "db" created service "db" created deployment "redis" created service "redis" created deployment "result" created service "result" created deployment "vote" created service "vote" created deployment "worker" created

There you go! Your app has successfully been deployed to the single node cluster, and you can list the running pods and services.

$ kubectl get pods NAME READY STATUS RESTARTS AGE db-86b99d968f-s5pv7 1/1 Running 0 1m redis-659469b86b-hrxqs 1/1 Running 0 1m result-59f4f867b8-cthvc 1/1 Running 0 1m vote-54f5f76b95-zgwrm 1/1 Running 0 1m worker-56578c48f8-h7zvs 1/1 Running 0 1m $ kubectl get svc NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE db ClusterIP 10.109.241.59  5432/TCP 2m kubernetes ClusterIP 10.96.0.1  443/TCP 23m redis ClusterIP 10.102.242.148  6379/TCP 2m result NodePort 10.106.7.255  5001:31001/TCP 2m vote NodePort 10.103.28.96  5000:31000/TCP 2m

Behold the cats vs dogs war, which the cats always win. Cats are cute by design and their IDC attitude is a big win. But this is a discussion for another time.

Back to the moment, your voting app is exposed on port 30001, and the results app is exposed on port 31001. You can access it using localhost:port or, using the IP on which minikube is running, you can get that using minikube ip command.

Kubernetes Cheat Sheet

Since you all have shown a lot of patience going through these blocks of text, let me now present to you the Kubernetes Cheat Sheet (which could have been a whole new article in itself, but whatever!):

Minikube command:

# Start Minikube server $ minikube start # Get the Minikube IP $ minikube ip

Version Info:

$ kubectl version #Get kubectl version $ kubectl cluster-info #Get cluster info

Creating Objects:

$ kubectl create -f ./file.yml $ kubectl create -f ./file1.yml -f ./file2.yaml $ kubectl create -f ./dir $ kubectl create -f //www.fpaste.org/279276/48569091/raw/

Viewing and finding resources:

# List all services in the namespace $ kubectl get services # List all pods in all namespaces $ kubectl get pods --all-namespaces # List all pods in the namespace, with more details $ kubectl get pods -o wide # List a particular replication controller $ kubectl get rc  # List all pods with a label env=production $ kubectl get pods -l env=production

List services sorted by name:

$ kubectl get services --sort-by=.metadata.name

Modifying and Deleting resources:

$ kubectl label pods  new-label=awesome $ kubectl annotate pods  icon-url=//goo.gl/XXBTWq $ kubectl delete pod pingredis-XXXXX

Scaling up and down:

$ kubectl scale --replicas=3 deployment nginx

Interacting with running Pods:

$ kubectl logs  # Runs a tailf log output $ kubectl logs -f  # Run pod as interactive shell $ kubectl run -i --tty busybox --image=busybox -- sh # Attach to Running Container $ kubectl attach  -i # Forward port of Pod to your local machine $ kubectl port-forward   # Forward port to service $ kubectl port-forward   # Run command in existing pod (1 container case) $ kubectl exec  -- ls / # Run command in existing pod (multi-container case) $ kubectl exec  -c  -- ls /

DNS Lookups:

$ kubectl exec busybox -- nslookup kubernetes $ kubectl exec busybox -- nslookup kubernetes.default $ kubectl exec busybox -- nslookup kubernetes.default.svc.cluster.local

Create and expose a deployment:

$ kubectl run nginx --image=nginx:1.9.12 $ kubectl expose deployment nginx --port=80 --type=LoadBalancer

Summary

Kubernetes is super exciting, cool, and most likely the future of container orchestration. The tech is great, and it is worth investing your time in if you are interested in containers or simply a fan like me. Kubernetes is a very powerful container orchestration engine, it can be used to amplify cloud containerisation strategy as it is designed to automate deploying, scaling, and operating containers.

The sunny side is that Kubernetes readily integrates with any cloud portfolio, be it public, private, hybrid or multi-cloud. Cloud vendors like AWS and Google provide managed Kubernetes services like Elastic Container Service for Kubernetes (EKS) and Google Kubernetes Engine (GKE). The dark side is that Kubernetes is significantly more complex than Docker’s very own container orchestration engine Docker Swarm.

All the information here was just for wetting your feet. If you feel like taking a dive in the awesome Kubernetes ocean, here you go.

ramitsurana/awesome-kubernetes

awesome-kubernetes - A curated list for awesome kubernetes sources :ship::tada:github.com

Når du kommer ud af dybdykningen, kan du lige så godt have brug for Kubernetes. Tag Kubernetes på en tur, eller lad det tage dig med til en i Labs med Kubernetes labs.

Spil med Kubernetes

Spil med Kubernetes er et laboratorieside leveret af Docker og oprettet af Tutorius. Leg med Kubernetes er en legeplads ... labs.play-with-k8s.com

Jeg håber, at denne artikel hjalp med at forstå Kubernetes. Jeg vil meget gerne høre om, hvordan du bruger Kubernetes i dine projekter. Klapp, hvis det øgede din viden, og hjælp det til at nå ud til flere mennesker.