Kubernetes ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਦਾ ਹੈ?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (ਅਕਸਰ **K8s** ਕਹਿ ਕੇ ਸੰਖੇਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ) ਇੱਕ ਓਪਨ-ਸੋਰਸ **container orchestration** ਪਲੇਟਫਾਰਮ ਹੈ। ਇਹ ਮਸ਼ੀਨਾਂ ਦੇ ਇੱਕ cluster ਵਿੱਚ container ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ deploying, scaling, networking, ਅਤੇ healing ਨੂੰ ਆਟੋਮੇਟ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ *desired state* ਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ ਅਤੇ Kubernetes ਲਗਾਤਾਰ ਕੰਮ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਹਕੀਕਤ ਉਸ ਨਾਲ ਮੇਲ ਖਾਵੇ।

## ਸਮੱਸਿਆ: ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ container ਚਲਾਉਣਾ ਔਖਾ ਹੈ

```text
ਤੁਹਾਡੇ ਕੋਲ container ਹਨ (Docker ਤੋਂ), ਪਰ production ਵਿੱਚ ਤੁਹਾਨੂੰ ਇਹ ਵੀ ਜਵਾਬ ਦੇਣੇ ਪੈਂਦੇ ਹਨ:
  → ਹਰ container ਕਿਹੜੀ ਮਸ਼ੀਨ 'ਤੇ ਚੱਲਦਾ ਹੈ? (scheduling)
  → ਜੇ ਕੋਈ container crash ਹੋ ਜਾਵੇ ਤਾਂ? (self-healing / restarts)
  → ਜੇ ਪੂਰਾ node ਮਰ ਜਾਵੇ ਤਾਂ? (ਕਿਤੇ ਹੋਰ reschedule ਕਰੋ)
  → 50 replica ਇੱਕ-ਦੂਜੇ ਨੂੰ ਕਿਵੇਂ ਲੱਭਣ ਤੇ ਗੱਲ ਕਰਨ? (service discovery)
  → ਜ਼ੀਰੋ downtime ਨਾਲ ਨਵਾਂ version ਕਿਵੇਂ roll out ਕਰਾਂ? (rolling updates)
  → traffic spike 'ਤੇ 3 ਤੋਂ 30 replica ਤੱਕ ਕਿਵੇਂ scale ਕਰਾਂ? (autoscaling)
ਇਹ ਸਭ ਕਈ server 'ਤੇ ਹੱਥੀਂ ਕਰਨਾ scale ਨਹੀਂ ਹੁੰਦਾ।
```

## ਹੱਲ: declarative orchestration

ਤੁਸੀਂ ਇੱਕ **manifest** ਜਮ੍ਹਾਂ ਕਰਦੇ ਹੋ ਜੋ ਤੁਹਾਡੀ ਲੋੜ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ, ਅਤੇ cluster ਦੇ **control loops** system ਨੂੰ ਉਸ ਵੱਲ ਚਲਾਉਂਦੇ ਹਨ:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਹਮੇਸ਼ਾ 3 ਕਾਪੀਆਂ ਚੱਲਣ"
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80
```

```bash
kubectl apply -f web.yaml     # desired state ਦਾ ਐਲਾਨ ਕਰੋ
kubectl get pods              # Kubernetes ਨੇ 3 Pod ਬਣਾ ਕੇ schedule ਕਰ ਦਿੱਤੇ ਹਨ
```

ਜੇ ਕੋਈ Pod ਮਰ ਜਾਵੇ, ਤਾਂ Kubernetes ਫ਼ਰਕ ਵੇਖ ਲੈਂਦਾ ਹੈ (2 ਚੱਲ ਰਹੇ ਬਨਾਮ 3 ਲੋੜੀਂਦੇ) ਅਤੇ ਆਪਣੇ-ਆਪ ਇੱਕ ਬਦਲ ਬਣਾ ਦਿੰਦਾ ਹੈ।

## Kubernetes ਤੁਹਾਨੂੰ ਕੀ ਦਿੰਦਾ ਹੈ

```text
✓ SCHEDULING       — resource ਤੇ constraint ਦੇ ਆਧਾਰ 'ਤੇ Pod ਨੂੰ node 'ਤੇ ਰੱਖਦਾ ਹੈ
✓ SELF-HEALING     — ਫੇਲ੍ਹ container restart ਕਰਦਾ, ਮਰੇ Pod/node ਬਦਲਦਾ ਹੈ
✓ SERVICE DISCOVERY— Pod ਦੇ ਸਮੂਹਾਂ ਲਈ ਸਥਿਰ virtual IP ਤੇ DNS ਨਾਂ
✓ LOAD BALANCING   — ਸਿਹਤਮੰਦ replica ਵਿੱਚ traffic ਵੰਡਦਾ ਹੈ
✓ ROLLING UPDATES  — ਬਿਨਾਂ downtime ਨਵੇਂ version ਭੇਜਦਾ, ਫੇਲ੍ਹ 'ਤੇ roll back ਕਰਦਾ ਹੈ
✓ SCALING          — ਹੱਥੀਂ ਜਾਂ ਆਪਣੇ-ਆਪ (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — image ਦੁਬਾਰਾ build ਕੀਤੇ ਬਿਨਾਂ configuration inject ਕਰਦਾ ਹੈ
✓ STORAGE ORCHESTRATION — workload ਨਾਲ persistent volume ਜੋੜਦਾ ਹੈ
```

## Declarative ਬਨਾਮ imperative

```text
IMPERATIVE  → "ਇਹ ਲੇਖ ਚਲਾਓ, ਫਿਰ ਉਹ ਲੇਖ" (ਤੁਸੀਂ ਹਰ ਕਦਮ ਸੰਭਾਲਦੇ ਹੋ)
DECLARATIVE → "ਇਹ ਹੈ ਉਹ ਅੰਤਿਮ ਸਥਿਤੀ ਜੋ ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ" (Kubernetes ਉਸ ਵੱਲ reconcile ਕਰਦਾ ਹੈ)
declarative, reconciliation-loop ਮਾਡਲ Kubernetes ਦਾ ਮੁੱਖ ਵਿਚਾਰ ਹੈ।
```

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Kubernetes production ਵਿੱਚ container ਵਾਲੇ workload ਚਲਾਉਣ ਦਾ ਅਸਲ ਮਿਆਰ ਬਣ ਗਿਆ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਮਝਣਾ ਕਿ ਇਹ ਕੀ ਹੈ ਅਤੇ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਦਾ ਹੈ ਬੁਨਿਆਦੀ, ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਲਾਗੂ ਹੋਣ ਵਾਲਾ ਗਿਆਨ ਹੈ। Container (Docker ਵਰਗੇ ਸੰਦਾਂ ਤੋਂ) packaging ਹੱਲ ਕਰਦੇ ਹਨ, ਪਰ ਉਹ ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਪਰਿਚਾਲਨ ਸਵਾਲਾਂ ਦਾ ਜਵਾਬ ਨਹੀਂ ਦਿੰਦੇ: ਹਰ container ਕਿਹੜੀ ਮਸ਼ੀਨ 'ਤੇ ਚੱਲਦਾ ਹੈ, ਜਦੋਂ ਕੋਈ container ਜਾਂ ਪੂਰਾ node ਫੇਲ੍ਹ ਹੁੰਦਾ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ, ਦਰਜਨਾਂ replica ਇੱਕ-ਦੂਜੇ ਨੂੰ ਕਿਵੇਂ ਲੱਭਦੇ ਤੇ ਗੱਲ ਕਰਦੇ ਹਨ, ਬਿਨਾਂ downtime ਨਵਾਂ version ਕਿਵੇਂ roll out ਕਰੀਏ, ਅਤੇ ਮੰਗ ਨਾਲ ਉੱਪਰ-ਹੇਠਾਂ ਕਿਵੇਂ scale ਕਰੀਏ। Kubernetes ਇਹ ਸਭ ਨੂੰ ਇੱਕ **declarative, reconciliation-based** ਮਾਡਲ ਰਾਹੀਂ ਸੰਬੋਧਿਤ ਕਰਦਾ ਹੈ: ਤੁਸੀਂ ਇੱਕ manifest ਵਿੱਚ desired state ਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਅਤੇ cluster ਦੇ control loops ਲਗਾਤਾਰ ਅਸਲ state ਨੂੰ ਉਸ ਵੱਲ ਚਲਾਉਂਦੇ ਹਨ — ਲੋੜ ਅਨੁਸਾਰ Pod ਬਣਾਉਂਦੇ, schedule ਕਰਦੇ, restart ਕਰਦੇ ਅਤੇ ਬਦਲਦੇ ਹਨ। ਇਹ ਤੁਹਾਨੂੰ **self-healing** (crash ਹੋਏ container ਅਤੇ ਮਰੇ node ਆਪਣੇ-ਆਪ ਮੁੜ ਬਹਾਲ ਹੁੰਦੇ ਹਨ), **service discovery ਅਤੇ load balancing** (Pod ਦੇ ਸਮੂਹਾਂ ਅੱਗੇ ਸਥਿਰ virtual IP ਤੇ DNS), **rolling updates ਅਤੇ rollbacks** (zero-downtime deploy), **scaling** (ਹੱਥੀਂ ਜਾਂ ਆਪਣੇ-ਆਪ), ਅਤੇ **config, secret, ਤੇ storage orchestration** ਦਿੰਦਾ ਹੈ। ਕਿਉਂਕਿ Kubernetes ਇਸ ਗੱਲ ਦਾ ਆਧਾਰ ਹੈ ਕਿ ਉਦਯੋਗ ਦਾ ਇੱਕ ਵੱਡਾ ਹਿੱਸਾ software ਨੂੰ ਕਿਵੇਂ deploy ਅਤੇ ਪਰਿਚਾਲਿਤ ਕਰਦਾ ਹੈ — ਹਰ ਵੱਡੇ cloud ਅਤੇ on-premises 'ਤੇ — ਇਸ ਲਈ ਇਸਦੇ ਮਕਸਦ ਅਤੇ ਇਸਦੇ ਦਿਲ ਵਿੱਚ ਪਈ declarative ਮਾਡਲ ਨੂੰ ਸਮਝਣਾ ਆਧੁਨਿਕ infrastructure ਦੇ ਕੰਮ ਲਈ ਜ਼ਰੂਰੀ ਪਿਛੋਕੜ ਹੈ, ਅਤੇ ਉਹ ਮਾਨਸਿਕ ਨੀਂਹ ਹੈ ਜਿਸ 'ਤੇ ਹਰ ਦੂਜਾ Kubernetes ਸੰਕਲਪ ਉਸਰਦਾ ਹੈ।

ਸਮੱਸਿਆ: ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ container ਚਲਾਉਣਾ ਔਖਾ ਹੈ

ਹੱਲ: declarative orchestration

Kubernetes ਤੁਹਾਨੂੰ ਕੀ ਦਿੰਦਾ ਹੈ

Declarative ਬਨਾਮ imperative

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ