Kubernetes Learning Curve: How Hard It is to Learn K8s?

Kubernetes Learning Curve

Introduction

Kubernetes has been around for quite some time. Since then, it has revolutionized the way companies serve their applications to their clients.

An app in a container is easy to move around. And it's also easy to clone. Kubernetes can create more containers with that app inside (scale up) when needed. And it can remove excess containers when they're not needed (scale down). This helps a company's services easily adapt to user demand. And it makes the services more reliable. Kubernetes can quickly recreate defective containers where the app has malfunctioned.

Kubernetes was the answer to three common concerns of organizations: infrastructure costs, reliability, and user experience.

As Kubernetes grows in popularity, so does the demand for professionals skilled enough to manage it. So for anyone who wants to have better career options in the job market, Kubernetes may be something you can add to your skill set. But how is the Kubernetes Learning Curve exactly?

Is Kubernetes Hard to Learn?

When you work with Kubernetes, you'll usually deal with 3 big things:

1. Containers.

2. The kubectl command.

3. Kubernetes manifests written in YAML format.

#1. Containers

The main job of Kubernetes is to manage thousands of containers. So it's kind of implied that you should understand how containers work. Learning about these is a pretty straightforward process. If you're a total beginner, you can use this course to learn about Docker.

Consider a scale of 1 to 10. 1 meaning, super easy to learn, 10 meaning super hard. Difficulty to learn about containers and Docker is around 5-6/10.

#2. kubectl Command

With the kubectl command you basically "talk" to your Kubernetes cluster. And you could tell it things like these:

  • Remove server5 from the cluster.
  • Show me all servers that currently make up this cluster.
  • Show me some logs, so I can figure out what went wrong.

These commands interact with the cluster itself. But most of the kubectl commands you will use will actually interact with so-called objects instead. We will look at an object example in the next section.

So most of your work will be done through the kubectl command. If you'll want to tell Kubernetes to run 10 Nginx containers, you will do so with the help of kubectl. If you'll want to inspect the logs of one container, you will also use the kubectl command. So you will have to learn about commands like:

kubectl apply -f config.yaml
kubectl logs nginx

and so on.

The kubectl command is easy to understand. And there aren't many command patterns that you need to remember.

The difficulty for learning kubectl is around 2-3/10.

#3. Kubernetes Objects Declared in YAML format (Manifest Files)

Now, this is where it gets tricky. Remember how we said that if you want to run containers you run the kubectl command? You could run something like:

kubectl apply -f nginx.yaml

With this, we basically tell Kubernetes: "Hey, create the objects I declared in this nginx.yaml file." Short and sweet command, but that's not where the story ends. The tricky part is writing, and understanding that file. Here's an example of what we could have in such a YAML file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # tells deployment to run 2 pods matching the template
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

If you're familiar with Docker, you can understand where we told Kubernetes what containers to run. And this is probably the most difficult task when you learn about this tool. It takes a while to understand how objects should be declared in such YAML files. The syntax and words are easy enough to remember. But the hard part is understanding the logic behind Kubernetes objects. What is a pod, service, or deployment is. How they work. How they're connected. It takes a while to wrap your mind around these Kubernetes concepts.

The difficulty to understand Kubernetes objects is probably around 8-9/10.

But don't let that intimidate you. Yes, Kubernetes is hard to learn, if you do that on your own. But there is an alternative that's much more simple. Use some guidance. Follow an easy-to-understand course about Kubernetes.

Conclusion

We can see that some Kubernetes-related things are easy to learn. Containers and the kubectl command are straightforward. Understanding Kubernetes' internal logic, that's the tricky part. But, as mentioned, you can start out with an easy-to-understand course about Kubernetes. That will clear up all of the initial mysteries. At that point, you'll find Kubernetes a bit less intimidating.

And if you want a job in this domain, we've got you covered! We have a collection of courses that explain all of the important concepts. They will take you from beginner level to Kubernetes expert! Want to jump into a Kubernetes career? Check out our Kubernetes learning path.