K8s Structure and Visualization

So we’re back to understanding K8s now that we’ve taken a round of understanding the undelining linux basics.

Visualisation

A data center looks like this

Datacenter
|--- Rack
|    |--- Server 1
|    |--- Server 2
|    |--- Server 3
|--- Rack
     |--- Server 4
     |--- Server 5
     |--- Server 6
  • Different servers on diff racks can be part of same Kubernetes cluster.
  • When multiple servers have cost check, certain requirements, they are as associated of k8s, they are then part of k8s cluster. -

K8s terms

  • kubelet
    • small local agent/process
    • Exists on every worker node / control plane node.
    • Make sure containers/pods runs correctly on that m/c.
  • Tasks of kubelet :
    • talk to api server, receive pod assignments, start/stop containers, report node health, report pod status, mounts volume, handle probes.
  • kubectl
    • Pronounced “kyoobe-cuttle” or “kyoobe-control”.
    • Exists on developer laptop / admin m/c / control server.
    • It communicates of kube-apiserver.
  • kube-proxy
    • Kubernetes n/w proxy.
    • exists on every worker node (as daemon/fbg process).
    • It handles k8s n/wing rules inside cluster Eg: Service virtual IPs, load balancing, traffic forwarding, ip tables / ipvs rules.
  • kubeadm
    • K8s admin / bootstrap tool
    • exists on control plane m/c.
    • worker setup m/c
    • used during cluster creation for creating control plane “kubeadm init” & join worker pods “kubeadm join”, etc…
    • Not part of ras running cluster logic instead part of cluster installation / setup tool.
  • kube-apiserver
    • main entry point for k8s cluster. Everything talks to this. Acts like central management api. - Exists on control plane server.
    • Talks to kubectl, kubelet, scheduler, controller-manager, etcd.
  • kube-scheduler
    • chooses which node runs pods. (decision engine)
    • Exists on control plane server. Chooses where worker node try maintains desired state pods.
    • talks to kube-apiserver, worker nodes indirectly.
  • kube-controller-manager
    • Exists on control plane server.
    • Maintains desired state.
    • Talks to :- kube-apiserver, etcd … indirectly.
    • Runs reconciliation loops (loops inside k8s that continuously check desired state vs actual state).
    • eg: desired replica = 3, actual replica = 2. Then create another pod.
  • etcd (etc distributed) (et-see-di)
    • etcd directory / distributed key value db (like redis)
    • store cluster state db.
    • most critical k8s db (source of truth).
    • Exists on control plane servers.
    • Stores :- pods, deployments, services, [as key-value pairs] nodes, secrets, cluster desired state.
    • distributed
      • it is called distributed bcoz multiple etcd servers can work together.
      • eg if multiple control planes with diff etcd, they communicate via a “Raft consensus” algorithm which stores a copy of the cluster state, thus preserving data even if one etcd beads down. (cluster state is not the same as control plane).
  • containerd
    • container runtime (actually runs containers)
    • Exists on worker node.
    • Talks to kubelet through CRI.
  • CoreDNS (Core Domain Name Sys)
    • K8s - Internal cluster dns.
    • lets pods communicate using names. eg: api-service.default.svc.cluster.local. - usually runs as pods on worker nodes.
  • Container Network Interface (CNI)
    • Provide pod networking.
    • Exists as CNI plugins on worker nodes.
    • eg: Calico, Flannel, Cilium.
  • CRI
    • Container runtime interface.
    • Standard interface btw. kubelet (node agent) & container runtime (containerd).
    • Types of communication being done via here include kubelet asking to pull image, start container, stop container, delete container, get container status, etc..
  • CSI
    • Container storage interface.
    • Standard way k8s interact w/ storage systems.
    • Exists on worker node, control plane (occasionally on worker node, control plane)
  • Pod
    • Small deployable unit holding one or more containers together
    • Runs on worker nodes inside container runtime (containerd)
    • Contains 1 or more containers, shared n/w, shared storage, shared localhost
    • e.g., k8s Pod
    • e.g., pod may contain:
      • nodejs API container
      • sidecar logging container, etc.
  • Deployment
    • An object that is stored in etcd (API resource)
    • It is used to keep a permanent record of the desired state of cluster
      • Deployment controller continuously checks actual state against the desired state stored in deployment object (key-value pair) stored in etcd
    • It is generated by k8s from the deployment.yml file (also called deployment manifest) upon running a command like “kubectl apply -f .yaml”
      • It can also be generated from a json file or directly from terminal like “kubectl create deployment –image=”. In such case kubectl itself creates a deployment object based w/ configuration based on kubectl defaults, k8s, defaults by API server generated metadata.
    • Also handles replicas, rolling updates, self healing, rollout history
  • Replica set
    • replica = copy, set = collection
    • it is an API resource (cluster resource) whose instance is stored within etcd
    • Deployment controller, from developer / cr server sense kube controller manages, creates a replica set.
    • Though replicaset obj can be created from a riperi [replica] <missing text: “set”> manifest like deployment
    • it is generally auto-generated by deployment controller. The trigger for creating a replicaset is the appearance or change of deployment object. If expected no. of replicasets are 3 & these objects are 3 & deployment controller creates the extra one.
    • it manages the no. of pods to be kept up
  • Service
    • Objects that defines a service name that also becomes the DNS name inside the cluster (we can also set a static IP for that service that falls in its cluster’s service IP range & must be unique). It is this DNS name kube proxy will use to get incoming calls to BE from FE & then re-route to actual IPs of each pod that gets generated
    • created by user themselves via kubectl (like deployment obj) using a source manifest & stored in etcd
    • Endpoint Slice Controller, watches service objects & Pods, it also creates endpoint slice objects for the service.

      The objects stored in etcd can be multiple in number (eg: multiple service, deployment, replicaset objects, etc.). They can be multiple depending on diff manifests or based on diff namespaces
      eg: → etcd A | ↳ deployments | ↳ dev | ↳ staging | ↳ prod | ↳ services | ↳ dev | ↳ staging | ↳ prod | ↳ pod | ↳ dev | ↳ staging | ↳ prod → etcd B (same thing)

All the etcd’s of the same cluster will shared this segregation based on namespaces & such. (so that if one etcd goes down, others still have data)

  • Ingress
    • meaning → incoming traffic
    • it routes external HTTP / HTTPS traffic into cluster.
    • created from ingress manifest by the user/developer using kubectl .
    • It is an api cluster resource stored in etcd, it is called ingress object
    • Ingress controller watches the ingress objects. It is deployed along with other pods as one among them like:
    Node A → App pod
           ↳ App pod
           ↳ nginx ingress controller pod
    Node B → App pod
           ↳ App pod
    
    • Based on ingress object config, ingress controller manages the routing. -
  • namespaces:
    • means a boundary that keeps names from colliding
    • it is used for policy checks
      • Eg:
        • Resource Quota: Pod belongs to prod –> check prod quota
        • RBAC :- user accesses prod namespace –> check permissions
    • When we provide namespace to any manifest file, it creates multiple objects from that manifest file for each namespace.
  • stateful set
    • Most k8s workloads / pods are managed by a “Deployment” • But when a pod dies and when “Deployment” recreates the pod, the new pod recreates the pod, the IP & node can have suff name, IP & node. This is called stateless • This is generally used for- FE, API, servers, etc.
    • But some applications care about identity of the pods created & are not interchangable. In such case use “Stateful set”
    • Deployment pods look like api-6f84… etc, & every recreated pod gets a new name. stateful set pods look like postgres-1, postgres-2, etc out fixed names. each pod also gets a predictable pod name. This is very important for databases, distributed systems, cluster membership.
    • this works in association of persistent volume claim (PVC). Each pod gets its own storage which wont get destroyed when the pod gets destroyed. when a pod is recreated it attaches the same PVC as the older pod.
    • Ordered startup
      • In Deployment, “create 10 pods”, k8s may start them in parallel.
      • But stateful set starts in order: postgres-1 → postgres-2 → postgres-3, etc Similarly during shutdown, it stop db’s in reverse order.
      • this is because many distributed dbs require db 1 to start bt db2, b2 db 3, etc.
    • ordered updates
      • Pod deployment generally updates pods in batches. But Stateful set updates pods one after another. this is ordered rollout and generally useful for dbs.
    • stateful set components
      • when we apply “kind: StatefulSet” ; k8s creates a statefulset object stored in etcd. statefulset controller watches it. Statefulset controller then creates pods like postgres-1, postgres-2, etc based on the desired no. of pods mentioned in stateful set object being watched.
  • Daemonset
    • A k8s resource that ensures one copy of a pod runs on every matching node.
    • called daemonset because it is a set of
      • daemon-like pods running on nodes daemon → a background process that run continuously in background.
      • Example: we want to run a log collector on every node
      Node A → log collector
      Node B → log collector
      Node C → log collector
      
      • Deployment can’t guarantee this, it creates N replicas somewhere. (sometimes on one node)
      • But daemonset guarantees 1 pod per node.
      • Working:
        • We apply “kind: Daemonset”
        • kubectl reads the yaml file
        • API server authenticate
        • Daemonset object gets stored in etcd
        • Daemon controller watches daemon
        • By default it creates 1 pod per matching node.

        We cannot tell daemonset how many pods to sunper node. We can only say to run current pod in every node.

        • Eg of usage for :- kubeproxy, log controller, monitoring agents.
  • Job:
    • A k8s resource that tails, does same work
    • used for stuff like pdf generation, db migration
    • When deployment fails there is no further management as to retry or anything else. But when we configure job we can either retry or mark job as failed.
    • Can run parallel jobs
    • Flow:
      • Job obj stored in etcd
      • API server exposes it
      • Job controller watches Job obj
      • Job controller creates pod objects
      • Pod succeeds or fails Pod runs tasks
      • Job task succeeds go fails.
      • Job controller creates new pod if retry enabled, else marks Job as complete
      • Pod remain
  • CronJob:
    • K8s resource that creates job on schedule.
    • Create from CronJob manifest by kubectl & stored in etcd
    • CronJob controller watches CronJob via API server. When it is time, CronJob controller creates a Job obj.
    • Job controller creates job obj & creates a pod, Pod runs.
    • Pod succeed succeeds or fails. Retries if configured.
    • Job complete : Pods still remain
  • Secrets:
    • a K8s resource stored in etcd via terminal command for sake of safety. (bcz yaml file will record the secrets which we do not want)
    • We then reference the secrets obj name in deployment manifest, which will fetch the secrets directly from secrets obj. (eg: password)
  • Config map:
    • To store stuff like hostname, ports numbers, feature flags etc. (Non-sensitive data)
    • A K8s resource stored in etcd from manifest
  • Volume
    • Data storage
    • Specified as part of deployment manifest.
    • The actual data maybe stored within node/VM’s real disk or cloud or NFS (Network File system), but to the container it will look like it is coming from a folder within the container files.
    • Specification example: ```yaml volumes:
      • name: data mountPath: /data ```
    • It is specified as part of pod template in deployment manifest. When deployment controller creates pods each pod gets a volume named ‘data’. Just part of pod specification.
    • When pod is destroyed, the volume directly from container path will also be destroyed. When the directory gets destroyed, the associated actual db ins volume on disk also loses files in it.
    • Cons of volume per pod.
      • It is tied to pod life
      • Every pod will need to have volume specified
  • PV (Persistent volume) (Static Provisioning)
    • cluster level K8s obj stored in etcd created from PV manifest
    • Actual storage is on Node disk/cloud/NFS.
    • This object is created only for creating a… [continues to next page]
    • volume within the cluster for a ahead change in the volume, we use PVC.
    • Flow of creating PV volume in list
      • Fuse you create volume yourself.
      • Then just reference it in pv object. (This method is not used anymore)
  • PVC (Persistent Volume Claim):
    • Dynamic provisioning:
    • obj created from PVC manifest in etcd.
    • A storage controller notices PVC is pending & provisions storage.
    • eg: create EBS disk, GCP persistent disk, etc.
    • It then creates PV obj. & binds it to PVC (EBS, GCP disk, etc).
  • Node: Physical/virtual server.
  • Cluster: Group of physical datacenter servers.
  • Kube-system:
    • Namespace object stored in etcd.
    • created automatically during bootstap of control plane. (Eg: kubeadm init)
    • Part of other predefined yaml manifests
    • of system components : CoreDNS, kube-proxy, networking plugins (cni), etc.
    • Created by Namespace controller. It also creates default, kube system, kube public
    • Kube-node-lease:
    • Purpose: holds K8s internal components.
  • Sidecar:
    • Auxiliary container that runs inside same pod as main application & enhances or supports it.
    • has same network namespace (cannel, localhost shared), same storage volumes. (can be shared)
    • has separate process space (different container), separate lifecycle (can restart independently)
    • used to add functionality to or modifying main application code.
    • Eg:- logging, monitoring, proxying, security, configuration sync.
  • Init Containers:
    • temporary container that runs before main application
    • used to prepare env required by app (eg: wait for db/cache readiness, download config or secrets at runtime (sun DB migrations))
    • Not commonly used for smaller apps, but sahay for prod k8s systems, microservices
    • w/ dependencies, etc.
    • created from Pod yaml manifests.
    • spec -> initContainers -> Turns into pod object.
    • If initcontainers are omitted, pods start directly with containers
    • Developer defines it, K8s creates pod obj, kubelet executes based on pod objs.
  • Helm:
    • means ships steering wheel (k8s logo)
    • package manager for K8s. Bundles K8s yaml manifests into reusable, versioned packages called charts.
    • not a core component of cluster -> It is a cli tool on our m/c or CI/CD pipeline.
    • talks to K8s API server, applies manifests into cluster.
    • Without helm you need to manually manage multiple yaml files, repeated configs across envs, hard to version & reuse
    • Deployments:
      • with helm, everything is packaged, configurable via values, easy install/upgrade/rollback.
    • Helm Chart:
      • Chart
        • package K8s applicationist
        • contains templates values & chart yaml files
      • Template - K8s yaml templates
      • values.yaml - configurable params
      • chart.yaml - metadata (name, version)
    • Structure:
    my-chart/
    |--- chart.yaml
    |--- values.yaml
    |--- templates
          |--> deployment.yaml
          |--> service.yaml
          |--> configmap.yaml
    
    • Working of helm:
      • You install a chart: helm install prometheus prometheus-community/prometheus
      • Helm renders templates: - replaces placeholders in yaml.
        • Eg: image: becomes image: prom/prometheus
      • Helm applies manifests:
        • helm sends final yaml to K8s API server
        • eg: deployment, service, configmap, ingress, etc.
      • K8s stores it in etcd like other normal resources.
    • Key features:
      • Allows install of packages called charts, like prometheus, grafana, nginx, ingress, postgresql.
      • Versioning/rollback supported: “helm rollback my-release 1”
      • Reusability: Same chart works across dev, staging, prod. Just change values.yaml.
      • Upgrade/update cluster resources safely: “helm upgrade my-app /chart”
    • Comparison of helm vs normal kubectl:
      • Without helm: use kubectl apply on every yaml file. No release history, nothing.
      • With helm: use helm install my-app name.
      • eg. internally it will pull templates yaml, values.yaml, generate less yaml. internally apply them (like kubectl), store release history.
  • Operator:
    • K8s extension that automates full lifecycle of complex applications using CRD (Custom Resource Definitions) & Custom Controllers (reconciliation logic).
    • It acts like a system administrator (“operator”)
    • In normal K8s, it can manage stateless apps (deployments), basic scaling (HPA), simple configs.
    • But it struggles with stateful, complex systems like Postgres databases, kafka cluster, elasticsearch, etc.
  • A cluster is multiple pods spun within same K8s cluster related to same application for complex purpose. Like :-
k8s
|--> nestjs Pod (Our own app)
|--> postgres-primary-------|
|--> postgres-replica-1     |---> postgres cluster
|--> postgres-replica-2-----|
  • CRD obj is stored in etcd
  • It is watched by operator controller. specific to the cluster we want (Postgres, kafka) . The cluster specific operator is installed in K8s cluster, via operator manifest in which in the deployment section, the location from/image from where the operator needs to be installed is mentioned. This installed operator will take care of replicas, replication, failure, backups, upgrades, etc.

Deployment section example in operator

kind: deployment
containers:
- image:
  Some-company
  postgres
  Operator: v1
  • CRD (Custom Resource Definition):
    • lets us add new resource type to K8s. (that are not built-in like kind:Pod, kind:Service, kind:Deployment, etc)
    • Examples for new resource types:
    • kind: kafkaCluster, kind: PostgresCluster
    • Added it is defined in operator manifest in CRD section, which only fully K8s that one specific type of obj exists.
    • The actual creation of object for that cluster is dependent on custom resource file (the manifest specific to that object)
    • eg. If CRD section in operator.yaml
    kind: CustomResourceDefinition
    spec:
      names:
        kind: PostgresCluster
    
    • Custom Resource (CR) example
    postgres-cluster.yaml
    kind: PostgresCluster
    metadata:
      name: my-db
    spec:
      instances: 3
    
  • API Group:
    • so when K8s is installed. kubeapi server comes along w/ it. In kube api server, along w/ it comes some built-in API (sources) - These APIs are exposed to outside K8s to which HTTP API calls are made by kubectl (http client)
    • API groups are some groupings made by K8s for these api paths for each resource type.
      • Built in API groups & paths:
        • CORE (no group) api/v1
          • pods, services, configmaps, secrets, nodes, namespaces
        • app. (/apps/apps/v1)
          • Deployments, Replicasets, Statefulsets, Daemonsets
        • batch (/apis/batch/v1)
          • Jobs, CronJobs
        • networking (/apis/networking.k8s.io/v1)
          • Ingress, NetworkPolicy
        • autoscaling (/apis/ /HPA) These all are compiled into kube-apiserver.
      • Additional APIs
        • Generate via CRDS.
        • kube-apiserver dynamically registers new route when user creates CRD.
        • we get new api path like apis/mycompany.com/v1/resources.
      • Aggregated API server (Advanced).
        • External API server can also plug into kube-api server.
      • Most of the conversations with K8s cluster between kubectl, kubelet, etc, controller schedules with kube-api server.happens via http/https rest & watch api calls & requests & these api paths
      • when writing manifest files, we mention the api path associated with its resource type so that kube-api server can do it like this :
        • apiVersion: apps/v1
          • kind: Deployment
        • apiVersion: v1
          • kind: Pod
        • apiVersion: batch/v1
          • kind: Job … etc
      • This is done so that when these manifests are applied, kube-api server can do the following:
        • Parse apiVersion + kind
        • Find matching resource handler
        • Validate schemas
        • Run admission controllers
        • Default missing fields
        • Store object in etcd
  • Admission Controllers
    • So when a request is made to K8s cluster via kubectl, a lot of stuff/checks happen w/ admission controllers are just part of it.
    • Stuff that happens after req from kubectl to kube-api server:
    kubectl apply deployment.yaml (via http req)
      |
      v
    kube-api-server
    |-- http routing (matches apiVersion = apps/v1, kind = Deployment)
    |-- authentication(verify who is making the req)
    |-- authorization(verify if authenticated user is allowed to make req)
    |-- request decoders(convert manifest to resource obj)
    |-- API resource lookup(kube finds appropriate handlers from
    |     internal api-registry to handle [apps/v1, Deployment])Decoded resourceobj
    |-- (built-in) Admission chain (chain of admission controllers)
        |-- service account controllers(injects default secure account)
        |-- default storage class(adds default storage class if omitted)
        |-- limit ranger (applies/enforces resource limits)
        |-- Pod security (checks security requirement)
        |-- resource quota (check namespace quota)
        |-- Mutating Admission Webhook (Calls custom mutation webhooks)
        |-- Validating Admission webhook (Calls custom validation webhooks)
    
    • Custom use defined admission controllers can also be added later via manifests.
  • Taints
    • rule applied to node based on which pods are not to be scheduled there. (cause normally all nodes are welcome to host pods).
    • Cases when you need to taint: GPU workloads, db workloads, infra components, control plane components.
    • How a taint looks like:
      • dedicated = database : NoSchedule
      • gpu = true : NoSchedule
    • Ways to taint nodes:
      • (Most common) kubectl taint kubectl taint nods worker-1 dedicated = gpu : NoSchedule
      • directly in Node manifest (less common).
      apiVersion : v1
      kind: Node
      metadata:
        name: worker-1
      spec:
        taints:
        - key: dedicated
        value: gpu
        effect: NoSchedule
      
      • Automatically by K8s (some taints are added by controller)
      • e.g: node.kubernetes.io/not-readynode.kubernetes.io/memory-pressure … etc.
  • Tolerations
    • Rule on pod saying, allowing it to run on a node set not wanting taint.node set not wanting taint.
    • Defined in Pod, Deployment, StatefulSet, Daemonset specification manifests.
    • e.g:
      apiVersion: apps/v1
      kind: Deployment
      spec:
      template:
        spec:
          tolerations
          - key: dedicated
          operator: equal
          value: gpu
          effect: NoSchedule
      

      Not satisfying taint - toleration can make pods pending

    • e.g: 3 taint & toleration
      • Node 1 -> accept all pods (no taint)
      • Node 2 -> tainted (gpu=true:NoSchedule)
      • Pod 1 -> no toleration
      • Pod 2 -> toleration - gpu=true: noo schedule
      • Result:
        • Node 2 - Pod 2 allowed, pod 2 rejected
        • Node 1 - Pod 1 allowed, pod 2 allowed.
  • Affinity/Anti-affinity
    • Rules before allowing pods to be placed near/force from any node/pod.
    • Can have node affinity e.g: pod affinity/anti affinity.Can be hard/soft rules.Must have topology key.
    • Node affinity
      • pod placement based on node labels.
      • e.g: if
        • Node A - disk=ssd
        • Node B - disk=hdd
        • Then Pod - Node Affinity :- disk = ssd. Schedule onto SSD nodes.
    • Pod Affinity/AntiAffinity
      • Pod placement based on other pod labels.
    • Hard rule: Soft rules
      • Hard rule
        • must satisfy. Else pod state goes into pending.
      • Soft rule
        • nice to have. But pod will still run somewhere.
    • Topology key (Scope)
      • Region where pod must have affinity/anti-affinity.
      • Eg: Near xyz node. Near xyz zone… etc.
    • eg to all taint + toleration + affinities
    Cluster
    |--Node A
    |  |--labels:
    |  |   type=gpu
    |  |   zone=east
    |  |--taint:
    |      dedicated = gpu : NoSchedule.
    |--Node B
    |  |--labels:
    |  |   type=general
    |  |   zone=east
    |  |--no taint.
    |--Node C
       |--labels:
       |   type=gpu
       |   zone=west
       |--taint:
           dedicated = gpu : NoSchedule.
    
    -> Existing pod
    redis
    |-- running on node A.
    |--labels:
    |--app=redis
    
    -> New pod (api-server)
    Tolerations:
    - key: dedicated
      value: gpu
    affinity:
      Node Affinity:
        required:
          type = gpu
      Pod Affinity:
        required:
          app = redis
      Pod AntiAffinity:
        required:
          app = api-server
    
    -> Result:
    Node taint -> all gpu tainted.
    New pod toleration -> gpu taint. So can run on all nodes A, B, C.
    Node affinity -> on nodes w/ type=gpu.
                    So Node A ✓, Node B ×, Node C ✓
    new pod, pod affinity -> near redis so Node A ✓, Node C ×
    pod anti affinity -> Not near api-server.
                        Since no node has api-server pod, Node A ✓.
    
    • Case
      • If Node A had a pod for api-server, then new pod will go into pending state.
  • Eviction
    • K8s process of removing pod from Node. K8s pod would normally stop on its own.
    • Reasons: Memory pressure, Disk Pressure, Node failure, A node having taint called “No-execut” like maintenance = true. “NoExecute” like “maintenance = true? NoExecute
    • Eviction vs Deletion
      • Eviction done by k8s, Delete - user removal
      • User can also manually want it to evict via kubectl.
    • After eviction
      • If statefulset or deployment or replacement pod from evicted w/ new one created w/ out migration.
      • If standalone pod -> Pod evicted & Gone.
    • Evictions can be rejected by. Pod Disruption Budget (PDB) restricted.
      • Eg: minAvailable : 2
      • (keeps 2 replicas always healthy - Protection during maintenance).
    • Eviction Not same as OOM kill.
      • Eviction -> Done by k8s
      • OOMkill -> (out of memory kill) done by node.
  • Drain
    • Process of safely removing workloads from node.
    • Reasons: Reboot a VM, upgrade the OS, replace hardware, upgrade, kubelet; Shutdown node.
    • Process
      • marks pod mode as unschedulable.
      • evicts existing pods.
      • if deployment, the controller - recreate pods elsewhere & then evict.
      • After drain, safe to reboot, shutdown, etc.
    • Cordon vs Drain
      • cordon -> only marking node as unschedulable.
      • drain -> mark & evict.

        Uncordon -> unmark it as schedulable.

    • Daemonset Pods are generally ignored during drain in terminal command “kubectl drain worker-1 –ignore -daemonsets.”

Cluster diagram

Developer/User machine
|-- Developer laptop
| |-- kubectl
| |-- kubeconfig
| |-- Browser
|-- CI/CD machine
| |-- kubectl
| |-- helm
| |-- ArgoCD CLI
| |-- Deployment Pipelines
|-- Admin Machine
|-- kubectl
|-- kubeadm

K8s cluster
|-- Control Plane Nodes
| |-- kubelet
| |-- Static Pods
| | |-- kube-api-server Pod
| | |-- kube-scheduler Pod
| | |-- kube-controller-manager Pod
| | |-- etcd Pod
| |-- Container Runtime (containerd / CRI-O)
| |-- CNI components
| |-- CSI components
|-- Worker Nodes
| |-- kubelet
| |-- kube-proxy
| |-- Container Runtime (containerd / CRI-O)
| |-- CNI Components
| |-- CSI Node components
| |-- Pods
| |-- Application Pod
| |-- CoreDNS Pod
| |-- Metrics Server Pod
| |-- Ingress Controller Pod
| |-- Prometheus Pod
| |-- Grafana Pod
|-- K8s API objects (records stored in etcd)
|-- Namespace
|-- Node
|-- Pod
|-- ReplicationSet
|-- Deployment
|-- StatefulSet
|-- DaemonSet
|-- Job
|-- CronJob
|-- Ingress
|-- Ingress Class
|-- Gateway
|-- HttpRoute
|-- Config Map
|-- Secret
|-- Secure Account
|-- Persistent Volume
|-- Persistent Volume Claim
|-- Storage Class
|-- Service
|-- Endpoints
|-- EndpointSlice
|-- Resource Quota
|-- Limit Range
|-- Resource Quota
|-- Limit Range
|-- Network Policy
|-- Horizontal Pod Autoscaler
|-- Pod Disruption Budget
|-- Priority Class
|-- Runtime Class
|-- Custom Resource Definition
|-- Custom Resources

External Systems
|-- Container Registry (Docker Hub, GHCR, ECR, GCR, Artifact Registry)
|-- DNS provider
|-- Storage System (NFS, Ceph, SAN, NAS)
|-- Cloud load balancer
|-- External users

This site uses Just the Docs, a documentation theme for Jekyll.