Kubernetes is being adopted at companies at
a high pace and anyone with knowledge in that has a career advantage. You can even become a
full-time Kubernetes engineer at your job, it has almost become its own role. Kubernetes is an
amazing powerful platform, but a very complex one, which means you have a steep learning curve. And
even though many people want to learn Kubernetes, often they don't know where to start. So
it certainly helps to have a guidance and a sort of a roadmap of how to approach learning
Kubernetes efficiently. That's why I want to give you a step-by-step roadmap of what to learn
and in which order to structure your learning of Kubernetes. Now I know it also helps to have this
type of roadmap visualized in a written format, so we also created an accompanying PDF
roadmap for you, which you can download from our website for free. I will link all
the resources in the video description. Here's the most important point to consider
when you start learning Kubernetes, which will make your learning journey much easier and
more efficient, is to understand the following: Kubernetes platform, like almost all other
platforms, has two sides or aspects of it. The administration side, meaning someone needs to set
it up, initialize, configure all the essentials to prepare it for its actual usage. And the platform
user side meaning someone will now start actually using it deploying applications and services
inside. Just like with AWS cloud platform or Jenkins platform for example, you have to set it
up like create an AWS account or install Jenkins service, then configure the access, install
or activate any plugins needed or services, secure the platform to make it usable and so
on. And once that's done and accesses are given, the engineers, who actually need to use the
platform we'll create the pipeline on Jenkins or deploy their application to AWS platform and so
on. So these are two different roles. So we need to differentiate and draw the line between the
two. You need to understand, which aspect of the technology you want to learn and you can decide
that based on your role. Are you an application developer? You need a roadmap to learn how
to use Kubernetes to deploy applications and run applications inside the cluster. Are you an
operations engineer? Well then you need to learn the Kubernetes administration and operation side.
By recognizing the distinction between these two roles, you can approach your learning journey with
a clear focus. If you're a developer your primary aim will be to understand Kubernetes usage and
deployment. As an operations engineer your main focus will be on administration and Kubernetes
operations. Now you can eventually learn both, if you want to, but if you divide it and learn
one part first and then build the other on top, it will make your learning process much easier and
more structured, it will also be easier to connect the dots. There are even different certifications
for these two: You have the CKA or Kubernetes Administrator exam and you have CKAD, which is
Kubernetes Application Developer certification exam. And just like there is no learning AWS,
you learn a specific path within AWS based on your engineering role and what you want to do
on AWS platform. And you also have different AWS certifications for administrator, developer,
maybe mobile developer, data engineer and so on. So when you have clarified that, then it's easier
to create a roadmap to learn only the relevant services and concepts from hundreds of AWS
services. So it's exactly the same concept here. So we've established that we have these
two separate learning paths. However, before branching off into a specific path there
are fundamental concepts that apply to both: developers and administrators. So
first you need to learn the basics, no matter which path you continue with. These are
the building blocks of Kubernetes knowledge. So let's explore this shared topics to lay a solid
foundation for your Kubernetes learning journey first. And the most important entry point to
learning any new technology or tool is learn the why behind the technology first. What problem
does it solve that made Kubernetes so popular and widely used. The whys of how Kubernetes
helps solve issues of operating large, containerized applications. Once you've understood
"why Kubernetes" or "what problems it solves", then you can learn how it actually solves those
problems and the actual implementation of the tool and how the tool works. So this will be
the first step in grasping the fundamentals of Kubernetes. Once you've established the why, you
can dive into the core components and architecture of Kubernetes. As part of Kubernetes architecture,
you need to understand and learn about the control plane and worker nodes. What is the role of
each, how are they connected, what processes are running on them. After that you need to learn
the core building blocks of Kubernetes, which are Kubernetes components. You need to understand
what is Pod, what is a Service, ConfigMap, Secret, Ingress, Deployments, StatefulSets, Namespaces
and Volumes. These are the main Kubernetes components. Understand why each one exists and
what are their relations and connections to each other. Now these components that are mentioned,
you work with them directly, you create the Pods, you create the Services, Deployments, you also
create Worker Nodes and join them to the cluster and so on. But there are components that are part
of Kubernetes that just work behind the scenes, kind of doing its magic in the cluster. These are
the components like Scheduler, Controller, etcd, Kubelet, container runtime and so on. Even though
you may have little to do with this directly, because they just run in the background and do the
work in the cluster, but still understanding these components, what each one of them does and what is
the role of each of these services in the cluster, will help you understand how Kubernetes
works, the mechanisms behind the cluster, the self-healing functionality, the way Kubernetes
manages the desired versus actual state and keeps them in sync, scaling deployments and so on.
So when you do things in a cluster when you administer it or run applications inside,
knowing what's happening in the background from the Kubernetes perspective will definitely
make it easier for you to work with Kubernetes. Now this is all theory, right? Understanding the
architecture, components, how Kubernetes works. Now we need to move on to practice, because while
understanding the components behind a tool is essential and that's definitely where you should
start at, after that you should get hands-on, because this will give you a different level
of confidence with the tool and kind of break the fear of working with it as well. So with
a solid understanding of the fundamentals, you can now shift your focus to understanding
how to access and work with a Kubernetes cluster. As part of this, you need to learn Kubectl
command line interface and its main commands, which is essentially for interacting with
your Kubernetes cluster. Whether you are an administrator or a product engineer, you need to
learn this tool to perform various actions in the cluster. Again creating components, updating
them, troubleshooting and viewing components, analyzing and so on. Additionally, you also need
to learn about Kubernetes manifest files as part of Kubernetes basics. These are Kubernetes YAML
configuration files, which describe the desired state of your applications within the cluster.
So basically you use this to define, what Kubernetes components like Deployments, Services,
StatefulSets and so on you want to create in the cluster and what configuration you want those
components to have. And understanding how to create and manage these manifest files is going
to be very important for working with Kubernetes as well. As you progress in your Kubernetes
journey and start deploying applications inside with manifest files and Kubectl and start creating
various Kubernetes components, you will definitely encounter challenges and issues in the process
that require troubleshooting skills. So you also need to learn Kubectl commands for troubleshooting
as well as other ways of getting insights into the cluster and what's going on with your components,
like getting insights into cluster networking, the component configuration, the runtime
environment of your applications and so on. So troubleshooting is an essential skill you
will need to practice in order to work with and learn even more about Kubernetes and how things
work inside the cluster. Now when you learn how to create components and run various services in
Kubernetes you will soon notice that Kubernetes is a powerful and very flexible platform. It's
not very opinionated and you can do a lot in the cluster. So it gives you a lot of flexibility,
but this also means that you can do a lot wrong, like misconfiguring things with bad practices and
that's where details of common misconfigurations will actually help you a lot. Knowing from the
start what are some things that people without experience in Kubernetes may misconfigure. Things
that are not really logical or intuitive and where people mostly make mistakes and I find it easier
to start with bad practices and learn explicitly what not to do, before learning about the best
practices, because you learn exactly what to avoid and importantly why to avoid them and this will
also teach you more about how Kubernetes works and why are things a certain way. Such details are
usually missing in the official documentations or other common learning resources, which teach
you about a feature or a component, but usually they don't mention such details. That's why in my
educational content I always make sure to add some of the common mistakes as well as best practices
that are not immediately clear or intuitive, which I myself learned from practice, so you can
avoid making these mistakes as a beginner. Another advanced topic you can learn at this point is
Helm charts, especially as you start deploying third-party services in your cluster next to
your own applications. So learn what is Helm, what are Helm charts, what are they used for, how
they make working with Kubernetes and deploying different services easier and so on. Again the
same approach: First understand why we need them and then how to use them. So this will basically
be a really solid good foundation of Kubernetes knowledge, doesn't matter which path you continue
with. This will already get you to the level, where you know exactly what Kubernetes is, how to
work with and you're confident with the tool. And all this until here, you can actually learn on
my channel. I have videos on all these topics and I will link them in the video description,
so you don't have to search for those resources elsewhere. So now that we have a foundation of
Kubernetes knowledge, based on your engineering role and direction you want to go into, you can
now branch out to either Kubernetes administrator side or Kubernetes user side. Let's start with
the Kubernetes administrator roadmap first! On this foundation you can now build the
knowledge you need to administer and operate a Kubernetes cluster. First start by understanding
different ways of operating Kubernetes cluster, like self-managed and managed Kubernetes
services, which are offered by cloud providers, such as AWS EKS or Azure AKS and understand the
pros and cons of each one and the differences between them. This will help you make informed
decisions about how to operate Kubernetes cluster for your specific organization or
your engineering teams. Another important concept you need to learn as a Kubernetes
administrator to do your job effectively, is Networking in Kubernetes. Networking plays
an important role in how various components communicate within a cluster. You should learn
the concepts such as Ingress, Network Policies, Pod-to-Pod communication, Pod-to-Service
communication, Kubernetes Network Interface and Network Plugins, cluster DNS service and
so on. Understanding these networking concepts is absolutely essential, especially when you
want to administer a self-managed Kubernetes cluster. Troubleshooting and fixing networking
issues is very difficult if you don't understand properly how Kubernetes networking works. As
part of networking, also understand the soft network isolation with namespaces as well as hard
network isolation between cluster components and why this concept is important in general. Now
most of the networking functionality, once you install network plugin in cluster is automatic.
So in terms of establishing communication between cluster components or joining new servers to
the Kubernetes network, Kubernetes does a lot of these out of the box without much effort
and configuration needed from administrator, which is great. But there is another essential
responsibility of a Kubernetes administrator that you need to explicitly configure and set up and
you need to set up properly with best practices, and this is cluster access management. Basically
"who can do what" in the cluster. As I said Kubernetes is complex and powerful, so you don't
want unauthorized people with little knowledge of Kubernetes to have admin permissions to mess
everything up. So understanding Kubernetes RBAC or Role-Based Access Control is very important
to make sure that everyone has correct access permissions to the cluster resources and everyone
can do their job without messing things up in the cluster. For this you need to learn Kubernetes
components, such as Roles, ClusterRoles, Role- and ClusterRole Bindings, ServiceAccounts as well
as Kubeconfig and how it works. Creating client certificates in Kubernetes for human users as
well as how to integrate various authentication services in Kubernetes cluster. So you can
give engineers in your organization access to the cluster more easily as an administrator.
You also will need to take care of data backups in Kubernetes. You need to make sure to have
a proper mechanism in place to easily recover your cluster in case of a disaster. For this you
need to understand generally how data is managed in Kubernetes and that by default you have no
data persistence in Kubernetes and generally in the container world. You need to understand the
concept of Kubernetes Volumes and how data is plugged into the applications inside the cluster
through Volumes. Apart from the application data, you also need to understand etcd, which is data
storage for Kubernetes cluster configuration data itself. And you need to understand what's stored
inside, how to backup and secure etcd store with all its sensitive cluster data as well as how
to secure any secret data for various cluster applications. As a Kubernetes admin you also need
to learn the concept of Kubernetes operators. When you start deploying more complex stateful
applications, like databases in your Kubernetes cluster, you will come across the operators.
Kubernetes operator is basically the service itself bundled with the intelligent logic of
operating that service automatically within the cluster. So instead of human intervention
of setting up, initiating maintaining and so on that service, so basically operating the service,
the automated operator does all that, which is a powerful extension of Kubernetes capabilities.
So understanding this concept, learning how to deploy and use operators, will help you a lot
in administering the cluster. To have insights into what's going on in your cluster you need
monitoring. And it's your job as a Kubernetes administrator to take care of configuring and
setting up monitoring on a cluster level. You can't manage and administer or fix what you can't
see. One of the most popular tools for monitoring in Kubernetes is Prometheus and when you
deploy a monitoring stack including Prometheus, Alert Manager and all the components that come
with it, you will be able to deploy it with a Kubernetes operator, because there is an operator
for the monitoring stack. Which again means all these skills that I just mentioned kind of stack
up on top of each other and each one kind of helps in doing the other task better. And generally for
all the above administrative tasks you need to learn the best practices as well, not just any way
of doing it and configuring it so that it works, but the best way of operations and security in
Kubernetes. So that's basically your roadmap if you want to become a Kubernetes administrator and
learn that aspect of the platform. Now having a roadmap like this is great for structuring your
learning, but you still need to find the right resources that explain these concepts properly,
you have to put them in the right order, make sure you don't miss any important topics. That's still
a huge effort to research all of these and drains the motivation right at the beginning. So instead
as a simpler alternative you can actually enroll in our pre-structured course, where I already did
all that heavy lifting of creating the perfect curriculum with the right hands-on projects and
practical examples for these specific learning path. Many of our students right after completing
the course successfully passed the CKA exam and became Certified Kubernetes Administrators
only through this course. But more importantly, because for me this is more important than the
certification it's itself, they are actually able to apply the knowledge from the course directly
in their work and actually administer a Kubernetes cluster. So if you are interested in this path,
definitely check out our CKA course to make your life easier. Now of course we don't operate
Kubernetes just for the sake of operating it, right? A product team actually needs to use
it. So that's the Kubernetes user or developer roadmap. As a Kubernetes user your main goal is to
deploy and run your applications in a Kubernetes cluster with high availability, meaning even if
something happens in your application it's still accessible for users and that's where Kubernetes
power actually lies. So you need to understand the concepts of replicating your application in
Kubernetes, scaling your application up and down to adjust to the load, and for that you need
to learn more about Deployments, ReplicaSets, you need to learn how to configure Readiness and
Liveness probes and you need to also learn how to achieve all that for stateful applications
as well. But as I mentioned at the beginning, all such cluster components are defined
through Kubernetes manifest files, so we send those manifests to Kubernetes to actually
apply them and they contain a definition of what the desired cluster state should be. Again
what should be created, updated and so on, which means as a Kubernetes user you need deeper
knowledge of Kubernetes manifest files, syntax, structure, configuration details for different
Kubernetes objects like Deployments, Services etc. Again how to configure liveness and
readiness probes for your applications inside the Deployment configuration file, how
to define init containers for your application, how to use Volumes, understand the types of
Volumes to decide which one is the best for which use case and application. And how to configure
that for your application definition, how to configure Services for different applications
with different Service types and so on. Another important thing to learn as a Kubernetes user
is deploying your application changes without causing your application downtime or deploying
without risking that the application changes may crash the entire application in a production
environment. For that you need to learn deployment strategies that you can use in Kubernetes, such
as canary deployments, blue green deployments, rolling updates and rollbacks. And when you know
these deployment strategies, you can decide which one fits best for your application and for
your cluster. When deploying your application changes to Kubernetes, you won't be doing that
manually. As part of your developer workflow, you will have CI/CD release pipeline configured
that actually deploys to the end environment. So you need to learn how to integrate CI/CD into
Kubernetes cluster to do automatic deployments, where whether it's a self-managed or managed
Kubernetes service. Again with best practices and the right deployment strategy for your application
within the frame of Kubernetes. Knowledge of those configuration details that I just mentioned may
be even more important when you're deploying more complex microservice applications, because now you
have to connect them properly within the cluster and configure all needed third-party services for
your microservices application. And that's where you will need to learn more about services
that you can deploy inside cluster for such microservice applicatio,n like a service mesh for
example. You also need to understand how to handle traffic to the cluster as well as between your
services. So that will be the part that covers usage of Kubernetes to the advanced level. Now
hopefully this gives you a clear roadmap of how to structure your learning and helps you get
started. There are many resources out there: official documentation, articles, individual
videos that you can put together to learn all this stuff, but I know from experience that this
is still a lot of effort and time to research and find the right resources, thinking about the
roadmap and structuring, having to collect all the learning resources, analyze which ones are
easy to follow and understandable, not outdated, not missing important information, making sure
you don't have knowledge gaps left and so on. If you don't want to go through this process and
make it easier for you, save your time and energy as I mentioned before, you can use our courses to
learn all this. You just follow the prepared path, which is perfectly laid out for you and learn
both the whys to really understand the concepts as well as how's of practically working with the
tool and actually implementing these things. So in terms of learning resources, as a starting
point for the shared knowledge that you need for both directions, you can use my one hour
Kubernetes video or the 4 hour tutorial video, which are both on my YouTube channel and
absolutely free. If it's easy to follow and understandable for you and you decide you want to
learn Kubernetes properly to the advanced level, for the administration path you can use our CKA
course. And if you want to build on top of that, learn how to use Kubernetes to the advanced level
as well as other operational parts of Kubernetes, you can enroll in our DevOps Bootcamp, where
I teach Kubernetes in combination with various other DevOps technologies, including the managed
Kubernetes service, AWS EKS, automating Kubernetes cluster provisioning with Terraform, deploying
from Jenkins CI/CD pipeline to Kubernetes cluster, monitoring and alerting in Kubernetes and more
based on actual real-life use cases that you can apply directly at work as an engineer. And
if you want to take it even one step higher and learn about the security best practices and secure
configuration of Kubernetes cluster specifically, then soon we are releasing a full DevSecOps
bootcamp, where a large part of that bootcamp will actually cover security in Kubernetes
to the advanced level. So you can also use it as different steps of learning the basics
and then moving to the next level of learning and acquiring new engineering skills. But
regardless of which resources you use to learn, be sure to follow this roadmap step by step for
each concept. First understand the why and then immediately put it in practice, so you can have
the full picture of the theory and practice. If you decide to learn yourself take a containerized
dockerized, open source application and deploy that to a Kubernetes cluster, you will learn a lot
in that process alone to at least get started and break through the fear of working with Kubernetes.
I hope this comprehensive roadmap will guide you through your Kubernetes learning journey. Please
let me know in the comments if it did actually help to break it down like this and also if
you want me to do similar roadmap videos on any other technology or platform, also let me
know in the comments. I try to read all your comments and respond to all of them as much as
I can and I absolutely appreciate hundreds and thousands of positive comments and amazing
feedback you guys leave under my videos. So thank you for that! And with that as always thank
you for watching and see you in the next video! :)
