Kubernetes：如何从Service或Ingress向所有Pod发送请求

Absolutely! While Kubernetes Services and Ingress controllers are built for load-balancing traffic across pods (not broadcasting to every single one), there are totally practical ways to make your /send/all path trigger requests to all backend pods. Let’s break down the most common approaches:

This is the simplest approach if you’re okay with adding a bit of logic to your application:

• First, create a Headless Service for your backend pods (set clusterIP: None in the Service spec). Kubernetes will generate DNS records for each pod under this service, so you can resolve all pod addresses via the service’s DNS name (like my-service.my-namespace.svc.cluster.local).
• When your app receives a request to /send/all, add logic to:
  1. Resolve the Headless Service’s DNS to get all pod IPs/domain names; or
  2. Call the Kubernetes API (you’ll need to assign RBAC permissions to your pod’s ServiceAccount for this) to list all pods linked to your service.
• Loop through the list of pod addresses, send the request to each one, and optionally collect all responses to return to the original caller.

Here’s a quick pseudocode example to illustrate:

def handle_send_all(request):
    # Resolve all pod addresses via Headless Service DNS
    pod_hosts = resolve_dns("my-service.my-namespace.svc.cluster.local")
    responses = []
    
    for host in pod_hosts:
        # Forward the original request to each pod
        target_url = f"http://{host}:8080{request.path}"
        resp = requests.request(
            method=request.method,
            url=target_url,
            headers=request.headers,
            data=request.body
        )
        responses.append({
            "pod_host": host,
            "status_code": resp.status_code,
            "response_body": resp.text
        })
    
    return json.dumps(responses), 200

If you don’t want to mess with your application code, add a sidecar container to each backend pod that handles the broadcasting logic:

• The sidecar runs a lightweight HTTP service that listens on a local port (e.g., localhost:9090).
• When your main app gets a /send/all request, it forwards it to the sidecar instead of handling it directly.
• The sidecar uses the Headless Service DNS or Kubernetes API to fetch all pod addresses, sends the request to each one, and returns aggregated responses to the main app.

This keeps your application clean and focused on its core functionality, while the sidecar takes care of the broadcast work.

For larger clusters or if you want a cluster-wide solution, you can extend your Ingress controller or build a custom proxy service:

• Nginx Ingress + Lua: You can configure the Ingress to route /send/all to a custom proxy. This proxy uses Lua scripts to dynamically fetch backend pod lists (via Kubernetes API or service discovery) and broadcast requests to each pod.
• Custom Service Proxy: Build a small service that acts as an intermediary. When it receives /send/all requests, it fetches all backend pod addresses and forwards the request to each one, then returns combined responses.

• Performance: Broadcasting to many pods at once can create concurrency pressure—make sure to add timeouts and retry logic for failed requests.
• RBAC Permissions: If you’re using the Kubernetes API to list pods, your pod’s ServiceAccount needs pods.list permissions in its namespace.
• DNS Latency: Headless Service DNS resolution might have slight delays, so this works best for stable pod sets.

内容的提问来源于stack exchange，提问作者user1578872