Kubernetes fundamentals

Introduction

Kubernetes (commonly abbreviated as k8s) is a container orchestration system that is designed to be easy to use and easy to deploy. As the "container orchestation" term suggests, Kubernetes relies on containers and offers an administration environment that focus on them. According to their docs:

Kubernetes is a portable and extensible open source platform for managing workloads and services. Kubernetes facilitates automation and declarative configuration. It has a large and rapidly growing ecosystem. Support, tools and services for Kubernetes are widely available.

Summing up, kubernetes offers a fully equiped administration environment for running multiple containers, which makes it the favourite choice when it comes to deploying microservices inside a cluster.

Clusters

A Cluster is a set of nodes that run containerized applications. Kubernetes clusters allow containers to run across multiple machines and environments: virtual, physical, cloud-based, and on-premises. Kubernetes containers are not restricted to a specific operating system, unlike virtual machines. Instead, they are able to share operating systems and run anywhere.

Clusters consists on a master node and a number of worker nodes. Nodes are independent machines with a number of cores and memory each which can run multiple containers. The master node controls the state of the cluster and is the origin of all task assignments, coordinating processses such as scheduling and scaling applications, maintaining the cluster state or implementeing updates.

Worker nodes, on the other hand, are the nodes that perform the master's assignments. They operate as part of one system, orchestated by the master. Worker noeds can be virtual or physical machines.

Single Node Clusters

Single node clusters are a popular solution for testing and development purposes. Since they consists on a single node, they are able to run in local machines where developers can work on their applications' development.

Most used single node clusters are Minikube and Docker Kubernetes. The last one comes installed with Docker Desktop so you only need to activate kubernetes from the settings.

Kubernetes Cluster Structure

A Kubernetes cluster contains six main components:

1. API server: Exposes a REST interface to all Kubernetes resources. Serves as the front end of the Kubernetes control plane.
2. Scheduler: Places containers according to resource requirements and metrics. Makes note of Pods with no assigned node, and selects nodes for them to run on.
3. Controller manager: Runs controller processes and reconciles the cluster’s actual state with its desired specifications. Manages controllers such as node controllers, endpoints controllers and replication controllers.
4. Kubelet: Ensures that containers are running in a Pod by interacting with the Docker engine , the default program for creating and managing containers. Takes a set of provided PodSpecs and ensures that their corresponding containers are fully operational.
5. Kube-proxy: Manages network connectivity and maintains network rules across nodes. Implements the Kubernetes Service concept across every node in a given cluster.
6. Etcd: Stores all cluster data. Consistent and highly available Kubernetes backing store.

These six components can each run on Linux or as Docker containers (This is the case of Docker desktop kubernetes). The master node runs the Control Plane (API server, scheduler and controller manager), and the worker nodes run the kubelet and kube-proxy.

kubernetes also provides an internal DNS server for registering services domain names, it is automatically included in the DNS requests made from the containers.

CLI commands

This section does not cover the complete Kubernetes CLI documentation. Think of it as a quick reference cheat sheet for basic commands when managing your cluster. You can find the complete documentation here.

Basic commands

• Kubectl create:

  Create a resource from a file or from stdin.

  $ kubectl create RESOURCE NAME [...PROPERTIES]

  You can run kubectl api-resources to see the different resources available. Check the Resources sections for more information

• Kubectl get

  Display one or many resources.

  $ kubectl get [(-o|--output=)json|yaml|name|go-template|go-template-file|template|templatefile|jsonpath|jsonpath-as-json|jsonpath-file|custom-columns-file|custom-columns|wide] (TYPE[.VERSION][.GROUP] [NAME | -l label] | TYPE[.VERSION][.GROUP]/NAME ...) [flags]

  Option	Shortcut	Description	Exampe
  --namespace	-n	Specify the namespace to get resources from	Kubectl get pods --namespace=example
  --output	-o	Output format	Kubectl get deployments -o json

  
  

• Kubectl describe

  Show details of a specific resource. Print a detailed description of the selected resources, including related resources such as events or controllers. You may select a single object by name, all objects of that type, provide a name prefix, or label selector.

  $ kubectl describe RESOURCE NAME

  Option	Shortcut	Description	Exampe
  --namespace	-n	Specify the namespace to get resources from	Kubectl describe pods --namespace=example

  
  

• Kubectl delete

  Delete resources by file names, stdin, resources and names, or by resources and label selector.

  $ kubectl delete ([-f FILENAME] | [-k DIRECTORY] | TYPE [(NAME | -l label | --all)])

  Option	Shortcut	Description	Exampe
  --namespace	-n	Specify the namespace to get resources from	Kubectl delete pods example --namespace=example
  --force		Forces the deletion of the resource	Kubectl delete pods example --force
  --selector	-l	Label query to filter on	Kubectl delete pods --l key=value

  Deleting a namespace will also delete all objects in that namespace.

App management

• Kubectl apply

  Apply a configuration to a resource by file (manifest) name or stdin. The resource name must be specified. This resource will be created if it doesn't exist yet.

  $ kubectl apply (-f FILENAME | -k DIRECTORY)

  Check the Manifests section to see the structure of the files.

• Kubectl scale

  Set a new size for a deployment, replica set, replication controller, or stateful set.

  $ kubectl scale [--resource-version=version] [--current-replicas=count] --replicas=COUNT (-f FILENAME | TYPE NAME)

Working with apps

• Kubectl exec

  Execute a command in a container.

  $ kubectl exec (POD | TYPE/NAME) [-c CONTAINER] [flags] -- COMMAND [args...]

  Option	Shortcut	Description	Exampe
  --container	-c	Container name	kubectl exec example -c cname -- echo "hi"
  --stdin	-i	Pass stdin to the container	Kubectl exec -i example -- echo "hi"
  --tty	-l	Stdin is a TTY	Kubectl exec -t example -- echo "hi"

  Just like in docker, you can use -i & -t (-it) flags to launch an interactive shell inside the container.

• Kubectl logs

  Print the logs for a container in a pod or specified resource. If the pod has only one container, the container name is optional.

  $ kubectl logs [-f] [-p] (POD | TYPE/NAME) [-c CONTAINER]

  Option	Shortcut	Description	Exampe
  --container	-c	Prints a container log	kubectl logs example -c cname
  --follow	-f	Real time logs	kubectl logs -f example
  --tail		Print last X logs (default -1)	Kubectl logs --tail 100 example

Resources

Every application running inside a kubernetes cluster is deployed by creating a set of resources that interact with each other and make the application accesible to the outside world.

Those resources can be of many types, each one performs a specific task inside the cluster. They can be created declaratively through manifests files. There is not a certain number of resources, since they are retrieved from the Kubernetes API, which is extensible. However, Kubernetes natively provides a set of resources that are pre-defined in the endpoints of Kubernetes API, check the Kubernetes API section containing some of the most commonly used.

A resource is an endpoint in the Kubernetes API that stores a collection of API objects of a certain kind; for example, the built-in pods resource contains a collection of Pod objects.

Manifests

Manifests are files that describes the properties of a certain resource type. They can be written in YAML or JSON format, and vary depending on the resource type. Since many applications require multiple resources to be created, their properties can be simplified by writting the resources in the same file separated by --- lines. The following example shows how to deploy an nginx container in a pod with a LoadBalancer service to allow connections fron outside the cluster:

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Resources can be created through manifests using kubectl apply -f <manifest> command.

It is a recommended practice to put resources related to the same microservice or application tier into the same file, and to group all of the files associated with your application in the same directory. If the tiers of your application bind to each other using DNS, you can deploy all of the components of your stack together

Kubernetes API

The kubernetes API provides a set of endpoints that allow you to interact with the resources in the cluster. The API is extensible, and new resources can be added to it. The following resources comes pre-defined in the Kubernetes API and are the most commonly used for any application deployment:

 Pods

A pod is a collection of containers that are deployed on a node, it may be composed of only one container, or many directly connected containers in some advanced scenarios. Pods run inside a node of the cluster and most of the time are dynamically created by deployments.

The following manifest file describes a pod that contains a single container running nginx:

apiVersion: v1
kind: Pod
metadata:
  name: static-web
spec:
  containers:
    - name: web
      image: nginx
      ports:
        - name: web
          containerPort: 80
          protocol: TCP

Note that the apiVersion field indicates "v1". The apiVersion depends on the type of resource, run kubectl api-resources to see the list of available resources and their api group.

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: example
spec:
  replicas: 3
  selector:
    matchLabels:
      tier: example
  template:
    metadata:
      labels:
        tier: example
    spec:
      containers:
      - name: example
        image: example/example

$ kubectl create namespace <namespace>

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: {{ ClusterIP | NodePort | LoadBalancer | ExternalName }}
  selector:
    app: MyApp
  ports:
    - name: http
      protocol: TCP
      port: 80
      targetPort: 1234
      nodePort: 30000 # If type == NodePort

apiVersion: v1
kind: PersistentVolume
metadata:
  name: foo-pv
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteOnce
  storageClassName: ""
  claimRef:
    name: foo-pvc
    namespace: foo

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: simple-db
  namespace: simple-app
  labels:
    app: simple-db
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

apiVersion: v1
kind: ConfigMap
metadata:
  name: game-demo
data:
  # property-like keys; each key maps to a simple value
  player_initial_lives: "3"
  ui_properties_file_name: "user-interface.properties"

  # file-like keys
  game.properties: |
    enemy.types=aliens,monsters
    player.maximum-lives=5    
  user-interface.properties: |
    color.good=purple
    color.bad=yellow
    allow.textmode=true   

Check other resources API like Project Contour and Cert-Manager for managing reverse proxy, web sockets and HTTP over TLS Certificates.

Conclusion

This is the end of this post about kubernetes, eventhough it might seem pretty long, Kubernetes is a very powerful platform that extends reeeeeaally far beyond this post. Feel free to check out the Kubernetes documentation and keep learning on one of the most used technologies world wide.