Barátságos bevezetés a Kuberneteshez

A Kubernetes manapság az egyik legizgalmasabb technológia a DevOps világában. Az elmúlt években nagy figyelmet keltett. Azonnali hírnevének oka a hatalmas konténerek .

A Docker Inc. egy csodálatos termék kifogástalan marketingjével hozta a konténereket a mészfénybe. Docker megalapozta a konténerek széles körű használatát, bár a konténertechnológia elavult. A Docker miatt azonban egyre elterjedtebb a Linux-konténerek használata, amely megalapozza a konténeres hangszerelő motorok alapját.

Írja be a Kubernetes programot - amelyet a Google fejlesztett ki, felhasználva a sokéves konténerek világszínvonalú infrastruktúrájának üzemeltetésével szerzett tapasztalatait. A Kubernetes azonnali sláger volt, és az idei évtől a Docker Inc. a Kubocketet további hangszerelési motorként csomagolta a Docker Swarm mellé.

Mostantól a Kubernetes a Docker közösség és a Docker Enterprise Edition része lesz. Nagyon klasszul hangzik, mi? Mindkét világ legjobbjai egyetlen bináris formában csomagolva.

Madártávlat áttekintése

A Kubernetes, a k8s vagy a kube egy nyílt forráskódú platform, amely automatizálja a konténer műveleteket. Megszünteti a meglévő manuális folyamatok többségét, amelyek magukban foglalják a konténeres alkalmazások telepítését, méretezését és kezelését. Phew! ez sok munka.

A Kubernetes segítségével csoportosíthatja a tárolókat futtató gazdagépcsoportokat. A Kubernetes segít kezelni ezeket a fürtöket. Ezek a klaszterek átívelhetik a nyilvános, a magán- és a hibrid felhőket - és ki tudja, a Csillagháborús univerzum egy nap.

A Kubernetes-t a Google mérnöki csapata fejlesztette ki és tervezte. A Google régóta közreműködik a konténertechnológiában. Amellett, hogy hangosan szól a konténertechnológia használatáról, a Kubernetes a Google felhőszolgáltatásai mögött álló technológia.

A Google több mint 2 milliárd konténert helyez ki hetente. Mindezt egy Borg nevű belső platform hajtja (inkább úgy hangzik, mint valami ork hadvezér a Mordortól, de nem). Borg a Kubernetes elődje volt. Azok a tanulságok, amelyeket a Google Borggal együtt dolgozott az évek során, a Kubernetes mögött meghúzódó vezetővé váltak.

A Kubernetes minden örömet okoz a konténeres alkalmazások telepítésével és kezelésével kapcsolatban. A Kubernetes automatizálja a bevezetéseket, a visszaállításokat és figyeli a telepített szolgáltatások állapotát. Ez megakadályozza a rossz bevezetést, mielőtt a dolgok valóban romlanak.

Ezenkívül a Kubernetes a kihasználtság alapján fel vagy le növelheti a szolgáltatásokat, biztosítva, hogy csak akkor fusson, amire szüksége van, amikor szüksége van rá, bárhol is van szüksége. A konténerekhez hasonlóan a Kubernetes is lehetővé teszi számunkra a fürtök kezelését, lehetővé téve a beállítás verzió-vezérlését és replikálását.

Ez egy madártávlat volt, de ne álljon meg itt. A Kubernetesben több van, mint amilyennek látszik (és ezért is írom ezt eleve).

Hogyan működik a Kubernetes?

A Kubernetes egy nagyon összetett rendszer a Docker hangszerelési megoldásához, a Docker Swarmhoz képest. Ahhoz, hogy megértsük a Kubernetes működését, meg kell értenünk a mögöttes fogalmakat és elveket.

A kívánt állam

A kívánt állapot a Kubernetes egyik alapfogalma. Ön szabadon meghatározhat egy állapotot a Pods-ban lévő konténerek végrehajtásához. Ha valamilyen meghibásodás miatt a tároló leáll, a Kubernetes a kívánt állapot vonalai alapján újrateremti a Pod-ot.

A Kubernetes szigorúan biztosítja, hogy a fürtön futó összes konténer mindig a kívánt állapotban legyen. Ezt a Kubernetes Master hajtja végre, amely a Kubernetes Control Plane része. A kubectlközvetlenül a fürttel interakcióval beállíthatja vagy módosíthatja a kívánt állapotot a Kubernetes API segítségével.

Kubernetes objektumok

A Kubernetes-dokumentációban meghatározottak szerint:

A Kubernetes objektum a szándék nyilvántartása - amint létrehozza az objektumot, a Kubernetes rendszer folyamatosan dolgozik annak biztosításában, hogy az objektum létezik. Objektum létrehozásával hatékonyan megmondja a Kubernetes rendszernek, hogy nézzen ki a fürt munkaterhelése; ez a klasztered kívánt állapota.

A rendszerben az entitások állapotát az adott időpontban a Kubernetes Objects képviseli. A Kubernetes Objects az absztrakció további rétegeként is működik a tároló felületén. A tárolókkal való interakció helyett most közvetlenül léphet kapcsolatba a Kubernetes Objects példányaival. Az alapvető Kubernetes objektumok a következők:

  • Hüvelya legkisebb telepíthető egység egy csomóponton . Ez egy konténercsoport, amelynek együtt kell futnia. Elég gyakran, de nem feltétlenül, a Pod általában egy konténert tartalmaz.
  • Szolgáltatása Podok logikai készletének meghatározására szolgálés a hozzájuk való hozzáféréshez használt kapcsolódó irányelvek.
  • Hangerőlényegében egy Pod-ban futó összes tároló számára elérhető könyvtár.
  • Névterekvirtuális fürtök, amelyeket a fizikai fürt támogat.

A Kubernetes számos vezérlőt biztosít. Ezek a vezérlők az alapvető Kubernetes objektumokra épülnek, és további szolgáltatásokat nyújtanak. A Kubernetes vezérlők a következőket tartalmazzák:

  • ReplicaSetbiztosítja, hogy egy adott számú Pod-másolat futjon egy adott pillanatban.
  • A telepítés az aktuális állapot kívánt állapotra váltására szolgál.
  • StatefulSeta telepítési sorrend és a kötetekhez való hozzáférés stb. ellenőrzésének biztosítására szolgál.
  • DaemonSeta Pod másolatának futtatására szolgál a fürt összes csomópontján vagy meghatározott csomópontokon.
  • Munkabizonyos feladatok elvégzésére és kilépésre szolgál a munkájuk sikeres befejezése után vagy egy adott idő után.

Kubernetes vezérlősík

A Kubernetes Control Plane azon dolgozik, hogy a fürt aktuális állapota megfeleljen a kívánt állapotnak. Ehhez a Kubernetes különféle feladatokat hajt végre automatikusan - például tárolók indításával vagy újraindításával, az adott alkalmazás replikáinak számának méretezésével és még sok mással.

A Kubernetes-dokumentációban meghatározottak szerint:

A Kubernetes vezérlősík különböző részei, például a Kubernetes Master és a kubelet folyamatok szabályozzák, hogy a Kubernetes hogyan kommunikál az Ön fürtjével. A Control Plane nyilvántartást vezet a rendszer összes Kubernetes objektumáról, és folyamatos vezérlési ciklusokat futtat az objektum állapotának kezelésére. A Vezérlősík vezérlő hurkok bármikor reagálnak a fürt változásaira, és azon dolgoznak, hogy a rendszer összes objektumának tényleges állapota megfeleljen a kívánt állapotnak.

A Kubernetes vezérlő sík a kívánt állapot fenntartását végzi a fürtön. Rögzíti az objektum állapotát, és folyamatosan futtat egy vezérlőhurkot annak ellenőrzésére, hogy az objektum aktuális állapota megfelel-e a kívánt állapotnak. Úgy gondolhat rá, mint az államot irányító kormányra.

Kubernetes mester

As a part of the Kubernetes Control Plane, the Kubernetes master works towards continuously maintaining the desired state throughout your cluster. The kubectl command is an interface to communicate with the cluster’s Kubernetes master through the Kubernetes API. Think of it as the police force responsible for maintaining law and order.

As defined in the Kubernetes Documentation:

The “master” refers to a collection of processes managing the cluster state. Typically these processes are all run on a single node in the cluster, and this node is also referred to as the master. The master can also be replicated for availability and redundancy.

The Kubernetes Master controls and coordinates all the nodes in the cluster with the help of three processes that run on one or more master nodes in the cluster. Each Kubernetes master in your cluster runs these three processes:

  1. kube-apiserver: the single point of management for the entire cluster. The API server implements a RESTful interface for communication with tools and libraries. The kubectl command directly interacts with the API server.
  2. kube-controller-manager: regulates the state of the cluster by managing the different kinds of controllers.
  3. kube-scheduler: schedules the workloads across the available nodes in the cluster.

Kubernetes Nodes

The Kubernetes nodes are basically worker machines (VMs, physical, bare metal servers, etc) in a cluster running your workloads. The nodes are controlled by Kubernetes master and are continuously monitored to maintain the desired state of the application. Previously they were known as minions (not the tiny hilarious yellow loyal army of Gru). Similar to the master, each Kubernetes node in your cluster runs two processes:

  1. kubelet is a communication interface between the node and the Kubernetes Master.
  2. kube-proxy is a network proxy that reflects services as defined in the Kubernetes API on each node. It can also perform simple TCP and UDP stream forwarding.

The Voting App

Let’s get you up to speed by actually running an application on Kubernetes. But, before you can move a step further in the amazing world of Kubernetes, first you’ll need to install and run Kubernetes locally. So, let’s start with that. Skip this if you have Kubernetes and MiniKube installed.

Installing Kubernetes

Kubernetes now comes out of the box with Docker Community Edition for version 17.12.+. In case you don’t have the Community Edition installed, you can download it here.

Installing MiniKube

To run Kubernetes locally you will need to install MiniKube. It creates a local VM and runs a single node cluster. Don’t even think of running your production cluster on it. It’s best used for development and testing purposes only.

The Single Node Cluster

To run a single node cluster, we just need to run the minikube start command. Voilà, a VM, a Cluster and Kubernetes are running.

$ 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.

To verify that your setup was successful, run kubectl version to check for the Kubernetes version running on your machine.

$ 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"}

The Voting App Finally

Fast forward to the Voting App now that you have installed Kubernetes on your local machine. This is a simple application based on micro-services architecture, consisting of 5 simple services.

  1. Voting-App: Frontend of the application written in Python, used by users to cast their votes.
  2. Redis: In-memory database, used as intermediate storage.
  3. Worker: .Net service, used to fetch votes from Redis and store in Postgres database.
  4. DB: PostgreSQL database, used as 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

After you emerge from the deep dive, you might as well want to get hands on Kubernetes. Take Kubernetes for a ride or let it take you for one, in the Play with Kubernetes labs.

Play with Kubernetes

Play with Kubernetes is a labs site provided by Docker and created by Tutorius. Play with Kubernetes is a playground…labs.play-with-k8s.com

I hope this article helped in the understanding of Kubernetes. I’d love to hear about how you use Kubernetes in your projects. Clap if it increased your knowledge, and help it reach more people.