How to Monitor Kubernetes Ingress Controllers with Vigilmon

Kubernetes Ingress controllers are the traffic gateway for your cluster — they route external HTTP/HTTPS traffic to your services. When an Ingress controller fails, every service behind it goes down simultaneously. This guide covers monitoring your Kubernetes Ingress setup with Vigilmon.

Why Ingress Monitoring Is Critical

The Ingress controller sits in front of all your services. A failure here means:

• All services are unreachable from the internet
• Internal service-to-service traffic via ingress breaks
• SSL termination stops working (certificates aren't served)
• Health probes from load balancers start failing

Kubernetes internal probes (liveness/readiness) don't catch Ingress failures from the outside — only external monitoring does.

Setting Up External Uptime Monitoring

For each service exposed via Ingress, add a monitor in Vigilmon:

1. Log in to vigilmon.online
2. Click Add Monitor → HTTP(S)
3. Enter your service URL: https://api.yourapp.com
4. Set interval: 60 seconds
5. Enable alerts for your on-call team

Repeat for each critical service exposed via Ingress rules.

Health Check Endpoints for Ingress-Exposed Services

Monitor a dedicated health endpoint per service:

# kubernetes/ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
    - host: api.yourapp.com
      http:
        paths:
          - path: /health
            pathType: Prefix
            backend:
              service:
                name: api-service
                port:
                  number: 8080
          - path: /
            pathType: Prefix
            backend:
              service:
                name: api-service
                port:
                  number: 8080
  tls:
    - hosts:
        - api.yourapp.com
      secretName: api-tls-secret

Monitor https://api.yourapp.com/health in Vigilmon — this proves both the Ingress and the downstream service are functioning.

Monitoring Nginx Ingress Controller Health

Nginx Ingress exposes its own metrics endpoint:

# Check Nginx Ingress controller is running
kubectl get pods -n ingress-nginx

# Get the external IP
kubectl get svc -n ingress-nginx ingress-nginx-controller

You can also monitor the Nginx controller's health endpoint directly if it's exposed:

# Expose controller metrics via a separate service if needed
apiVersion: v1
kind: Service
metadata:
  name: ingress-nginx-metrics
  namespace: ingress-nginx
spec:
  ports:
    - name: metrics
      port: 10254
      targetPort: 10254
  selector:
    app.kubernetes.io/name: ingress-nginx

SSL Certificate Monitoring for Kubernetes

Kubernetes often uses cert-manager to provision Let's Encrypt certificates. These can fail to renew if:

• ACME challenge routes are broken
• DNS01 challenges fail
• cert-manager pods restart during renewal

Vigilmon's SSL monitoring catches cert expiry regardless of the underlying provisioner:

1. Add an SSL Monitor in Vigilmon for each domain
2. Set alert threshold: 14 days before expiry
3. This catches cert-manager renewal failures before they cause user-visible errors

Heartbeat Monitoring for CronJobs

For Kubernetes CronJobs (batch workloads), use Vigilmon's heartbeat monitor:

# kubernetes/cronjob.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: data-processor
spec:
  schedule: "*/10 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: processor
              image: yourapp/processor:latest
              command:
                - /bin/sh
                - -c
                - |
                  ./process-data && \n                  curl -s https://push.vigilmon.online/YOUR_HEARTBEAT_KEY
          restartPolicy: OnFailure

If the CronJob stops running (scheduler issue, image pull failure, or resource constraints), Vigilmon alerts you.

Multi-Service Monitoring Architecture

For a typical microservices deployment on Kubernetes:

Vigilmon Monitors:
├── api.yourapp.com (HTTP)
│   ├── /health → checks Ingress + API pod
│   └── SSL certificate
├── auth.yourapp.com (HTTP)  
│   └── /health → checks Ingress + auth service
├── dashboard.yourapp.com (HTTP)
│   └── / → checks Ingress + frontend
└── Heartbeats
    ├── Data pipeline CronJob (every 15m)
    └── Report generator CronJob (hourly)

Setting Up a Status Page for Kubernetes Services

1. In Vigilmon, create a Status Page
2. Group monitors by service tier:
   • API — api.yourapp.com health check
   • Auth — auth.yourapp.com health check
   • Dashboard — dashboard uptime
3. Publish at status.yourapp.com
4. Add to your Ingress:

  - host: status.yourapp.com
    http:
      paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: vigilmon-status-proxy
              port:
                number: 80

Alerting Strategy for Kubernetes Teams

Scenario	Signal	Alert Channel
API health check fails	HTTP 503 from /health	PagerDuty
SSL expiry approaching	< 14 days	Email
CronJob heartbeat missed	No ping in 20 min	Slack
Multiple services down	2+ monitors failing	PagerDuty + phone

Summary

Kubernetes Ingress controllers are a single point of failure for all external traffic. Vigilmon gives you external visibility that Kubernetes' internal probes can't provide:

1. HTTP monitors for each ingress-exposed service
2. Health endpoints that test Ingress + downstream service together
3. SSL monitors to catch cert-manager renewal failures
4. Heartbeat monitors for CronJobs and batch workloads
5. Status page for transparency with users

---

Vigilmon — external uptime monitoring for Kubernetes applications.