Una introducción amistosa a Kubernetes

Kubernetes es una de las tecnologías más interesantes del mundo de DevOps en estos días. Ha atraído mucha atención en los últimos años. La razón de su fama instantánea son los poderosos contenedores .

Docker Inc. sacó a la luz los envases con su impecable marketing de un producto asombroso. Docker sentó las bases para el uso generalizado de contenedores, aunque la tecnología de contenedores la ha anticuado. Sin embargo, gracias a Docker, el uso de contenedores de Linux se ha vuelto más frecuente, cimentando las bases para los motores de orquestación de contenedores.

Ingrese a Kubernetes, desarrollado por Google con años de experiencia en la ejecución de una infraestructura de clase mundial en miles de millones de contenedores. Kubernetes fue un éxito instantáneo y, a partir de este año, Docker Inc. ha empaquetado Kubernetes como un motor de orquestación adicional junto con Docker Swarm.

A partir de ahora, Kubernetes será parte de la comunidad de Docker y de Docker Enterprise Edition. Suena muy bien, ¿eh? Lo mejor de ambos mundos empaquetados en un solo binario.

Descripción general de Bird's Eye

Kubernetes, k8s o kube, es una plataforma de código abierto que automatiza las operaciones de contenedores. Elimina la mayoría de los procesos manuales existentes, que implican la implementación, el escalado y la gestión de aplicaciones en contenedores. ¡Uf! eso es mucho trabajo.

Con Kubernetes, puede agrupar grupos de hosts que ejecutan contenedores juntos. Kubernetes lo ayuda a administrar esos clústeres. Estos grupos pueden abarcar las nubes públicas, privadas e híbridas y, quién sabe, el universo de Star War algún día.

Kubernetes fue desarrollado y diseñado por el equipo de ingeniería de Google. Google ha contribuido durante mucho tiempo a la tecnología de contenedores. Además de hablar sobre el uso de la tecnología de contenedores, Kubernetes es la tecnología detrás de las ofertas de servicios en la nube de Google.

Google despliega más de 2 mil millones de contenedores a la semana. Todo impulsado por una plataforma interna llamada Borg (suena más como un señor de la guerra orco de Mordor, pero no). Borg fue el predecesor de Kubernetes. Las lecciones aprendidas por Google trabajando con Borg a lo largo de los años se convirtieron en la fuerza impulsora detrás de Kubernetes.

Kubernetes hace que todo lo relacionado con la implementación y la administración de aplicaciones en contenedores sea un placer. Kubernetes automatiza las implementaciones, las reversiones y supervisa el estado de los servicios implementados. Esto evita las implementaciones incorrectas antes de que las cosas vayan realmente mal.

Además, Kubernetes puede escalar los servicios hacia arriba o hacia abajo en función de la utilización, lo que garantiza que solo esté ejecutando lo que necesita, cuando lo necesita, donde lo necesite. Al igual que los contenedores, Kubernetes nos permite administrar clústeres, lo que permite controlar la versión y replicar la configuración.

Esta fue una vista de pájaro, pero no se detenga aquí. Hay más en Kubernetes de lo que parece (y por eso escribo esto en primer lugar).

¿Cómo funciona Kubernetes?

Kubernetes es un sistema muy complejo en comparación con la solución de orquestación de Docker, Docker Swarm. Para comprender cómo funciona Kubernetes, debemos comprender sus conceptos y principios subyacentes.

El estado deseado

El estado deseado es uno de los conceptos centrales de Kubernetes. Puede definir un estado para la ejecución de contenedores dentro de los pods. Si, debido a alguna falla, el contenedor deja de ejecutarse, Kubernetes vuelve a crear el Pod según las líneas del estado deseado.

Kubernetes garantiza estrictamente que todos los contenedores que se ejecutan en el clúster estén siempre en el estado deseado. Esto lo aplica Kubernetes Master, que es parte del plano de control de Kubernetes. Puede usar el kubectlque interactúa directamente con el clúster para establecer o modificar el estado deseado a través de la API de Kubernetes.

Objetos de Kubernetes

Como se define en la documentación de Kubernetes:

Un objeto de Kubernetes es un "registro de intención"; una vez que crea el objeto, el sistema de Kubernetes trabajará constantemente para garantizar que el objeto exista. Al crear un objeto, le está diciendo al sistema de Kubernetes cómo desea que se vea la carga de trabajo de su clúster; este es el estado deseado de su clúster.

Los objetos de Kubernetes representan el estado de las entidades del sistema en un momento determinado. Los objetos de Kubernetes también actúan como una capa adicional de abstracción sobre la interfaz del contenedor. Ahora puede interactuar directamente con instancias de objetos de Kubernetes en lugar de interactuar con contenedores. Los objetos básicos de Kubernetes son los siguientes:

  • Vainaes la unidad desplegable más pequeña en un nodo . Es un grupo de contenedores que deben funcionar juntos. Muy a menudo, pero no necesariamente, un Pod suele contener un contenedor.
  • Serviciose utiliza para definir un conjunto lógico de podsy políticas relacionadas que se utilizan para acceder a ellos.
  • Volumenes esencialmente un directorio accesible para todos los contenedores que se ejecutan en un Pod.
  • Espacios de nombresson clústeres virtuales respaldados por el clúster físico.

Hay varios controladores proporcionados por Kubernetes. Estos controladores se basan en los objetos básicos de Kubernetes y proporcionan funciones adicionales. Los controladores de Kubernetes incluyen:

  • ReplicaSetasegura que se ejecute una cantidad específica de réplicas de pod en un momento dado.
  • La implementación se utiliza para cambiar el estado actual al estado deseado.
  • StatefulSetse utiliza para garantizar el control sobre los pedidos de implementación y el acceso a los volúmenes, etc.
  • DaemonSetse usa para ejecutar una copia de un pod en todos los nodos de un clúster o en nodos específicos.
  • Trabajose utiliza para realizar alguna tarea y salir después de completar con éxito su trabajo o después de un período de tiempo determinado.

Plano de control de Kubernetes

El plano de control de Kubernetes funciona para hacer que el estado actual del clúster coincida con el estado deseado. Para hacerlo, Kubernetes realiza una variedad de tareas automáticamente, por ejemplo, iniciar o reiniciar contenedores, escalar el número de réplicas de una aplicación determinada y mucho más.

Como se define en la documentación de Kubernetes:

Las distintas partes del plano de control de Kubernetes, como los procesos Kubernetes Master y kubelet , gobiernan cómo se comunica Kubernetes con su clúster. El plano de control mantiene un registro de todos los objetos de Kubernetes en el sistema y ejecuta ciclos de control continuos para administrar el estado del objeto. En cualquier momento, los lazos de control del plano de control responderán a los cambios en el clúster y trabajarán para que el estado real de todos los objetos del sistema coincida con el estado deseado que usted definió.

El plano de control de Kubernetes realiza la tarea de mantener el estado deseado en todo el clúster. Registra el estado del objeto y ejecuta continuamente un bucle de control para verificar si el estado actual del objeto coincide con el estado deseado. Puede pensar en ello como el gobierno que dirige el estado.

Maestro de Kubernetes

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.