How to access a pod on an external IP – Nginx

Having in mind the following statement:

And I am a freshman in kubernetes.

I think there are some topics that should be addressed:

• General thoughts on the question
• $ kubectl port-forward ...
• Working example

General thoughts on the question

Kubernetes as a platform has a specific objects to accomplish certain things/tasks. You’ve already created a Pod named kube-nginx which spawned on of the Nodes.

To expose Pods (like your kube-nginx) for internal/external sources you will need to use a Service. You can read more about it by following official documentation:

Service

An abstract way to expose an application running on a set of Pods as a network service.
With Kubernetes you don’t need to modify your application to use an unfamiliar service discovery mechanism. Kubernetes gives Pods their own IP addresses and a single DNS name for a set of Pods, and can load-balance across them.

— Kubernetes.io: Docs: Concepts: Services networking: Service

Your Pod definition is correct and it will spawn a single Pod with nginx image but Kubernetes won’t be able to expose it to external sources (apart from $ kubectl port-forward which I will address later) due to lack of certain field in your manifest.

The minimal example that should be exposable with Services:

apiVersion: v1
kind: Pod
metadata:
  name: kube-nginx
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx

I do also think that you should be using other Kubernetes objects like for example Deployment:

• Kubernetes.io: Docs: Concepts: Workloads: Controllers: Deployment

Also you haven’t added anything to your manifest to force the Pod to be scheduled on the k8smaster. It could be scheduled on k8snode01. You can check on which Node your Pod is running by:

• $ kubectl get pods/kube-nginx -o wide

NAME         READY   STATUS    RESTARTS   AGE   IP         --> NODE <--        NOMINATED NODE   READINESS GATES
kube-nginx   1/1     Running   0          84m   10.32.2.7  --> raven-6k6m  <--  <none>           <none>

See the Node column.

$ kubectl port-forward ...

Coming onto the topic of kubectl port-forward pod/kube-nginx 10086:80 command. This is a guess but I think the interpretation is that it will permanently expose the kube-nginx Pod on port: 10086 on a host that ran this command. Yes, it will expose your Pod but in this setup only on localhost and it will run as long as the command is running. To expose your workload you should be using earlier mentioned Services. If you want to expose your Pod with $ kubectl port-forward you should use the command as user @Phillipe pointed:

• kubectl port-forward --address 0.0.0.0 pod/kube-nginx 10086:80

The --address 0.0.0.0 will allow incoming connections from your LAN (assuming no firewall dropping the requests).

Citing another answer from Stackoverflow.com:

kubectl port-forward makes a specific Kubernetes API request. That means the system running it needs access to the API server, and any traffic will get tunneled over a single HTTP connection.

Having this is really useful for debugging (if one specific pod is acting up you can connect to it directly; in a microservice environment you can talk to a back-end service you wouldn’t otherwise expose) but it’s not an alternative to setting up service objects. When I’ve worked with kubectl port-forward it’s been visibly slower than connecting to a pod via a service, and I’ve found seen the command just stop after a couple of minutes. Again these aren’t big problems for debugging, but they’re not what I’d want for a production system.

— Stackoverflow.com: Answer: How kubectl port-forward works

Working example

Assuming that your cluster is configured correctly as there are no steps in the question about the cluster provisioning process, you could use following example to expose your kube-nginx Pod to the external sources.

apiVersion: v1
kind: Pod
metadata:
  name: kube-nginx
  labels: 
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx
---
apiVersion: v1
kind: Service
metadata:
  name: kube-nginx-service
spec:
  selector:
    app: nginx # <-- this needs to match .metadata.labels field in Pod
  type: NodePort
  ports:
    - protocol: TCP
      port: 80 # <-- port inside of the cluster 
      targetPort: 80 # <-- port that app is listening on
      nodePort: 30080 # <-- from 30000 to 32767 on the node (can be changed) 

By this example you will spawn a Pod with nginx image and allow the connections on port: 30080 on each Node to reach the Pod(i.e. $ curl 192.168.0.114:30080).

Service of type LoadBalancer is also possible with it’s External IP allocation but due to the lack of information on the Kubernetes setup, it could be hard to point to the right solution (on-premises=metallb, otherwise consult the provider documentation).

I also encourage you to check the following documentation to get more reference/best practices etc.:

• Kubernetes.io: Docs: Concepts: Configuration: Overview
• Kubernetes.io: Docs: Concepts: Architecture