🖼️ See the drawing + lab 🏠 Course home 🌿 Branch on GitHub ✏️ View source

🖼️ आकृती आणि labThe drawing + lab पूर्ण पानावर उघडा ↗Open full page ↗

🏫 धडा 10 — Ingress: मुख्य फाटक आणि त्यावरचा फलक

📍 तुम्ही इथे आहात: 13 पैकी धडा 10 · मागचा: lesson-09-autoscaling · पुढचा: lesson-11-rollouts

📦 या ब्रँचमध्ये काय आहे

धडे 01–09, आणि: Ingress — internet वरून योग्य Service पर्यंत येणारे HTTP traffic. खरी file:

k8s/ingress.yaml — एक AWS load balancer, दोन paths, दोन services

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

शाळेला एकच मुख्य फाटक 🏫 असते — प्रत्येक वर्गखोलीसाठी वेगळे फाटक नाही (30 फाटकांसाठी 30 पहारेकऱ्यांचा पगार कल्पना करा! 💸). फाटकावर एक पहारेकरी फलक घेऊन उभा असतो:

🪧 "क्रीडा दिनासाठी आलात? → डावीकडे मैदानाकडे जा. बाकी काहीही? → सरळ कार्यालयाकडे जा."

पाहुणे फक्त त्या एका फाटकाकडे येतात; पहारेकरी त्यांना कुठे जायचे आहे ते वाचतो आणि त्यांना योग्य खोलीकडे पाठवतो.

Ingress म्हणजे हेच फाटक + फलक:

संपूर्ण app साठी एकच सार्वजनिक प्रवेशद्वार (AWS वर: एक Application Load Balancer).
URL वर आधारित नियम: /analytics/... → Python service, बाकी सगळे (/) → Node service.
फाटक स्वतः एक पहारेकऱ्यांची कंपनी बांधते — ingress controller (EKS वर: AWS Load Balancer Controller add-on). पहारेकऱ्यांची कंपनीच नेमली नाही = फलक आहे पण तो कोणीच वाचत नाही!

🗺️ आकृती

flowchart LR
    U["🌍 Internet<br/>parent's browser"]
    ALB["🏫 Main gate<br/>AWS ALB - created by<br/>the Ingress controller"]
    R{"🪧 signboard<br/>which path?"}
    S1["☎️ Service school-api"]
    S2["☎️ Service school-analytics"]
    P1["🪑 node pods"]
    P2["🪑 python pods"]
    U -->|"http://gate/students"| ALB --> R
    R -->|"/analytics/*"| S2 --> P2
    R -->|"/* everything else"| S1 --> P1

❓ काय

Ingress म्हणजे HTTP routing नियमांचा संच: host/path → Service. ते फक्त data आहे; एक ingress controller हे नियम पाहतो आणि ते लागू करण्यासाठी खरा load balancer configure करतो.
आपला Ingress ingressClassName: alb + annotations वापरतो, म्हणून AWS controller internet-facing ALB बनवतो जो थेट pod IPs कडे route करतो आणि त्यांचे /healthz वर health-check करतो (धडा 07 चा endpoint, पुन्हा वापरलेला!).
नियमांचा क्रम महत्त्वाचा: /analytics (विशिष्ट) / (सर्वसमावेशक) च्या आधी लिहिलेला आहे.
Local ला AWS नसते — minikube त्याऐवजी NGINX ingress controller वापरतो; तीच Ingress ची कल्पना, वेगळी पहारेकऱ्यांची कंपनी.

🤔 का

धडा 04 मधल्या Services ClusterIP आहेत — मुद्दाम फक्त अंतर्गत. तुम्ही प्रत्येक service तिच्या स्वतःच्या cloud LoadBalancer ने बाहेर उघडू शकता, पण प्रत्येक LB ला खरे पैसे लागतात आणि TLS, domains आणि routing तुम्हाला N वेळा सांभाळावे लागेल. एक Ingress = एक फाटक, एक बिल, एक जागा HTTPS certificates आणि path नियमांसाठी — आणि पुढे कधी तिसरी service जोडायची झाली तर फलकावर फक्त एक ओळ वाढते.

🔧 कसे (या repo मध्ये)

k8s/ingress.yaml, त्यातले रंजक भाग:

metadata:
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing   # public gate
    alb.ingress.kubernetes.io/target-type: ip           # straight to pod IPs
    alb.ingress.kubernetes.io/healthcheck-path: /healthz
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /analytics    # specific first!
            backend: { service: { name: school-analytics, port: { number: 80 } } }
          - path: /             # catch-all last
            backend: { service: { name: school-api, port: { number: 80 } } }

🧪 करून पाहा

# LOCAL (minikube):
minikube addons enable ingress                # hire the local guard company
# use a local-friendly ingress (no ALB annotations needed):
sed '/alb.ingress/d; s/ingressClassName: alb/ingressClassName: nginx/' \
  k8s/ingress.yaml | kubectl apply -f -
kubectl -n school get ingress                 # note the ADDRESS
minikube tunnel                               # then browse http://127.0.0.1/

# ON EKS (after terraform apply + installing the AWS LB Controller):
kubectl apply -f k8s/ingress.yaml
kubectl -n school get ingress -w              # ADDRESS becomes a real ALB DNS name
curl http://<ALB-address>/students            # → Node API
curl http://<ALB-address>/analytics/summary   # → Python API

🔧 या धड्यासाठी kubectl

kubectl get ingress · kubectl describe ingress

🔗 यावर आधारित: 🪪 AWS L15 (ALB) · L16 (Route 53)

✅ तपासा — तुम्हाला काय दिसायला हवे

curl -H 'Host: school.local' http://INGRESS_IP/analytics/ Python service पर्यंत पोहोचते; / Node पर्यंत पोहोचते — एक पत्ता, path नुसार route.

🧹 साफसफाई

local cluster: kubectl delete -f k8s/ (किंवा तुम्ही apply केलेली file) — EKS वर चालू राहिलेल्या प्रत्येक गोष्टीचे तासाप्रमाणे बिल लागते; EKS वर त्याने बनवलेल्या ALB चे दर तासाला बिल लागते

⚠️ नेहमीच्या चुका

विशिष्ट paths / च्या नंतर लिहिणे — क्रम महत्त्वाचा आहे
ingress controller add-on विसरणे — controller नसलेला Ingress object काहीच करत नाही

⏭️ पुढे

Traffic वाहते आहे! आता: एका सेकंदाचाही downtime न होता version 2 कसे पाठवायचे — आणि खराब release मागे कसा घ्यायचा? Rollouts आणि rollbacks.

git checkout lesson-11-rollouts

🏫 Lesson 10 — Ingress: the main gate and its signboard

📍 You are here: Lesson 10 of 13 · Previous: lesson-09-autoscaling · Next: lesson-11-rollouts

📦 What's in this branch

Lessons 01–09, plus: the Ingress — HTTP traffic from the internet into the right Service. Real file:

k8s/ingress.yaml — one AWS load balancer, two paths, two services

🧒 Explain like I'm 5

A school has ONE main gate 🏫 — not a separate gate for every classroom (imagine paying a guard for 30 gates! 💸). At the gate stands a guard with a signboard:

🪧 "Here for sports day? → go LEFT to the playground. Everything else? → go STRAIGHT to the office."

Visitors just walk to the one gate; the guard reads where they want to go and points them to the right room.

The Ingress is that gate + signboard:

ONE public entrance (on AWS: one Application Load Balancer) for the whole app.
Rules based on the URL: /analytics/... → the Python service, everything else (/) → the Node service.
The gate itself is built by a guard company — the ingress controller (on EKS: the AWS Load Balancer Controller add-on). No guard company hired = signboard exists but no one reads it!

🗺️ Diagram

flowchart LR
    U["🌍 Internet<br/>parent's browser"]
    ALB["🏫 Main gate<br/>AWS ALB - created by<br/>the Ingress controller"]
    R{"🪧 signboard<br/>which path?"}
    S1["☎️ Service school-api"]
    S2["☎️ Service school-analytics"]
    P1["🪑 node pods"]
    P2["🪑 python pods"]
    U -->|"http://gate/students"| ALB --> R
    R -->|"/analytics/*"| S2 --> P2
    R -->|"/* everything else"| S1 --> P1

❓ What

An Ingress is a set of HTTP routing rules: host/path → Service. It's just data; an ingress controller watches these rules and configures a real load balancer to enforce them.
Ours uses ingressClassName: alb + annotations, so the AWS controller builds an internet-facing ALB that routes straight to pod IPs and health-checks them on /healthz (lesson 07's endpoint, reused!).
Rule order matters: /analytics (specific) is listed before / (catch-all).
Locally there's no AWS — minikube uses an NGINX ingress controller instead; same Ingress idea, different guard company.

🤔 Why

Lesson 04's Services are ClusterIP — internal only, on purpose. You could expose each service with its own cloud LoadBalancer, but every LB costs real money and you'd manage TLS, domains and routing N times. One Ingress = one gate, one bill, one place for HTTPS certificates and path rules — and adding a third service someday is just one more line on the signboard.

🔧 How (in this repo)

k8s/ingress.yaml, the interesting bits:

metadata:
  annotations:
    alb.ingress.kubernetes.io/scheme: internet-facing   # public gate
    alb.ingress.kubernetes.io/target-type: ip           # straight to pod IPs
    alb.ingress.kubernetes.io/healthcheck-path: /healthz
spec:
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /analytics    # specific first!
            backend: { service: { name: school-analytics, port: { number: 80 } } }
          - path: /             # catch-all last
            backend: { service: { name: school-api, port: { number: 80 } } }

🧪 Try it

# LOCAL (minikube):
minikube addons enable ingress                # hire the local guard company
# use a local-friendly ingress (no ALB annotations needed):
sed '/alb.ingress/d; s/ingressClassName: alb/ingressClassName: nginx/' \
  k8s/ingress.yaml | kubectl apply -f -
kubectl -n school get ingress                 # note the ADDRESS
minikube tunnel                               # then browse http://127.0.0.1/

# ON EKS (after terraform apply + installing the AWS LB Controller):
kubectl apply -f k8s/ingress.yaml
kubectl -n school get ingress -w              # ADDRESS becomes a real ALB DNS name
curl http://<ALB-address>/students            # → Node API
curl http://<ALB-address>/analytics/summary   # → Python API

🔧 kubectl for this lesson

kubectl get ingress · kubectl describe ingress

🔗 Builds on: 🪪 AWS L15 (ALB) · L16 (Route 53)

✅ Verify — what you should see

curl -H 'Host: school.local' http://INGRESS_IP/analytics/ reaches the Python service; / reaches Node — one address, routed by path.

🧹 Clean up

local cluster: kubectl delete -f k8s/ (or the file you applied) — on EKS, anything left running bills by the hour; on EKS the ALB it created bills hourly

⚠️ Common mistakes

specific paths after / — order matters
forgetting the ingress controller add-on — an Ingress object with no controller does nothing

⏭️ Next

Traffic flows! Now: how do you ship version 2 without a second of downtime — and how do you undo a bad release? Rollouts & rollbacks.

git checkout lesson-11-rollouts

← Previousautoscaling Next →rollouts

This page is the lesson's README from the lesson-10-ingress branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.