Hey there! Let's walk through your problem step by step—you've got a non-K8s service running on localhost:8082 inside your main Pod (Pod1), and you need your Job's Pod (Pod2) to reach it, plus a unified way both containers can access it like they would localhost. Here are your options:

1. Direct Pod IP Access #

Pods in a Kubernetes cluster can reach each other via their cluster IPs, so Pod2 can connect directly to Pod1's IP on port 8082. The catch is Pod IPs change if the Pod restarts, so here's how to handle that:

• Use Kubernetes' Downward API to inject Pod1's IP into an environment variable in its container:

  env:
    - name: POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP
  

• When Pod1 creates the Job, pass this IP as an environment variable to Pod2's container:

  env:
    - name: MAIN_SERVICE_IP
      value: "<value-of-POD_IP-from-Pod1>"
  

Now Pod2 can use $(MAIN_SERVICE_IP):8082 to hit the service.

2. Headless Service for Stable DNS #

Create a headless Service (no cluster IP) that targets Pod1. This gives Pod1 a stable DNS record, even if its IP changes. Here's how to set it up:

1. Define the headless Service:

   apiVersion: v1
   kind: Service
   metadata:
     name: main-pod-headless
   spec:
     clusterIP: None
     selector:
       # Match the labels you've set on Pod1
       app: your-main-app-label
     ports:
       - port: 8082
         targetPort: 8082
   

2. Pod2 can now access the service using the DNS name: pod1-name.main-pod-headless.your-namespace.svc.cluster.local:8082 (swap in your actual Pod name and namespace).

3. Unix Domain Socket via Shared Volume (Same Node Only) #

If you can schedule Pod1 and Pod2 on the same node, a Unix socket is a fast, lightweight option:

1. Reconfigure your non-K8s service in main-container to listen on a socket file instead of localhost:8082.
2. Add a HostPath volume to Pod1, mounting it to a path like /var/run/service-socket where the socket file will live.
3. When creating the Job for Pod2, add the same HostPath volume and use node affinity to ensure Pod2 lands on the same node as Pod1.
4. Pod2 can then access the service directly via the socket file path (e.g., /var/run/service-socket).

To get a single access method that works like https://localhost:8082 for both main-container and job-container, use environment variables to abstract the endpoint:

1. In main-container's spec, set an env var pointing to the local service:

   env:
     - name: SERVICE_ENDPOINT
       value: "localhost:8082"
   

2. When defining Pod2's container in the Job, set the same env var to point to your Kubernetes Service (or the headless Service DNS we talked about):

   env:
     - name: SERVICE_ENDPOINT
       value: "your-main-service-name:8082"
   

3. Update your application code in both containers to use $(SERVICE_ENDPOINT) instead of hardcoding the address. This way, both containers use the same variable name—you just adjust the value based on which container is running.

This approach keeps your code consistent without adding extra complexity like sidecars or port-forwarding.

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