Kubernetes Resources

In Kubernetes, resources are like building blocks used to create and manage your cluster. Each resource is an object with metadata (such as names and labels) and a desired state that defines its behavior. All objects in Kubernetes are managed by an API and stored in the etcd database.

For example, a Pod resource defines how to run a group of containers, while a Service resource manages network access to those containers. Everything you can manage with kubectl or the Kubernetes API - like workloads, storage, or configuration - is a resource, making them essential for defining and controlling your cluster's behavior.

The following command lists all the resources that can be managed in a Kubernetes cluster, including their names, short names, API versions, and whether they are namespaced:

kubectl api-resources

The most relevant resources for the KCNA exam are marked red

Resource Overview

You can link to the table here

Core Resources

Pod
Service
ConfigMap
Secret
Namespace
PersistentVolume
PersistentVolumeClaim
ServiceAccount
Binding
ComponentStatus
Endpoints
Event
LimitRange
PodTemplate
ReplicationController
ResourceQuota

Workloads

Deployment
ReplicaSet
DaemonSet
StatefulSet
CronJob
Job
ControllerRevision

Networking

Ingress
NetworkPolicy
IngressClass

RBAC (Role-Based Access Control)

Role
RoleBinding
ClusterRole
ClusterRoleBinding

Storage

StorageClass
CSIDriver
CSINode
CSIStorageCapacity
VolumeAttachment

Admission Control

MutatingWebhookConfiguration
ValidatingWebhookConfiguration

API Extensions

CustomResourceDefinition
APIService

Authentication and Authorization

TokenReview
LocalSubjectAccessReview
SelfSubjectAccessReview
SelfSubjectRulesReview
SubjectAccessReview

Autoscaling

HorizontalPodAutoscaler

Certificates

CertificateSigningRequest

Coordination

Lease

Discovery

EndpointSlice

Events

Event

Flow Control

FlowSchema
PriorityLevelConfiguration

Node Management

RuntimeClass

Policies

PodDisruptionBudget
PodSecurityPolicy

Scheduling

PriorityClass

Resource Description

~~POD~~

~~Useful Links:~~

~~Kubernetes Official Documentation~~

~~Viewing Pods and Nodes~~

~~Detailed Description:~~

A Pod is the smallest deployable unit in Kubernetes and serves as the basic building block for running applications in the cluster. Each Pod encapsulates one or more containers, which share the same resources such as storage, networking, and compute. Containers within a Pod are tightly coupled, meaning they always run together on the same node and share the same network namespace, allowing them to communicate with each other using localhost.

Typically, a Pod has a single container, but it can host sidecar containers that assist the main application container with additional tasks like logging, monitoring, or proxying requests. Pods are ephemeral by nature, designed to be replaceable and scaled according to workload demands through higher-level Kubernetes abstractions like Deployments or StatefulSets.

~~Key characteristics of Pods include:~~

~~Shared Networking:~~ ~~All containers in a Pod share the same IP address and port space.~~

~~Shared Storage:~~ ~~Volumes attached to a Pod are shared among all its containers.~~

~~Lifecycle Management:~~ ~~Pods are managed by controllers like Deployments, ReplicaSets, and DaemonSets to ensure desired state is maintained.~~

Service

Useful Links:

Detailed Description:

In Kubernetes, a Service is a way to expose an application running inside a set of Pods as a network service. It provides a stable IP address and DNS name, allowing access either from outside the cluster or from other Pods within the cluster. A Service serves as an abstraction layer, connecting clients to the appropriate Pods, ensuring that the actual Pods behind the Service can change without disrupting access.

There are different types of Services in Kubernetes, including:

ClusterIP: The default service type that assigns an internal IP, reachable only within the cluster. It allows communication between Pods inside the cluster.
NodePort: Exposes the service on a static port across all nodes in the cluster, allowing external traffic to access the service.
LoadBalancer: In cloud environments, this service type provisions an external load balancer to distribute traffic to multiple Pods.
ExternalName: Maps a service to an external DNS name, allowing Kubernetes services to refer to external resources.
Headless Service: A type of ClusterIP service with no assigned IP. It allows direct access to Pods without a proxy.

Endpoints are associated with a Service and represent the IP addresses of the Pods that match the Service's selector. When a Service is created, Kubernetes automatically creates Endpoints for it, enabling traffic forwarding to the correct Pods.