Testing locally k8s distributed system

Question

I'm new to k8s and I'm trying to build a distributed system. The idea is that a stateful pod will be spawened for each user.

Main services are two Python applications MothershipService and Ship . MothershipService's purpose is to keep track of ship-per-user, do health checks, etc. Ship is running some (untrusted) user code.

MothershipService           Ship-user1
|              | ---------- |        |---vol1
|..............| -----.     |--------|
                       \    
                        \   Ship-user2
                         '- |        |---vol2
                            |--------|

I can manage fine to get up the ship service

> kubectl get all -o wide
NAME           READY   STATUS    RESTARTS   AGE   IP            NODE       NOMINATED NODE   READINESS GATES
pod/ship-0     1/1     Running   0          7d    10.244.0.91   minikube   <none>           <none>

NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE   SELECTOR
service/ship         ClusterIP   None         <none>        8000/TCP   7d    app=ship
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP    7d    <none>

NAME                      READY   AGE   CONTAINERS   IMAGES
statefulset.apps/ship     1/1     7d    ship       ship

My question is how do I go about testing this via curl or a browser? These are all backend services so NodePort seems not the right approach since none of this should be accessible to the public. Eventually I will build a test-suite for all this and deploy on GKE.

ship.yml (pseudo-spec)

kind: Service
metadata:
  name: ship
spec:
  ports:
  - port: 8000
    name: ship
  clusterIP: None  # headless service
  ..

---

kind: StatefulSet
metadata:
  name: ship
spec:
  serviceName: "ship"
  replicas: 1
  template:
    spec:
      containers:
      - name: ship
        image: ship
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8000
          name: ship
  ..

Answer 1

One possibility is to use the kubectl port-forward command to expose the pod port locally on your system. For example, if I'm use this deployment to run a simple web server listening on port 8000:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: example
  name: example
spec:
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - args:
        - --port
        - "8000"
        image: docker.io/alpinelinux/darkhttpd
        name: web
        ports:
        - containerPort: 8000
          name: http

I can expose that on my local system by running:

kubectl port-forward deploy/example 8000:8000

As long as that port-forward command is running, I can point my browser (or curl ) at http://localhost:8000 to access the service.

---

Alternately, I can use kubectl exec to run commands (like curl or wget ) inside the pod:

kubectl exec -it web -- wget -O- http://127.0.0.1:8000

Answer 2

Example process on how to create a Kubernetes Service object that exposes an external IP address:

**Creating a service for an application running in five pods: **

Run a Hello World application in your cluster:

 kubectl run hello-world --replicas=5 --labels="run=load-balancer-example" --image=gcr.io/google-samples/node-hello:1.0  --port=8080

The preceding command creates a Deployment object and an associated ReplicaSet object. The ReplicaSet has five Pods, each of which runs the Hello World application.

Display information about the Deployment:

 kubectl get deployments hello-world
 kubectl describe deployments hello-world

Display information about your ReplicaSet objects:

 kubectl get replicasets
 kubectl describe replicasets

Create a Service object that exposes the deployment:

 kubectl expose deployment hello-world --type=LoadBalancer --name=my-service

Display information about the Service:

 kubectl get services my-service

The output is similar to this:

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
 my-service   10.3.245.137   104.198.205.71   8080/TCP   54s

Note: If the external IP address is shown as, wait for a minute and enter the same command again.

Display detailed information about the Service:

kubectl describe services my-service The output is similar to this:

Name:           my-service
 Namespace:      default
 Labels:         run=load-balancer-example
 Selector:       run=load-balancer-example
 Type:           LoadBalancer
 IP:             10.3.245.137
 LoadBalancer Ingress:   104.198.205.71
 Port:           <unset> 8080/TCP
 NodePort:       <unset> 32377/TCP
 Endpoints:      10.0.0.6:8080,10.0.1.6:8080,10.0.1.7:8080 + 2 more...
 Session Affinity:   None

Events: Make a note of the external IP address exposed by your service. In this example, the external IP address is 104.198.205.71. Also note the value of Port. In this example, the port is 8080.

In the preceding output, you can see that the service has several endpoints: 10.0.0.6:8080,10.0.1.6:8080,10.0.1.7:8080 + 2 more. These are internal addresses of the pods that are running the Hello World application. To verify these are pod addresses, enter this command:

 kubectl get pods --output=wide

The output is similar to this:

NAME                         ...  IP         NODE
 hello-world-2895499144-1jaz9 ...  10.0.1.6   gke-cluster-1-default-pool-e0b8d269-1afc
 hello-world-2895499144-2e5uh ...  0.0.1.8    gke-cluster-1-default-pool-e0b8d269-1afc
 hello-world-2895499144-9m4h1 ...  10.0.0.6   gke-cluster-1-default-pool-e0b8d269-5v7a
 hello-world-2895499144-o4z13 ...  10.0.1.7   gke-cluster-1-default-pool-e0b8d269-1afc
 hello-world-2895499144-segjf ...  10.0.2.5   gke-cluster-1-default-pool-e0b8d269-cpuc

Use the external IP address to access the Hello World application:

curl http://<external-ip>:<port>

where <external-ip> is the external IP address of your Service, and <port> is the value of Port in your Service description.

The response to a successful request is a hello message:

 Hello Kubernetes!

Please refer to How to Use external IP in GKE and Exposing an External IP Address to Access an Application in a Cluster for more information.