Kubernetes Cheat Sheet| Mirantis (2023)

Often you know what you want to do, you just can't remember the vocabulary or syntax for how to do it. This Kubernetes cheat sheet is designed to help solve that problem. Kubernetes provides a way to orchestrate containers to provide a robust, cloud native environment. The architecture looks something like this: Kubernetes Cheat Sheet| Mirantis (1)

Kubernetes Terms

Terms with which you should be familiar:

  • Cluster - Group of physical or virtual servers wherein Kubernetes is installed
  • Node (Master) - Physical or virtual server that controls the Kubernetes cluster
  • Node (Worker) - Physical or virtual servers where workloads run in a given container technology
  • Pods - Group of containers and volumes which share the same network namespace
  • Labels - User defined Key:Value pair associated to Pods
  • Master - Control plane components which provide access point for admins to manage cluster workloads
  • Service - An abstraction which serves as a proxy for a group of Pods performing a “service”

List of Kubernetes objects

Kubernetes enables you to control and orchestrate various types of objects, either by their full name or their "shortname". These objects include: Workloads

  • Container
  • CronJob / cronjobs / cj
  • DaemonSet / daemonsets / ds
  • Deployment / deployments / deploy
  • Job / jobs
  • Pod / pods / po
  • ReplicaSet / replicasets / rs
  • ReplicationController / replicationcontrollers / rc
  • StatefulSet / statefulsets / sts


  • Endpoints / endpoints / ep
  • EndpointSlice / endpointslices
  • Ingress / ingresses / ing
  • IngressClass / ingressclasses
  • Service / services / svc

Config & Storage

  • ConfigMap / configmaps / cm
  • CSIDriver / csidrivers
  • CSINode / csinodes
  • Secret / secrets
  • PersistentVolumeClaim / persistentvolumeclaims / pvc
  • StorageClass / storageclasses / sc
  • CSIStorageCapacity
  • Volume
  • VolumeAttachment / volumeattachments


  • APIService / apiservices
  • Binding / bindings
  • CertificateSigningRequest / certificatesigningrequests / csr
  • ClusterRole / clusterroles
  • ClusterRoleBinding / clusterrolebindings
  • ComponentStatus / componentstatuses/cs
  • FlowSchema / flowschemas
  • Lease / leases
  • LocalSubjectAccessReview / localsubjectaccessreviews
  • Namespace / namespaces/ns
  • NetworkPolicy / networkpolicies / netpol
  • Node / nodes / no
  • PersistentVolume / persistentvolumes / pv
  • PriorityLevelConfiguration / prioritylevelconfigurations
  • ResourceQuota / resourcequotas / quota
  • Role / roles
  • RoleBinding / rolebindings
  • RuntimeClass / runtimeclasses
  • SelfSubjectAccessReview / selfsubjectaccessreviews
  • SelfSubjectRulesReview / selfsubjectrulesreviews
  • ServiceAccount / serviceaccounts / sa
  • StorageVersion
  • SubjectAccessReview / subjectaccessreviews
  • TokenRequest
  • TokenReview / tokenreviews


  • ControllerRevision / controllerrevisions
  • CustomResourceDefinition / customresourcedefinitions / crd,crds
  • Event / events / ev
  • LimitRange / limitranges / limits
  • HorizontalPodAutoscaler / horizontalpodautoscalers / hpa
  • MutatingWebhookConfiguration / mutatingwebhookconfigurations
  • ValidatingWebhookConfiguration / validatingwebhookconfigurations
  • PodTemplate / podtemplates
  • PodDisruptionBudget / poddisruptionbudgets / pdb
  • PriorityClass / priorityclasses / pc
  • PodSecurityPolicy / podsecuritypolicies / psp

In general, any of these commands will work with any of these objects. So rather than:

kubectl get pods

You can use:

kubectl get deployments

Now let's look at getting started.

Get Started

Setting up a Kubernetes environment is straightforward.

Setup Kubernetes with k0s

There are many ways to create a Kubernetes cluster; in this case we are assuming you are using k0s with a single-node configuration. The minimum requirements for this install are:

(Video) Kubernetes Cheat Sheet

  • 1 vCPU (2 vCPU recommended)
  • 1 GB of RAM (2 GB recommended)
  • 1.7 GB of free disk space

To actually perform the installation, perform these steps on a Linux host:

sudo curl -sSLf k0s.sh | sudo shsudo k0s install controllersudo systemctl start k0scontrollersudo systemctl enable k0scontrollermkdir ~/Documentssudo cp /var/lib/k0s/pki/admin.conf ~/Documents/kubeconfig.cfgsudo chown $USER ~/Documents/kubeconfig.cfgexport set KUBECONFIG=~/Documents/kubeconfig.cfg

For more information on installing k0s, including making your clusters available from other machines, see this guide to getting started with k0s.

Install kubectl

You can get kubectl, the standard Kubernetes client, in multiple ways.

Use the k0s kubectl instance

The k0s install comes with its own installation of kubectl, so no installation is required, You would simply add "k0s" to the head of each command, as in:

k0s kubectl get nodes

Install kubectl manually

Installing kubectl on Linux is a simple matter of downloading the binary and adding it to your path:

curl -LO "https://dl.k8s.io/release/$(curl -L -s >https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

For more information on installing kubectl or for instructions for other operating systems, see the kubectl documentation.

Install Lens Kubernetes IDE

The easiest way to get access to kubectl is to install Lens, which includes kubectl. It also, however, provides alternative ways to accomplish most of these tasks without actually using kubectl. You can download and install Lens here, then use the kubectl tool from the terminal.[youtubevideo url="https://youtu.be/cSfrjKnjPEY"]Description: Showcasing how you can access the terminal via Lens IDE

Managing Kubernetes resources

Now that you have your software, we can look at actual tasks.

Start a single instance of a pod

kubectl run mywebserver --image=nginx

Create a resource from the command line:

kubectl create deployment myotherwebserver --image=nginx

Accessing the terminal via the Lens IDE and creating a resource via terminal:

[youtubevideo url="https://youtu.be/zitzZfJ8fhI"]Create resource(s) such as pods, services or daemonsets from a YAML definition file:

kubectl create -f ./my-manifest.yaml

Note that the file itself has a format such as:

---apiVersion: v1kind: Podmetadata:name: rss-sitelabels:app: webspec:containers:- name: front-endimage: nginxports:- containerPort: 80- name: rss-readerimage: nickchase/rss-php-nginx:v1ports:- containerPort: 88

For more information on creating YAML documents, see this Introduction to YAML.

(Video) Kubernetes Cheat Sheet for DevOps

Create or apply changes to a resource

kubectl apply -f ./my-manifest.yaml

Leveraging Lens IDE, Clicking into a pod and making configuration changes to a pod:

[youtubevideo url="https://youtu.be/CTIiPQXQ2dc"]

Delete a resource via Lens

kubectl delete -f ./my-manifest.yaml

Leveraging Lens IDE, viewing a pod and deleting the pod via Lens

[youtubevideo url="https://youtu.be/hg5NORTE6pE"]

Scale a resource

kubectl scale --replicas=3 deployment.apps/myotherwebserver


kubectl scale --replicas=3 -f my-manifest.yaml

Viewing a dployment and leveraging Kubernetes and the Lens IDE UI to scale that deployment:

[youtubevideo url="https://youtu.be/LL4-UeZYbaE"]

Connect to a running container

kubectl attach mywebserver -c mynginx -i

Accessing Lens IDE terminal to connect to a running container:

[youtubevideo url="https://youtu.be/lbBnLqOadRQ"]

Run a command in a single container pod

kubectl exec mywebserver -- /home/user/myscript.sh

Delete a resource

kubectl delete pod/mywebserver


kubectl delete -f ./my-manifest.yaml

Accessing a pod via Lens IDE and deleting the pod via the User Interface:

[youtubevideo url="https://youtu.be/hg5NORTE6pE"]

Viewing resources

Once you have all of these objects, you'll need a way to see what's going on.

(Video) Kubernetes: useful commands

View the cluster and client configuration

kubectl config view

Accessing terminal via Lens IDE to view the config:

[youtubevideo url="https://youtu.be/3-ypRnsx_nk"]

List all resources in the default namespace

kubectl get services

Filtering resources through namespaces via Lens IDE

[youtubevideo url="https://youtu.be/BY3pnJhmmY8"]

List all resources in a specific namespace

kubectl get pods -n my-app

Filtering resources through namespaces via Lens IDE

[youtubevideo url="https://youtu.be/73URu4SK2fs"]

List all resources in all namespaces in wide format

kubectl get pods -o wide --all-namespaces

Opening Lens IDE terminal to list all resources in all namespaces in wide format:

[youtubevideo url="https://youtu.be/Af4IS7y5F9Y"]

List all resources in json (or yaml) format

kubectl get pods -o json

Opening terminal via lens IDE and viewing all resources in JSON format:

[youtubevideo url="https://youtu.be/IxmhJ51kGco"]

Describe resource details

kubectl describe podskubectl describe pod mywebserver

Opening terminal via Lens IDE and running a command to describe pods within your cluster

[youtubevideo url="https://youtu.be/qc9Ngq2eGrA"]

Get documentation for a resource

kubectl explain podskubectl explain pod mywebserver

Opening terminal via Lens IDE and reviewing documentation for a specific resource, ex. Pods:

(Video) Kubernetes Commands Cheat Sheet - All useful commands.

[youtubevideo url="https://youtu.be/wAtSZvXWxj8"]

List of resources sorted by name

kubectl get services --sort-by=.metadata.name

Opening terminal via Lens IDE and listing resources by name

[youtubevideo url="https://youtu.be/VqgbudhR7aw"]

List resources sorted by restart count

kubectl get pods --sort-by='.status.containerStatuses[0].restartCount'

Opening terminal viaLens IDE to view resources sorted by “Restart count”

[youtubevideo url="https://youtu.be/3lHQNBoqOL8"]

Rolling update pods for resource

kubectl rolling-update echoserver -f my-manifest.yaml


Kubernetes networking is an entire topic on its own, but here are a few commands that come in handy when building and accessing applications.

Types of services

First, it's important to understand (and remember) the different types of services, because each has a different set of behaviors.

  • ClusterIP is the default ServiceType, ClusterIP services have a cluster-internal IP address, so they can only be reached by other cluster components.
  • NodePort enables you to create a service that's available from outside the cluster by exposing the service on the same port for every node. For example, the same service might be available on host1.example.com:32768, host2.example.com:32768, and host3.example.com:32768.
  • LoadBalancer requires coordination with your cloud provider's load balancer, which automatically routes requests to the service. For this reason, not all distributions of Kubernetes will support LoadBalancer services.
  • ExternalName is the most complex ServiceType, coordinating the service with your DNS server.

Port vs targetport

One aspect of Kubernetes networking that frequently gets confusing is the notion of port versus targetPort. Here's the difference:

  • port: the port receiving the request
  • targetPort: the container port receiving the request

Think of the request like an arrow flying into a container. Here are come commands that reference ports (and targetPorts):

Port forwarding from port 5000 to targetPort 6000

kubectl port-forward mywebserver 5000:6000kubectl port-forward svc/my-service 5000:6000kubectl port-forward deploy/my-deployment 5000:6000

Create a service that directs requests on port 80 to container port 8000

kubectl expose deployment nginx --port=80 --target-port=8000 --type=LoadBalancer


Finally, you need to know what's going on inside your application.

Dump resource logs to stdout

kubectl logs myotherwebserver-8458cdb575-s6cp4

Stream logs for a specific container within a pod

kubectl logs -f mywebserver -c mynginx

Leveraging Lens UI to view pod logs without writing any command line:

[youtubevideo url="https://youtu.be/1P1ezLf88uQ"]


What is Kubernetes cheat sheet? ›

Kubernetes is an open-source platform used to automate deployment and to scale containers across clusters of hosts providing container-centric infrastructure. It is a container orchestrator. It can run a Linux container. Become a master of DevOps by taking up this online instructor-led DevOps Training in London!

How do I resolve Imagepullbackoff in Kubernetes? ›

To resolve it, double check the pod specification and ensure that the repository and image are specified correctly. If this still doesn't work, there may be a network issue preventing access to the container registry. Look in the describe pod text file to obtain the hostname of the Kubernetes node.

How do you get all the pods in Kubernetes? ›

List all Container images in all namespaces
  1. Fetch all Pods in all namespaces using kubectl get pods --all-namespaces.
  2. Format the output to include only the list of Container image names using -o jsonpath={. items[*]. spec. ...
  3. Format the output using standard tools: tr , sort , uniq. Use tr to replace spaces with newlines.

What is the command to list all Kubernetes objects? ›

The most basic command for viewing Kubernetes objects via kubectl is get . If you run kubectl get <resource-name> you will get a listing of all resources in the current namespace. If you want to get a specific resource, you can use kubectl get <resource-name> <object-name> .

What is Kubernetes vs Docker? ›

While Docker is a container runtime, Kubernetes is a platform for running and managing containers from many container runtimes. Kubernetes supports numerous container runtimes including Docker, containerd, CRI-O, and any implementation of the Kubernetes CRI (Container Runtime Interface).

What are Kubernetes commands? ›

Kubectl controls the Kubernetes Cluster. It is one of the key components of Kubernetes which runs on the workstation on any machine when the setup is done. It has the capability to manage the nodes in the cluster. Kubectl commands are used to interact and manage Kubernetes objects and the cluster.

Is Kubelet a pod? ›

The kubelet works in terms of a PodSpec. A PodSpec is a YAML or JSON object that describes a pod. The kubelet takes a set of PodSpecs that are provided through various mechanisms (primarily through the apiserver) and ensures that the containers described in those PodSpecs are running and healthy.

What does ImagePullBackOff mean? ›

So what exactly does ImagePullBackOff mean? The status ImagePullBackOff means that a Pod couldn't start, because Kubernetes couldn't pull a container image. The 'BackOff' part means that Kubernetes will keep trying to pull the image, with an increasing delay ('back-off').

How do I find out what caused CrashLoopBackOff? ›

Check the syslog and other container logs to see if this was caused by any of the issues we mentioned as causes of CrashLoopBackoff (e.g., locked or missing files). If not, then the problem could be with one of the third-party services. To verify this, you'll need to use a debugging container.

How many pods can run on a node? ›

Overview. By default, GKE allows up to 110 Pods per node on Standard clusters, however Standard clusters can be configured to allow up to 256 Pods per node. Autopilot clusters have a maximum of 32 Pods per node.

How many containers can you run in a pod? ›

Remember that every container in a pod runs on the same node, and you can't independently stop or restart containers; usual best practice is to run one container in a pod, with additional containers only for things like an Istio network-proxy sidecar.

Can a pod run on multiple nodes? ›

The key thing about pods is that when a pod does contain multiple containers, all of them are always run on a single worker node—it never spans multiple worker nodes, as shown in figure 3.1.

How do you list all containers in a pod? ›

To access a container in a pod that includes multiple containers:
  1. Run the following command using the pod name of the container that you want to access: oc describe pods pod_name. ...
  2. To access one of the containers in the pod, enter the following command: oc exec -it pod_name -c container_name bash.

What does kubectl stand for? ›

Kubectl stands for “Kubernetes Command-line interface”. It is a command-line tool for the Kubernetes platform to perform API calls. Kubectl is the main interface that allows users to create (and manage) individual objects or groups of objects inside a Kubernetes cluster.

How do I know what size pod in Kubernetes? ›

If you want to check pods cpu/memory usage without installing any third party tool then you can get memory and cpu usage of pod from cgroup.
  1. Go to pod's exec mode kubectl exec -it pod_name -- /bin/bash.
  2. Run cat /sys/fs/cgroup/cpu/cpuacct.usage for cpu usage.
5 Feb 2019

Is Docker still relevant 2022? ›

Docker is still as popular as any container runtime in enterprise IT right now, but not for much longer. Kubernetes' Docker deprecation announcement has put Docker on a defined path towards irrelevancy in the enterprise space. It's a big changing of the guard, but don't view this as the end of Docker as a whole.

Should I learn Docker or Kubernetes first? ›

When it comes to learning Docker or Kubernetes first and you ask yourself do I need to learn Docker before Kubernetes? The answer is that you should instead learn about containerization engines.

Can Kubernetes run without Docker? ›

You can decide to use Kubernetes without Docker, or even Docker without Kubernetes for that matter (but we advise you to use it for different purposes than running containers). Still, even though Kubernetes is a rather extensive tool, you will have to find a good container runtime for it – one that has implemented CRI.

How do you restart a pod? ›

To restart pods using Kubectl, you have to first run the minikube cluster by using the following appended command in the terminal.
  1. $ minikube start.
  2. $ kubectl get pods.
  3. $ touch deployment.YAML.
  4. $ kubectl create –f deployment.yaml.
  5. $ kubectl get pods.
  6. $ kubectl rollout restart deployment <deployment name>

How do I check pod logs? ›

Checking the logs of a running pod

All that you need to do to do that is to run the following command: kubectl logs nginx-7d8b49557c-c2lx9.

What is helm in Kubernetes? ›

Helm is a package manager for Kubernetes that makes it easy to take applications and services that are either highly repeatable or used in multiple scenarios and deploy them to a typical K8s cluster.

Is Kubernetes pod a VM? ›

Pods always run on Nodes. A Node is a worker machine in Kubernetes and may be a VM or a physical machine, depending on the cluster. Each Node runs Pods and is managed by the Master. On a Node you can have multiple pods.

How many master nodes does Kubernetes? ›

👍 Efficient resource usage

This includes, for example, the master nodes — a Kubernetes cluster typically has 3 master nodes, and if you have only a single cluster, you need only 3 master nodes in total (compared to 30 master nodes if you have 10 Kubernetes clusters).

What is difference between kubectl and Kubelet? ›

kubectl is the command-line interface (CLI) tool for working with a Kubernetes cluster. Kubelet is the technology that applies, creates, updates, and destroys containers on a Kubernetes node.

What does ErrImagePull mean? ›

If kubectl get pods shows that your pod status is ImagePullBackOff or ErrImagePull, this means that the pod could not run because it could not pull the image.

Where does k8s pull images from? ›

During the deployment of an application to a Kubernetes cluster, you'll typically want one or more images to be pulled from a Docker registry. In the application's manifest file you specify the images to pull, the registry to pull them from, and the credentials to use when pulling the images.

What happens when a pod fails? ›

If a Pod is scheduled to a node that then fails, the Pod is deleted; likewise, a Pod won't survive an eviction due to a lack of resources or Node maintenance. Kubernetes uses a higher-level abstraction, called a controller, that handles the work of managing the relatively disposable Pod instances.

How do I check if a Kubernetes pod is failing? ›

You can see them by simply putting --previous flag along with your kubectl logs ... cmd.

How do I debug a failed container? ›

Debugging a container that won't start
  1. Find out if the Docker daemon is running. Since I am running on Ubuntu, I built this VM to use Upstart as the boot time start mechanism. ...
  2. Start your container, see if it's running. ...
  3. Check the container log. ...
  4. Commit the container changes to a new image.

What is the smallest Kubernetes cluster? ›

A Kubernetes cluster consists of the control plane and the worker nodes. To shrink this footprint, some projects have tried to strip nonessential elements out of Kubernetes to create a slimmed-down version.

How many Kubernetes masters do I need? ›

However, in case of Kubernetes HA environment, these important components are replicated on multiple masters(usually three masters) and if any of the masters fail, the other masters keep the cluster up and running.

Is pod a VM? ›

A vSphere Pod is a VM with a small footprint that runs one or more Linux containers. Each vSphere Pod is sized precisely for the workload that it accommodates and has explicit resource reservations for that workload. It allocates the exact amount of storage, memory, and CPU resources required for the workload to run.

Can we run two containers in a pod on the same port? ›

A Pod is is the smallest deployable unit that can be deployed and managed by Kubernetes. In other words, if you need to run a single container in Kubernetes, then you need to create a Pod for that container. At the same time, a Pod can contain more than one container, if these containers are relatively tightly coupled.

Can we create pod without container? ›

Workloads use metadata resources, which are the objects used to configure the behavior of other resources within the cluster. Workloads will eventually run a container, but to run a container, you will need to run a Pod. It is possible to create a Pod as a standalone object.

What is the difference between a container and a pod? ›

As the official documentation puts it: “A pod (as in a pod of whales or pea pod) is a group of one or more containers, with shared storage/network resources, and a specification for how to run the containers.” So, in the simplest terms possible, a pod is the mechanism for how a container actually gets turned “on” in ...

What is the difference between a pod and a node? ›

Pods are simply the smallest unit of execution in Kubernetes, consisting of one or more containers, each with one or more application and its binaries. Nodes are the physical servers or VMs that comprise a Kubernetes Cluster.

How do pods communicate with each other? ›

A Pod can communicate with another Pod by directly addressing its IP address, but the recommended way is to use Services. A Service is a set of Pods, which can be reached by a single, fixed DNS name or IP address. In reality, most applications on Kubernetes use Services as a way to communicate with each other.

What is the difference between master and worker nodes? ›

Worker nodes are generally more powerful than master nodes because they have to run hundreds of clusters on them. However, master nodes hold more significance because they manage the distribution of workload and the state of the cluster.

How do I list all clusters in Kubernetes? ›

Kubectl get pods

This command lists pods on the Kubernetes cluster. This command works for all types of Kubernetes resources: pods, services, deployments, cronjobs, events, ingresses, etc. We can also add parameters: --all-namespaces : List all resources of all namespaces.

How do I know which node pod is running? ›

To find the cluster IP address of a Kubernetes pod, use the kubectl get pod command on your local machine, with the option -o wide . This option will list more information, including the node the pod resides on, and the pod's cluster IP. The IP column will contain the internal cluster IP address for each pod.

How do I get container logs in Kubernetes? ›

You can see the logs of a particular container by running the command kubectl logs <container name> . Here's an example for Nginx logs generated in a container. If you want to access logs of a crashed instance, you can use –previous . This method works for clusters with a small number of containers and instances.

Why is it called k8? ›

The name Kubernetes originates from Greek, meaning helmsman or pilot. K8s as an abbreviation results from counting the eight letters between the "K" and the "s". Google open-sourced the Kubernetes project in 2014.

Is Kubernetes a PaaS? ›

It's true that most conventional PaaS platforms have disappeared. Yet if you look at Kubernetes, the massively popular open-source orchestrator, PaaS is alive and well. In many ways, Kubernetes is basically just PaaS by another name (and with less vendor lock-in).

What is POD in Kubernetes? ›

A pod is the smallest execution unit in Kubernetes. A pod encapsulates one or more applications. Pods are ephemeral by nature, if a pod (or the node it executes on) fails, Kubernetes can automatically create a new replica of that pod to continue operations.

Why is Kubernetes killing my pod? ›

For example, Kubernetes may run 10 containers with a memory request value of 1 GB on a node with 10 GB memory. However, if these containers have a memory limit of 1.5 GB, some of the pods may use more than the minimum memory, and then the node will run out of memory and need to kill some of the pods.

What does 1 CPU mean in Kubernetes? ›

One CPU, in Kubernetes, is equivalent to: 1 AWS vCPU. 1 GCP Core. 1 Azure vCore. 1 Hyperthread on a bare-metal Intel processor with Hyperthreading.

How much memory a pod is using? ›

Kubernetes uses memory requests to determine on which node to schedule the pod. For example, on a node with 8 GB free RAM, Kubernetes will schedule 10 pods with 800 MB for memory requests, five pods with 1600 MB for requests, or one pod with 8 GB for request, etc.

What is Kubernetes overview? ›

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

What is Kubernetes PDF? ›

With that out of the way, Kubernetes is an open source container orchestration system that is portable, extensible, and not only allows you to deploy those containers to a scalable cluster, but it can be used (with the addition of other tools) to completely automate the orchestration of your containerized applications.

What are different kinds in Kubernetes? ›

There are four types of Kubernetes services — ClusterIP , NodePort , LoadBalancer and ExternalName .

How easy is Kubernetes? ›

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.

What is better than Kubernetes? ›

The primary options you can choose instead of Kubernetes are: Container as a Service (CaaS)—services like AWS Fargate and Azure Container Instances, which allow you to manage containers at scale without the complex orchestration capabilities provided by Kubernetes.

Why is Kubernetes so popular? ›

Among the reasons why Kubernetes has been so widely adopted are flexibility and lack of fragmentation. Kubernetes may not be perfect, but there's no denying that a lot of people love it. Indeed, Kubernetes provides orchestration for more than three-quarters of containerized applications today.

What is Kubernetes in simple words? ›

Kubernetes (also known as k8s or “kube”) is an open source container orchestration platform that automates many of the manual processes involved in deploying, managing, and scaling containerized applications.

Is Kubernetes using Docker? ›

The Kubernetes server runs locally within your Docker instance, is not configurable, and is a single-node cluster. It runs within a Docker container on your local system, and is only for local testing.

How many containers can you run in a pod? ›

Remember that every container in a pod runs on the same node, and you can't independently stop or restart containers; usual best practice is to run one container in a pod, with additional containers only for things like an Istio network-proxy sidecar.

Are nodes and pods the same? ›

Pods are simply the smallest unit of execution in Kubernetes, consisting of one or more containers, each with one or more application and its binaries. Nodes are the physical servers or VMs that comprise a Kubernetes Cluster.

What are the two types of Kubernetes nodes? ›

There are two types of nodes:
  • The Kubernetes Master node—runs the Kubernetes control plane which controls the entire cluster. A cluster must have at least one master node; there may be two or more for redundancy. ...
  • Worker nodes—these are nodes on which you can run containerized workloads.
15 Aug 2022

How many Kubernetes objects are there? ›

The Kubernetes Platform contains control over the resources related to Storage and Compute. These resources are regarded as Objects, and it contains 8 Key objects.

What are the k8 objects? ›

Kubernetes objects are entities that are used to represent the state of the cluster. An object is a “record of intent” – once created, the cluster does its best to ensure it exists as defined. This is known as the cluster's “desired state.”


1. Kubernetes Storage Cheat Sheet for VM Administrators - Manu Batra & Jing Xu, Google
(CNCF [Cloud Native Computing Foundation])
2. Kubernetes Storage Cheat Sheet for VM Admins (KubeCon 2019, San Diego)
(Google Cloud Tech)
3. Hands-On Kubernetes - Kubectl Cheatsheet
(Build with latest)
4. Kubernetes Cheatsheet
(Thinknyx Technologies)
5. Kubernetes Basic Commands -How to hack kubernetes with 60 or more commands | Cheat Sheets k8s (9)
6. The VM admin's cheat sheet to containers and Kubernetes - David Stevens
Top Articles
Latest Posts
Article information

Author: Jamar Nader

Last Updated: 08/02/2023

Views: 5861

Rating: 4.4 / 5 (75 voted)

Reviews: 90% of readers found this page helpful

Author information

Name: Jamar Nader

Birthday: 1995-02-28

Address: Apt. 536 6162 Reichel Greens, Port Zackaryside, CT 22682-9804

Phone: +9958384818317

Job: IT Representative

Hobby: Scrapbooking, Hiking, Hunting, Kite flying, Blacksmithing, Video gaming, Foraging

Introduction: My name is Jamar Nader, I am a fine, shiny, colorful, bright, nice, perfect, curious person who loves writing and wants to share my knowledge and understanding with you.