What's Hard About Learning Kubernetes?

Learning objectives
  • Understand the difficulties with learning Kubernetes
  • Explore benefits and advantages of Kubernetes
  • Discover uses for Kubernetes

In environments where developers create native cloud applications, learning containerization and the tools that orchestrate deployments is necessary. Kubernetes is the standard in container orchestration and deployment management. Kubernetes can be difficult to learn for someone only familiar with traditional hosting and development environments. Learning a new software development environment can be hard for some people with little time to spend reading and practicing, and then for others it could be difficulties with learning cloud-native architecture after coding for traditional infrastructure for many years. Whatever the difficulties, every developer and operations person can get up to speed with containerization and Kubernetes with enough time and effort.


What is Kubernetes?

The idea of refactoring to a containerized environment usually starts with a desire to speed up code deployments or the idea that cloud-native applications have several benefits outweighing the cost to continue housing on-premise applications. Kubernetes (K8s -- pronounced “kates”) is an open-source orchestration tool for containers. “Orchestration” refers to the automation of deployment, monitoring, maintenance and configuration of containers for developers and operations. It’s often found in environments where continuous integration and continuous deployment (CI/CD) are found. 

If you research containerization or decide that it’s time to leverage cloud-native applications, Kubernetes will be a part of your research and will likely be your orchestration tool of choice. Here are a few of the reasons and benefits why Kubernetes is popular:

  • It works with any platform and environment. Kubernetes works with almost any type of container runtime. Linux is needed for the master node, but worker nodes can run on Windows (2019 or later) servers. 
  • Works on multi-cloud environments and on multiple providers. Vendor lock-in is an issue when organizations move to the cloud. Using a vendor-specific tool locks you into a cloud provider service, but Kubernetes works across all major cloud provider platforms.
  • It’s open-source technology. Many developers like open-source software for its community of developers who contribute to the source code and the ability to customize the source code if necessary.
  • It’s well-documented. The Kubernetes site and community has several examples and tutorials available. It’s also fully documented so that any questions about use cases and the ways to deploy Kubernetes can be answered.

Why use Kubernetes?

As you begin researching and learning Kubernetes, you might wonder if it’s better to learn a tool with a smaller learning curve, but Kubernetes is worth the effort in a containerized environment. Kubernetes has several benefits and can be found integrated into large enterprise development lifecycles due to the time-cost benefits. Several case studies have been documented from companies that used Kubernetes where they were able to lower costs and speed up delivery of applications.

Kubernetes is an orchestration tool, and you may ask if an orchestration tool is necessary when you work with containers. While orchestration tools aren’t absolutely necessary, they make automation, deployment, and maintenance of containers more efficient. They also configure containers as they are deployed, so human errors are reduced. Without them, it makes a containerized environment more difficult to manage.

Some benefits of working with orchestration tools:

  • Configure the environment during deployment. Instead of manually configuring changes (e.g., environment variables) and introducing potential human errors, orchestration tools will deploy and configure the applications.
  • Automate container deployment based on a more frequent schedule. Instead of scheduling deployment on a specific day of the week or month, deployments can be automated throughout the day as developers code and test their applications increasing speed of development.
  • Monitor container health. Orchestration tools such as Kubernetes lets you get an overall picture of container health and performance.

Advantages of Kubernetes particularly:

  • Developers can create a cluster of nodes that run applications in a pool of resources.
  • Kubelet tracks nodes and ensures that containers are started and running.
  • A group of containers deployed in a single node called a “pod” can be used to share an IP address, hostname and other resources.

What makes Kubernetes difficult?

The many moving parts and new architecture are two hurdles to overcome when learning Kubernetes. Although there are several advantages of using Kubernetes, they aren’t realized during the frustration of learning it. The change to a containerized environment takes a lot of time and effort and any mistakes will require immediate attention. In addition to refactoring code, developers must also build in fault tolerance, scaling, deployment schedules to support frequent changes, and rollback plans in case of catastrophic errors.

The addition of several moving pieces makes orchestration tools necessary. Orchestration tools help with management of containers, pods, and configurations. You can potentially have thousands of containers running multiple applications, so tracking and monitoring them efficiently without help is implausible. Kubernetes manages containers, but it’s difficult for developers to understand the moving parts in a large enterprise container environment.

Having many more moving parts also introduces a larger attack surface. Security researchers suggest that your attack surface should be as small as possible, but containers expand it. Developers are also unaware of the many ways code can introduce vulnerabilities. This means that developers must also learn new ways to write code that doesn’t introduce vulnerabilities and configure containers in a way that does not introduce ways to exploit the system.

Kubernetes will automate deployment to a staging and production environment, but it puts extra overhead on developers and operations to ensure that both environments mirror each other. Making a mirror image of production and keeping it always in the same state as production can be challenging.

Containers are sold as a way to lower cost, but they can actually cost IT more if they are not deployed properly. Developers must monitor resources and configure Kubernetes to manage container resources to run efficiently across the environment, while also ensuring that the staging environment mirrors production.

Failing to configure Kubernetes properly can result in performance degradation. Parameters in Kubernetes configure resources in the cluster, and it takes time for developers to understand the right parameters to configure and the ones necessary to run at optimal performance. Incorrect configurations could also result in downtime, and this factor can be especially troublesome in a continuous integration and deployment environment.

Finally, just like the world of IT is always changing, Kubernetes and containerized technology continue to change. Developers must always keep learning and investing time in understanding the ways Kubernetes changes. Because of this, developers should keep up to date with the latest changes, best practices, and any recommendations from experts.


Table of contents

Logging in the Age of DevOps eBook

Download Now