If you use Deployment to deploy your application onto cluster where it will be consumed via a Service you should have no need at all to manually set Endpoints. Just rely on kubernetes and define normal selector in your Service object.

Other then that, when it makes sense (external service consumed from within cluster), you need to make sure your Endpoints ports definition fully matches the one on service (incl. protocol and potentially name). This incomplete matching is a most common reason for endpoints to be not visible as a part of service.

From the above discussion, what I understood is, you want to expose a service but not using the IP address. Service can be exposed in many ways. you should look for Service type LoadBalancer.

Try modifying your service is follow :

apiVersion: v1
kind: Service
metadata:
  name: my-api
spec:
  type: LoadBalancer
  selector:
    app: my-api
  ports:
  - protocol: TCP
    port: 3000
    targetPort: 3000

This will create a loadbalancer and map your service to the same.

Later you can add this loadbalancer to your DNS mapping service provided by Azure to give the domain name you like. ex: http:\\my-api.example.com:3000

Also I would like to add, if you define your ports as follow :

ports:
  - name: http
    port: 80
    targetPort: 3000

This will redirect traffic coming to port 80 to 3000 and your service call would look much cleaner for ex. http:\\my-api.example.com

Fixing the indentation of your yaml file, I was able to launch the deployment and service successfully. Also the DNS resolution worked fine.

Differences:

• Fixed indentation
• Used test1 namespaces instead of default
• Used containerPort 80 instead of 3000
• Used my image

Deployment:

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  labels:
    app: my-api
  name: my-api
  namespace: test1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-api
  template:
    metadata:
      labels:
        app: my-api
    spec:
      containers:
      - image: leodotcloud/swiss-army-knife
        name: my-api
        ports:
        - containerPort: 80
          protocol: TCP

Service:

apiVersion: v1
kind: Service
metadata:
  name: my-api
  namespace: test1
spec:
  ports:
  - port: 3000
    protocol: TCP
    targetPort: 80
  selector:
    app: my-api
  type: ClusterIP

Debugging steps:

• Install tcpdump inside both of the kube-dns containers and start capturing DNS traffic (with filters from the second pod IP)
• From inside the second pod, run curl or dig command using the FQDN.
• Check if the DNS query packets are reaching the kube-dns containers.
• If not, check for networking issues.
• If the DNS resolution is working, then start tcpdump inside your application container and check if the curl packet is reaching the container.
• Check the source and destination IP address of the packets.
• Check the iptables rules on the hosts.
• Check sysctl settings.