Services

Question 1

What do Kubernetes Sevices do?

Answer 1

• enable communication between various components within and outside of the application
• help connect application to other applications or users
• enable loose coupling between microservices within our application

I.e helps when:
- making frontend available to customers
- connecting backend and frontend
- connecting to external data sources

Question 2

What is the Kubernetes Service?

Answer 2

• an object, just like pods, replicaSet or deployments

Question 3

What is a Usecase of a Kubernetes Service?

Answer 3

• listen to a port on the node and forward requests on that port to a port on the pod, running the web application
• known as a Node Port Service

Question 4

What kind of Service Types exist?

Answer 4

• NodePort Service: service makes an internal port accessible on a port on the node
• ClusterIp: service creates a virtual IP inside the cluster to enable communicaiton between different services
• Load Balancer: provisions a load balancer for our application in supported cloud providers

Question 5

How many and which ports are involved in the NodePort service?

Answer 5

In total 3:
1. Target port: port on the pod, where service is running: 80
2. Referred to as ‘Port’: Port of the service itself, like a virtual server inside the node, has its own IP address inside the cluster (cluster IP of the service)
3. NodePort: Port on the node itself, which we use to access the web server externally, can only be in a valid range, by default 30000 to 32767

Question 6

How do we create a Service?

Answer 6

Yaml, same as other objects.

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
	labels:
spec:
  type: NodePort
	ports:
	  - targetPort: 80
	    port: 80
			nodePort: 30008
	selector:
	  app: myapp
		type: frontend
			

Question 7

What happens, if for a NodePort service, no nodePort is provided in the yaml?

Answer 7

Free port in the valid range is provided

Question 8

In a NodePort, what port is mandatory?

Answer 8

Only ‘port’, of the service

Question 9

In a NodePort, what happens if we don’t provide a target port?

Answer 9

Assumed to be the same as the port of service

Question 10

How many port mappings can be part of a NodePort?

Answer 10

• one to multiple mappings can be provided

Question 11

How do we specify, to which pod a NodePort service should connect to?

Answer 11

• using labels and selectors
• label of the pod must be used in selector in NodePort

Question 12

How do we create a service?

Answer 12

‘kubectl creat -f service-definition.yaml’

Question 13

Once we set up a NodePort, how can we connect to it?

Answer 13

‘curl http://< ip of the node>:< node-port>

Question 14

What kind of algorithm uses the nodePort service and for what?

Answer 14

• Random Algorithm
• to distribute requests to multiple pods, managed by the service
• acts as a built-in load-balancer to distribute load across different parts
• has SessionAffinity

Question 15

What happends when the pods, connected via one service are spread on multiple nodes?

Answer 15

• when a Service in Kubernetes is created it spans across all the nodes in the cluster and maps the target port to the same NodePort on all nodes in the cluster
• using any node-ip with the same NodePort for connecting to the pod

Question 16

What are shortcuts for the api-resources?

Answer 16

pod: pod
replicaset: rs
deployment: deploy
service: svc

Question 17

What can a ClusterIP do?

Answer 17

• provide a single interface for pods to connect to pods in another group
• groups of pods can be connected so that requests from one group to the other can be forwarded to random instances in the target group
• each layer can now scale or move as required without impacting communication between various services
• each services get an IP and a name assigned to it
• that name should be used by other parts to access the service

Question 18

How is a ClusterIP service created?

Answer 18

Yaml as always.

apiVersion: v1
kind: Service
metadata:
  name: backend
spec:
  type: ClusterIP
	ports: 
	  - targetPort: 80
	    port: 80
	selector:
	  app: myapp
		type: backend

ClusterIP is the default Type for service, if not specified explicitly
TargetPort is the port where the backend is exposed.
Port is where the service is exposed

Question 19

Using a NodePort, would the used port still work if used with a node where the exposed pod-application is not running?

Answer 19

Yes, by accessing the port, even on a node, where the application is not running, the nodePort service routes the request to a node, where it is running, as it spans all nodes

Question 20

How can we achieve that the end user does not have to use the node-ip with the exposed port ip but a simple name instead?

Answer 20

Multiple possibilities. One way:
- cloud providers have native load balancers for their platforms
- Kubernetes has support for integrating with the native load balancers of certain cloud providers

Question 21

How does a load balancer yaml look like?

Answer 21

apiVersion: v1
kind: Service
metadata: 
  name: myapp-service
spec: 
  type: LoadBalancer
	ports:
	  - targetPort: 80
	    port: 80
			nodePort: 30008

Only works with supported type platforms: GCP, AWS, Azure
If used elsewhere it work similiar to NodePort, not doing any kind of external load balancing configuration

Question 22

With what command can we create a ClusterIP service for a pod, specifying the port?

Answer 22

kubectl expose pod redis –port=6379 –name redis-service –dry-run=client -o yaml

Question 23

When is a Service required?

Answer 23

• only required, when the app/pod has some kind of process/service/database that needs to be exposed
• i.e. a worker, that only copies values from a in-mem database into a relational database does not need a service