Ingress என்றால் என்ன, அது external traffic ஐ Service களுக்கு எவ்வாறு route செய்கிறது?

Question

IT Interview Practice · Accepted Answer

ஒரு **Ingress** என்பது **HTTP/HTTPS routing rule களை** வரையறுக்கும் ஒரு Kubernetes object — hostname களையும் URL path களையும் backend **Service களுக்கு** map செய்கிறது. இது ஒரு **Ingress Controller** ஆல் (nginx, Traefik, cloud gateway கள்) நிறைவேற்றப்படுகிறது, மேலும் ஒவ்வொரு service-க்கும் ஒரு LoadBalancer-க்குப் பதிலாக ஒரு நுழைவுப் புள்ளி, TLS termination, மற்றும் host/path routing ஐ உங்களுக்குத் தருகிறது.

## Ingress தீர்க்கும் பிரச்சினை

```text
Exposing many services with type: LoadBalancer means MANY cloud LBs (and public IPs)
— expensive, and no shared hostname/path routing or TLS.
Ingress gives ONE entry point that routes by host & path to internal ClusterIP Services.
```

## இது எப்படி ஒன்றாகப் பொருந்துகிறது

```text
      Internet
         │
   ┌─────┴──────────────┐
   │ Ingress Controller │  (a Pod, e.g. nginx; usually behind ONE LoadBalancer)
   │  reads Ingress rules│
   └─────┬──────────────┘
         │ routes by host / path
   ┌─────┼───────────────┬───────────────┐
   ▼                     ▼               ▼
 Service: web        Service: api    Service: admin  (all ClusterIP)
   │                     │               │
 Pods                  Pods            Pods

Ingress (rules)  ≠  Ingress Controller (the running proxy that enforces them)
```

## ஒரு Ingress manifest

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
    - hosts: [shop.example.com]
      secretName: shop-tls        # TLS cert/key stored in a Secret
  rules:
    - host: shop.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api
                port: { number: 80 }
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port: { number: 80 }
```

```text
shop.example.com/api/... → Service "api" → api Pods
shop.example.com/...     → Service "web" → web Pods
TLS is terminated at the controller using the cert in the "shop-tls" Secret.
```

## முக்கிய அம்சங்கள்

```text
• You MUST run an Ingress Controller — the Ingress object alone does nothing.
• ingressClassName selects which controller handles the rules.
• Ingress is HTTP/HTTPS (L7) only. For raw TCP/UDP use a Service or Gateway API.
• The newer Gateway API is the evolving successor with richer, role-oriented routing.
```

```bash
kubectl get ingress                  # list rules, hosts, addresses
kubectl describe ingress app-ingress # see backends & events
```

## இது ஏன் முக்கியம்

Ingress என்பது Kubernetes-இல் HTTP/HTTPS application களை வெளி உலகிற்கு வெளிப்படுத்தும் standard வழி, எனவே அதைப் புரிந்துகொள்வது middle-level engineer களுக்கு அத்தியாவசியமான networking அறிவு. அது தீர்க்கும் பிரச்சினை உறுதியானதும் பொதுவானதும்: பல service களை `type: LoadBalancer` வழியாக வெளிப்படுத்துவது என்பது ஒவ்வொரு service-க்கும் ஒரு தனி cloud load balancer மற்றும் public IP ஐ provision செய்வதைக் குறிக்கிறது — விலையுயர்ந்தது மற்றும் பகிரப்பட்ட hostname routing அல்லது TLS இல்லாதது — அதேசமயம் ஒரு **Ingress** உங்களுக்கு **host மற்றும் path** மூலம் internal ClusterIP Service களுக்கு route செய்து **TLS** ஐ மையமாக terminate செய்யும் ஒரு ஒற்றை நுழைவுப் புள்ளியைத் தருகிறது. மக்களைத் தடுமாற வைக்கும் வேறுபாடு **Ingress object** (declarative routing rule கள்) மற்றும் **Ingress Controller** (உண்மையில் இயங்கும் proxy — nginx, Traefik, ஒரு cloud gateway — அது அந்த rule களைக் கண்காணித்து அமல்படுத்துகிறது) இடையே; ஒரு controller நிறுவப்படாமல் rule கள் எதுவும் செய்யாது, மேலும் `ingressClassName` எந்த controller அவற்றைக் கையாளுகிறது என்பதைத் தேர்ந்தெடுக்கிறது. Ingress **L7 (HTTP/HTTPS மட்டும்)**-இல் இயங்குகிறது என்பதைப் புரிந்துகொள்வது — எனவே raw TCP/UDP-க்கு ஒரு Service அல்லது புதிய Gateway API தேவை — மற்றும் **Gateway API** என்பது வளர்ந்துவரும், மேலும் வெளிப்படையான successor என்பது, தற்போதைய, நிஜ-உலக அறிவைப் பிரதிபலிக்கிறது. Kubernetes-இல் கிட்டத்தட்ட ஒவ்வொரு user-facing application உம் ஒரு ஒற்றை நுழைவுப் புள்ளியிலிருந்து host/path-அடிப்படையிலான routing மற்றும் TLS ஐத் தேவைப்படுவதால், மற்றும் object-vs-controller வேறுபாடு interview களிலும் நடைமுறையிலும் அடிக்கடி குழப்பத்தின் மூலமாக இருப்பதால், Ingress-இன் உறுதியான புரிதல் ஒரு cluster-இல் web workload களை வெளிப்படுத்தி இயக்குவதற்கு அடிப்படையானது.

Ingress தீர்க்கும் பிரச்சினை

இது எப்படி ஒன்றாகப் பொருந்துகிறது

ஒரு Ingress manifest

முக்கிய அம்சங்கள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்