Kubernates notes 10 Static Pods, Manual Scheduling, Labels, and Selectors in Kubernetes

In Kubernetes, the following concepts play important roles in managing and organizing resources:

1. Static Pods:

  • Definition: A Static Pod is a pod that is managed directly by the kubelet on a node, without relying on the Kubernetes control plane (i.e., the API server, scheduler, or controller manager). Static pods are typically used for essential system-level workloads like kube-dns or monitoring agents.
  • Key Characteristics:
    • Not Managed by the Kubernetes API Server: Static pods are created and deleted directly by the kubelet, and they are not part of the cluster API.
    • Pod Definition Files: The kubelet watches for pod specification files placed in a specific directory (/etc/kubernetes/manifests by default).
    • Automatic Rescheduling: If a static pod crashes, the kubelet will automatically attempt to restart it.
    • No ReplicaSets or Deployments: Static pods are not controlled by higher-level controllers (like ReplicaSets or Deployments), so they can’t be scaled in the same way.
  • Use Cases: Static pods are commonly used for system-critical components like the Kubernetes control plane (e.g., the API server, etcd, scheduler).

Example Static Pod YAML:

apiVersion: v1
kind: Pod
metadata:
  name: static-pod
  labels:
    app: static
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

You can save this YAML to a file, and the kubelet will create the pod when it detects the file.

2. Manual Scheduling:

  • Definition: Manual scheduling refers to the process of placing pods onto specific nodes manually rather than allowing the Kubernetes scheduler to make the decision automatically based on resource availability and constraints.
  • How It Works:
    • NodeSelector: You can use the nodeSelector field in the pod specification to specify which node the pod should run on based on node labels.
    • Taints and Tolerations: Nodes can have taints to prevent certain pods from being scheduled unless the pod has the matching tolerations.
  • Use Cases: Manual scheduling is useful for pods that need to run on specific nodes due to hardware requirements (e.g., GPUs, custom hardware) or for running certain critical workloads on dedicated nodes.

Example of Manual Scheduling with nodeSelector:

apiVersion: v1
kind: Pod
metadata:
  name: manual-schedule-pod
spec:
  containers:
  - name: nginx
    image: nginx:latest
  nodeSelector:
    disktype: ssd

In this example, the pod will only run on nodes labeled with disktype=ssd.

3. Labels:

  • Definition: Labels are key-value pairs associated with Kubernetes objects like Pods, Nodes, Services, etc., used to organize and select subsets of objects.
  • Use Cases: Labels are primarily used for grouping, selecting, and organizing objects. For example, you can label all pods associated with a particular application or environment, which can later be used in services or deployments.
  • Examples:
    • A pod might be labeled with env=production to indicate that it is part of a production environment.
    • A node might be labeled with disktype=ssd to signify that it has SSD storage.

Example of Labels in a Pod:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: web
    env: production
spec:
  containers:
  - name: nginx
    image: nginx:latest

4. Selectors:

  • Definition: A Selector is a way to filter Kubernetes objects using labels. Selectors are used to specify a group of objects based on labels, which can be used by services, deployments, or other controllers to manage collections of resources.
  • Types:
    • Label Selectors: These are the most commonly used selectors. You can specify matchLabels (exact match) or matchExpressions (complex conditions).
    • Field Selectors: Field selectors are used to filter Kubernetes objects based on the fields of the resource, such as the pod name or node name.
  • Use Cases: Selectors are used to:
    • Define which set of pods a service should target.
    • Choose which pods a deployment should manage.
    • Create affinity/anti-affinity rules for pod placement.

Example of Label Selector in a Service:

apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  selector:
    app: web
  ports:
  - port: 80
    targetPort: 8080
  selector:
    env: production

In this example, the service will route traffic to all pods labeled with app=web and env=production.

Key Takeaways:

  • Static Pods are used for critical system components, and they are directly managed by the kubelet.
  • Manual Scheduling allows you to control which nodes your pods are scheduled on using nodeSelector, taints, and tolerations.
  • Labels provide a way to organize and categorize Kubernetes objects.
  • Selectors are used to select objects based on labels or fields, which helps in targeting resources like services, deployments, or replica sets.

Let me know if you need further clarification or examples!

© 2025 GeeksDirectory