* [Topics](/en/topics "Topics")
* [Containers](/en/topics/containers "Containers")
* Learning Kubernetes basics
Learning Kubernetes basics
==========================
Published  August 12, 2020•*6*-minute read
Copy URL
Jump to section
---------------
OverviewKubernetes architectureOther piecesHow Kubernetes worksKubernetes deploymentsKubernetes patternsKubernetes operatorsTraining & administrationOpenShift ApplicationsKubernetes for the enterprise
Overview
--------
Containers let developers focus on their apps while operations focus on the infrastructure—container orchestration is the way you manage these deployments across an enterprise.
[Kubernetes](/en/topics/containers/what-is-kubernetes) is an open source container orchestration platform that automates many of the manual processes involved in deploying, managing, and scaling containerized applications.
Kubernetes can help you deliver and manage containerized, legacy, and cloud-native apps at scale, as well as those being refactored into microservices across environments, including private cloud and major public [cloud providers](/en/topics/cloud-computing/what-are-cloud-providers) like Amazon Web Services (AWS), [Google Cloud](/en/partners/google), IBM Cloud, and [Microsoft Azure](/en/about/press-releases/red-hat-and-microsoft-fuel-hybrid-cloud-development-azure-red-hat-openshift).
[Get an introduction to enterprise Kubernetes](/en/engage/introduction-enterprise-kubernetes-s-202003040257 "SOLP: An introduction to enterprise Kubernetes")
Kubernetes architecture
-----------------------
Kubernetes gives you the platform to schedule and run containers on clusters of physical or [virtual machines.](/en/topics/virtualization/what-is-a-virtual-machine) Kubernetes architecture divides a cluster into components that work together to maintain the cluster's defined state.
A [Kubernetes cluster](/en/topics/containers/what-is-a-kubernetes-cluster) is a set of node machines for running containerized applications. You can visualize a Kubernetes cluster as two parts: the control plane and the compute machines, or nodes. Each node is its own [Linux®](/en/topics/linux/what-is-linux) environment, and could be either a physical or virtual machine. Each node runs pods, which are made up of containers.
The [Kubernetes API](/en/topics/containers/what-is-the-kubernetes-api) (application programming interface) is the front end of the Kubernetes control plane and is how users interact with their Kubernetes cluster. The API server determines if a request is valid and then processes it.
The Kubernetes API is the interface used to manage, create, and configure Kubernetes clusters. It's how the users, external components, and parts of your cluster all communicate with each other.
This quick Kubernetes tutorial shows you how to create a cluster and deploy an application.
[Get started with Kubernetes tutorial](https://opensource.com/article/17/11/getting-started-kubernetes)
Red Hat resources
-----------------
[Keep reading](/en/resources "Keep reading")
Other pieces of a Kubernetes cluster
------------------------------------
**Nodes:**  
These machines perform the requested tasks assigned by the control plane.
**Pod:**  
A set of 1 or more containers deployed to a single node. A pod is the smallest and simplest Kubernetes object.
**Service:**  
A way to expose an application running on a set of pods as a network service. This decouples work definitions from the pods.
**Kubectl:**  
The command line interface where you can manage your Kubernetes cluster. Learn [basic kubectl and Helm commands for beginners.](https://opensource.com/article/20/2/kubectl-helm-commands)
**kubelet:**  
A tiny application located within each node that communicates with the control plane. The kublet makes sure containers are running in a pod.
[See the additional components of a Kubernetes architecture](/en/topics/containers/kubernetes-architecture)
If you’re ready to get started with Kubernetes for yourself, Minikube is an open source tool that allows you to set up a local Kubernetes cluster so you can try out Kubernetes from a laptop.
[Use this guide on running Minikube for Linux users](https://opensource.com/article/18/10/getting-started-minikube)
How Kubernetes works
--------------------
Kubernetes works based on defined state and actual state. Kubernetes objects represent the state of a cluster and tell Kubernetes what you want the workload to look like.
Once an object has been created and defined, Kubernetes works to make sure that the object always exists.
Controllers actively manage the state of Kubernetes objects and work to make changes that move the cluster from its current state to the desired state.
Developers or sysadmins specify the defined state using the [YAML](/en/topics/automation/what-is-yaml) or JSON files they submit to the Kubernetes API. Kubernetes uses a controller to analyze the difference between the new defined state and the actual state in the cluster.
The desired state of a Kubernetes cluster defines which applications or other workloads should be running, along with which container images they use, which resources should be made available to them, and other configuration details.
Configuration data and information about the state of the cluster lives in etcd, a key-value store database. Fault-tolerant and distributed, [etcd](/en/topics/containers/what-is-etcd) is designed to be the ultimate source of truth about your cluster.
Kubernetes will automatically manage your cluster to match the desired state. Controllers usually do this by sending messages to the API server that result in the needed changes, and some Kubernetes resources have built-in controllers.
As an example of how Kubernetes manages desired state, suppose you deploy an application with a desired state of "3," meaning 3 replicas of the application should be running.
If 1 of those containers crashes, the Kubernetes replica set will see that only 2 replicas are running, so it will add 1 more to satisfy the desired state.
Replica sets are a type of controller that ensures a specified number of pods are running at any given time.
Kubernetes deployments are the preferred method for managing replica sets and provide declarative updates to pods so that you don’t have to manually manage them yourself.
You can also use autoscaling in Kubernetes to manage the scale of your services based on user demand. When specifying the desired state of an application or service, you can also tell the controller to make additional pods available if demand increases.
For example, during a busy time period your application's desired state could increase to 10, instead of the usual 3 replicas
Kubernetes deployments
----------------------
A Kubernetes deployment is a resource object in Kubernetes that provides declarative updates to applications.
A deployment allows you to describe an application’s life cycle, such as which images to use for the app, the number of pods there should be, and the way in which they should be updated.
The process of manually updating containerized applications can be time consuming and tedious. A Kubernetes deployment makes this process automated and repeatable.
Deployments are entirely managed by the Kubernetes backend, and the whole update process is performed on the server side without client interaction.
The Kubernetes deployment object lets you:
* Deploy a replica set or pod
* Update pods and replica sets
* Rollback to previous deployment versions
* Scale a deployment
* Pause or continue a deployment
[Continue reading about Kubernetes deployments](/en/topics/containers/what-is-kubernetes-deployment "article | what is a kubernetes deployment?")
Kubernetes patterns
-------------------
[Kubernetes patterns](/en/topics/cloud-native-apps/introduction-to-kubernetes-patterns) are design patterns for container-based applications and services.
Kubernetes can help developers write cloud-native apps, and it provides a library of application programming interfaces (APIs) and tools for building applications.
However, Kubernetes doesn’t provide developers and architects with guidelines for how to use these pieces to build a complete system that meets business needs and goals.
Patterns are a way to reuse architectures. Instead of completely creating the architecture yourself, you can use existing Kubernetes patterns, which also ensure that things will work the way they’re supposed to.
Patterns are the tools needed by a Kubernetes developer, and they will show you how to build your system.
Kubernetes operators
--------------------
A [Kubernetes operator](/en/topics/containers/what-is-a-kubernetes-operator) is a method of packaging, deploying, and managing a Kubernetes application. A Kubernetes application is both deployed on Kubernetes and managed using the Kubernetes API and kubectl tooling.
A Kubernetes operator is an application-specific controller that extends the functionality of the Kubernetes API to create, configure, and manage instances of complex applications on behalf of a Kubernetes user.
Learn how to [build a Kubernetes operator in 10 minutes](https://opensource.com/article/20/3/kubernetes-operator-sdk) using the Operator SDK.
It builds upon the basic Kubernetes resource and controller concepts, but includes domain or application-specific knowledge to automate the entire life cycle of the software it manages.
If you want more detail on Kubernetes operators and why they’re important [here’s how to explain them in plain English.](https://enterprisersproject.com/article/2019/2/kubernetes-operators-plain-english)
Operators allow you to write code to automate a task, beyond the basic automation features provided in Kubernetes. For teams following a DevOps or [site reliability engineering (SRE)](/en/topics/devops/what-is-sre) approach, operators were developed to put SRE practices into Kubernetes.
Learn more about how Kubernetes operators work, including real examples, and how to build them with the Operator Framework and software development kit.
[Learn more about implementing DevOps](/en/topics/devops "topic | understanding devops")
Training & administration
-------------------------
#### Deploying Containerized Applications Tech Overview
This on-demand series of short lectures and in-depth demonstrations introduces you to Linux containers and container orchestration technology using Docker, Kubernetes, and Red Hat® OpenShift® Container Platform.
[Start the training course](/en/services/training/do080-deploying-containerized-applications-technical-overview)
### 
#### Red Hat OpenShift Administration
This course teaches you how to install and administer the Red Hat OpenShift Container Platform. This hands-on, lab-based course shows you how to install, configure, and manage OpenShift clusters and deploy sample applications to further understand how developers will use the platform.
[Explore the training course](/en/services/training/red-hat-openshift-administration-ii-configuring-a-production-cluster)
Introduction to OpenShift Applications
--------------------------------------
This course is a developer-focused introduction to Red Hat OpenShift application building, deployment, scaling, and troubleshooting. As OpenShift and Kubernetes continue to become widely adopted, developers are increasingly required to understand how to develop, build, and deploy applications with a containerized application platform
[Start the training course](/en/services/training/do080-deploying-containerized-applications-technical-overview "Deploying Containerized Applications Technical Overview")
Kubernetes for the enterprise
-----------------------------
Red Hat OpenShift is Kubernetes for the enterprise. It includes all of the extra pieces of technology that make Kubernetes powerful and viable for the enterprise, including registry, networking, telemetry, security, automation, and services.
With Red Hat OpenShift, developers can make new containerized apps, host them, and deploy them in the cloud with the scalability, control, and orchestration that can turn a good idea into new business quickly and easily.
You can try using Red Hat OpenShift to automate your container operations with a free 60-day evaluation.
[Try Red Hat OpenShift for free](/en/technologies/cloud-computing/openshift/try-it "product | red hat openshift | try it")
Resource
Red Hat named a Leader in 2025 Gartner® Magic Quadrant™ for Container Management
--------------------------------------------------------------------------------
Read the 2025 Gartner® Magic Quadrant™ for Container Management to learn why Red Hat OpenShift has been named a “Leader” for the 3rd year in a row.
[Read the report](/en/engage/gartner-magic-quadrant-container-management-analyst-report "Red Hat named a Leader in 2025 Gartner® Magic Quadrant™ for Container Management")
All Red Hat product trials
--------------------------
Our no-cost product trials help you gain hands-on experience, prepare for a certification, or assess if a product is right for your organization.
[Keep reading](/en/products/trials "All Red Hat product trials")
Keep reading
------------
### Red Hat OpenShift for developers
Develop applications without worrying about infrastructure. Red Hat® OpenShift® helps you build and deploy applications using the tools you want.
[Read the article](/en/technologies/cloud-computing/openshift/developers "product article | Red Hat OpenShift for developers")
### What is a Linux container?
Find out more about Linux containers, which are a set of 1 or more processes that are isolated from the rest of the system.
[Read the article](/en/topics/containers/whats-a-linux-container "article | what is a linux container?")
### Why choose Red Hat for Kubernetes?
With Red Hat OpenShift, Red Hat provides a hybrid cloud enterprise Kubernetes platform for building and running new cloud native applications, as well as modernizing existing ones.
[Read the article](/en/topics/containers/why-choose-red-hat-kubernetes "article | Why choose Red Hat for Kubernetes?")
Containers resources
--------------------
### Related content
* Case study
  [[node:rh-smart-meta-title]](/en/resources/holcim-digital-center-case-study)
* Case study
  [Powering O2’s next-generation 5G network with Red Hat OpenShift](/en/resources/o2-czech-republic-case-study)
* Blog post
  [Simplify Red Hat Enterprise Linux provisioning in image builder with new Red Hat Lightspeed security and management integrations](/en/blog/simplify-red-hat-enterprise-linux-provisioning-image-builder-new-red-hat-lightspeed-security-and-management-integrations)
* Case study
  [Advent One modernizes IT with Red Hat](/en/resources/advent-one-case-study)
### Related articles
* [What is an image builder?](/en/topics/linux/what-is-an-image-builder)
* [Red Hat OpenShift for developers](/en/technologies/cloud-computing/openshift/developers)
* [What is a Linux container?](/en/topics/containers/whats-a-linux-container)
* [Why choose Red Hat for Kubernetes?](/en/topics/containers/why-choose-red-hat-kubernetes)
* [What is CaaS?](/en/topics/cloud-computing/what-is-caas)
* [What is Podman?](/en/topics/containers/what-is-podman)
* [What is Podman Desktop?](/en/topics/containers/what-is-podman-desktop)
* [Containers vs. VMs: Similarities, differences, and combined approaches](/en/topics/containers/containers-vs-vms)
* [Edge computing with Red Hat OpenShift](/en/technologies/cloud-computing/openshift/edge-computing)
* [What is container orchestration?](/en/topics/containers/what-is-container-orchestration)
* [Stateful vs stateless applications](/en/topics/cloud-native-apps/stateful-vs-stateless)
* [What is Kubernetes?](/en/topics/containers/what-is-kubernetes)
* [Red Hat OpenShift on VMware](/en/technologies/cloud-computing/openshift/vmware)
* [What is KubeVirt?](/en/topics/virtualization/what-is-kubevirt)
* [Why use Red Hat Ansible Automation Platform with Red Hat OpenShift?](/en/technologies/cloud-computing/openshift/ansible-on-openshift)
* [What is the Kubernetes Java client?](/en/topics/cloud-computing/what-is-kubernetes-java-client)
* [What are hosted control planes?](/en/topics/containers/what-are-hosted-control-planes)
* [What is kubernetes security?](/en/topics/containers/kubernetes-security)
* [How Kubernetes can help AI/ML](/en/topics/cloud-computing/how-kubernetes-can-help-ai)
* [What is Kubeflow?](/en/topics/cloud-computing/what-is-kubeflow)
* [What are microservices?](/en/topics/microservices/what-are-microservices)
* [What is container security?](/en/topics/security/container-security)
* [OpenShift vs. OpenStack: What are the differences?](/en/technologies/cloud-computing/openshift/openshift-vs-openstack)
* [What are sandboxed containers](/en/topics/containers/sandboxed-containers)
* [What is Buildah?](/en/topics/containers/what-is-buildah)
* [Kubernetes vs OpenStack](/en/topics/openstack/kubernetes-vs-openstack)
* [What are validated patterns?](/en/topics/cloud-computing/what-are-validated-patterns)
* [Kubernetes on AWS: Self-Managed vs. Managed Applications Platforms](/en/topics/containers/kubernetes-on-aws)
* [Red Hat OpenShift vs. OKD](/en/topics/containers/red-hat-openshift-okd)
* [Red Hat OpenShift vs. Kubernetes: What's the difference?](/en/technologies/cloud-computing/openshift/red-hat-openshift-kubernetes)
* [What is high availability and disaster recovery for containers?](/en/topics/containers/high-availability-containers)
* [Why run Apache Kafka on Kubernetes?](/en/topics/integration/why-run-apache-kafka-on-kubernetes)
* [Spring on Kubernetes with Red Hat OpenShift](/en/technologies/cloud-computing/openshift/spring)
* [What is a golden image?](/en/topics/linux/what-is-a-golden-image)
* [What are Red Hat OpenShift cloud services?](/en/technologies/cloud-computing/openshift/what-are-red-hat-openshift-cloud-services)
* [VNF and CNF, what’s the difference?](/en/topics/cloud-native-apps/vnf-and-cnf-whats-the-difference)
* [What is a container registry?](/en/topics/cloud-native-apps/what-is-a-container-registry)
* [What is Skopeo?](/en/topics/containers/what-is-skopeo)
* [What are Red Hat OpenShift Operators?](/en/technologies/cloud-computing/openshift/what-are-openshift-operators)
* [Using Helm with Red Hat OpenShift](/en/technologies/cloud-computing/openshift/helm)
* [Kubernetes security best practices](/en/topics/containers/kubernetes-security-best-practices)
* [Orchestrating Windows containers on Red Hat OpenShift](/en/technologies/cloud-computing/openshift/windows-containers-on-red-hat-openshift)
* [What is a Kubernetes operator?](/en/topics/containers/what-is-a-kubernetes-operator)
* [High performance computing with Red Hat OpenShift](/en/technologies/cloud-computing/openshift/high-performance-computing)
* [Advantages of Kubernetes-native security](/en/topics/containers/advantages-of-kubernetes-native-security)
* [What is KubeLinter?](/en/topics/containers/what-is-kubelinter)
* [Intro to Kubernetes security](/en/topics/containers/intro-kubernetes-security)
* [Container and Kubernetes compliance considerations](/en/topics/containers/compliance)
* [How microservices support IT integration in healthcare](/en/topics/microservices/microservices-in-healthcare)
* [Kubernetes cluster management](/en/technologies/cloud-computing/openshift/kubernetes-cluster-management)
* [Red Hat OpenShift on IBM IT infrastructure](/en/technologies/cloud-computing/openshift/what-is-red-hat-openshift-on-IBM-IT-infrastructure)
* [Red Hat OpenShift for business leaders](/en/technologies/cloud-computing/openshift/business-leaders)
* [How to deploy Red Hat OpenShift](/en/technologies/cloud-computing/openshift/deploy-red-hat-openshift)
* [Cost management for Kubernetes on Red Hat OpenShift](/en/technologies/cloud-computing/openshift/cost-management)
* [What is enterprise Kubernetes?](/en/topics/containers/what-is-enterprise-kubernetes)
* [What makes Red Hat OpenShift the right choice for IT operations?](/en/technologies/cloud-computing/openshift/it-operations)
* [What makes Red Hat OpenShift the right choice for SAP?](/en/technologies/cloud-computing/openshift/sap)
* [Kubernetes-native Java development with Quarkus](/en/technologies/cloud-computing/openshift/quarkus)
* [What is Kubernetes role-based access control (RBAC)](/en/topics/containers/what-kubernetes-role-based-access-control-rbac)
* [What is containerization?](/en/topics/cloud-native-apps/what-is-containerization)
* [What was CoreOS and CoreOS container Linux](/en/technologies/cloud-computing/openshift/what-was-coreos)
* [What is service-oriented architecture?](/en/topics/cloud-native-apps/what-is-service-oriented-architecture)
* [What is the Kubernetes API?](/en/topics/containers/what-is-the-kubernetes-api)
* [What is Kubernetes cluster management?](/en/topics/containers/what-is-kubernetes-cluster-management)
* [What is a Kubernetes deployment?](/en/topics/containers/what-is-kubernetes-deployment)
* [Why choose the Red Hat build of Quarkus?](/en/topics/cloud-native-apps/why-choose-red-hat-quarkus)
* [Introduction to Kubernetes architecture](/en/topics/containers/kubernetes-architecture)
* [Introduction to Kubernetes patterns](/en/topics/cloud-native-apps/introduction-to-kubernetes-patterns)
* [What is a Kubernetes cluster?](/en/topics/containers/what-is-a-kubernetes-cluster)
* [What is Quarkus?](/en/topics/cloud-native-apps/what-is-quarkus)
* [What is Jaeger?](/en/topics/microservices/what-is-jaeger)
* [What is etcd?](/en/topics/containers/what-is-etcd)
* [What is container-native virtualization?](/en/topics/containers/what-is-container-native-virtualization)
* [What is Clair?](/en/topics/containers/what-is-clair)
* [What is Knative?](/en/topics/microservices/what-is-knative)
* [Why choose Red Hat for microservices?](/en/topics/microservices/why-choose-red-hat-microservices)
* [Why choose Red Hat for containers?](/en/topics/containers/why-choose-red-hat-containers)
* [What is Docker?](/en/topics/containers/what-is-docker)
* [What is a Kubernetes pod?](/en/topics/containers/what-is-kubernetes-pod)
[More about this topic](/en/topics/containers "More about this topic")