kubernetes Practice 2

1. Sample message boards deployed on Kubernetes

1.1 Check Cluster

controlplane $ kubectl cluster-info Kubernetes master is running at https://172.17.0.29:6443 KubeDNS is running at https://172.17.0.29:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'. controlplane $ kubectl get nodes NAME STATUS ROLES AGE VERSION controlplane Ready master 2m57s v1.14.0 node01 Ready <none> 2m31s v1.14.0

1.2 Create rc

controlplane $ cat redis-master-controller.yaml apiVersion: v1 kind: ReplicationController metadata: name: redis-master labels: name: redis-master spec: replicas: 1 selector: name: redis-master template: metadata: labels: name: redis-master spec: containers: - name: master image: redis:3.0.7-alpine ports: - containerPort: 6379

Establish

controlplane $ kubectl create -f redis-master-controller.yaml replicationcontroller/redis-master created controlplane $ kubectl get rc NAME DESIRED CURRENT READY AGE redis-master 1 1 0 2s controlplane $ kubectl get pods NAME READY STATUS RESTARTS AGE redis-master-2j4qm 1/1 Running 0 4s

1.3 Redis Master Service

The second part is service. The Kubernetes service is a named load balancer that proxies traffic to one or more containers. The proxy works even if the container is on a different node.

Service proxies communicate within clusters and rarely expose ports to external interfaces.

When you start the service, it appears that you cannot connect using curl or netcat unless you start it as part of Kubernetes. The recommended method is to use the LoadBalancer service to handle external communications.]

controlplane $ cat redis-master-service.yaml apiVersion: v1 kind: Service metadata: name: redis-master labels: name: redis-master spec: ports: # the port that this service should serve on - port: 6379 targetPort: 6379 selector: name: redis-master

Establish

controlplane $ kubectl create -f redis-master-service.yaml service/redis-master created controlplane $ kubectl get services NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 6m58s redis-master ClusterIP 10.111.64.45 <none> 6379/TCP 1s controlplane $ kubectl describe services redis-master Name: redis-master Namespace: default Labels: name=redis-master Annotations: <none> Selector: name=redis-master Type: ClusterIP IP: 10.111.64.45 Port: <unset> 6379/TCP TargetPort: 6379/TCP Endpoints: 10.32.0.193:6379 Session Affinity: None Events: <none>

1.4 rc slave Pod

In this example, we will run Redis Slaves, which will copy data from the master. For more details on Redis replication, visit http://redis.io/topics/replication

As mentioned earlier, the controller defines how the service operates. In this example, we need to determine how the service discovers other pod s. YAML will GET_ HOSTS_ The FROM attribute is represented as DNS. You can change it to use environment variables in yaml, but this introduces a creation order dependency because you need to run the service to define environment variables.
In this case, we will use image:kubernetes/redis-slave:v2 to launch two instances of pod. It will link to redis-master through DNS.

controlplane $ cat redis-slave-controller.yaml apiVersion: v1 kind: ReplicationController metadata: name: redis-slave labels: name: redis-slave spec: replicas: 2 selector: name: redis-slave template: metadata: labels: name: redis-slave spec: containers: - name: worker image: gcr.io/google_samples/gb-redisslave:v1 env: - name: GET_HOSTS_FROM value: dns # If your cluster config does not include a dns service, then to # instead access an environment variable to find the master # service's host, comment out the 'value: dns' line above, and # uncomment the line below. # value: env ports: - containerPort: 6379

Execution:

controlplane $ kubectl create -f redis-slave-controller.yaml replicationcontroller/redis-slave created controlplane $ kubectl get rc NAME DESIRED CURRENT READY AGE redis-master 1 1 1 4m29s redis-slave 2 2 2 3s

1.5 Redis slave service

As before, we need to make incoming requests accessible to our slaves. This is done by starting a service that knows how to communicate with redis-slave.

Since we have two replicated pods, the service will also provide load balancing between the two nodes.

controlplane $ cat redis-slave-service.yaml apiVersion: v1 kind: Service metadata: name: redis-slave labels: name: redis-slave spec: ports: # the port that this service should serve on - port: 6379 selector: name: redis-slave

Execution:

controlplane $ kubectl create -f redis-slave-service.yaml controlplane $ kubectl get services NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 14m redis-master ClusterIP 10.111.64.45 <none> 6379/TCP 7m13s redis-slave ClusterIP 10.109.135.21 <none> 6379/TCP 41s

1.6 Front End rc

Now that the data service is started, we can deploy the Web application. The pattern for deploying a Web application is the same as the pod we deployed earlier. YAML defines a service named frontend that uses images_ gcr.io/google samples/gb-frontend:v3. The replication controller ensures that the three Pods always exist.

controlplane $ cat frontend-controller.yaml apiVersion: v1 kind: ReplicationController metadata: name: frontend labels: name: frontend spec: replicas: 3 selector: name: frontend template: metadata: labels: name: frontend spec: containers: - name: php-redis image: gcr.io/google_samples/gb-frontend:v3 env: - name: GET_HOSTS_FROM value: dns # If your cluster config does not include a dns service, then to # instead access environment variables to find service host # info, comment out the 'value: dns' line above, and uncomment the # line below. # value: env ports: - containerPort: 80

implement

controlplane $ kubectl create -f frontend-controller.yaml replicationcontroller/frontend created controlplane $ kubectl get rc NAME DESIRED CURRENT READY AGE frontend 3 3 1 2s redis-master 1 1 1 20m redis-slave 2 2 2 15m controlplane $ kubectl get pods NAME READY STATUS RESTARTS AGE frontend-bkcsj 1/1 Running 0 3s frontend-ftjrk 1/1 Running 0 3s frontend-jnckp 1/1 Running 0 3s redis-master-2j4qm 1/1 Running 0 20m redis-slave-79w2b 1/1 Running 0 15m redis-slave-j8zqj 1/1 Running 0 15m

PHP code uses HTTP and JSON to communicate with Redis. When a value is set, the request goes to redis-master, and the data read comes from the redis-slave node.

1.7 Guestbook Frontend Service

In order for the front end to be accessible, we need to start a service to configure the proxy.
YAML defines a service as NodePort. NodePort allows you to set well-known ports that are shared across the cluster. This is like -p 80:80 in Docker.

In this case, we define our Web application to run on port 80, but we will expose the service on 30080.

controlplane $ cat frontend-service.yaml apiVersion: v1 kind: Service metadata: name: frontend labels: name: frontend spec: # if your cluster supports it, uncomment the following to automatically create # an external load-balanced IP for the frontend service. # type: LoadBalancer type: NodePort ports: # the port that this service should serve on - port: 80 nodePort: 30080 selector: name: frontend controlplane $ kubectl create -f frontend-service.yaml service/frontend created controlplane $ kubectl get services NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE frontend NodePort 10.105.214.152 <none> 80:30080/TCP 2s kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 28m redis-master ClusterIP 10.111.64.45 <none> 6379/TCP 21m redis-slave ClusterIP 10.109.135.21 <none> 6379/TCP 15m

1.8 Access Guestbook Frontend

Once all the controllers and services are defined, Kubernetes will start starting them as Pods. Depending on what happens, Pods can have different states. For example, if the Docker image is still downloading, the Pod will be suspended because it cannot start. When ready, the status changes to running.

View Pod Status

controlplane $ kubectl get pods NAME READY STATUS RESTARTS AGE frontend-bkcsj 1/1 Running 0 4m55s frontend-ftjrk 1/1 Running 0 4m55s frontend-jnckp 1/1 Running 0 4m55s redis-master-2j4qm 1/1 Running 0 24m redis-slave-79w2b 1/1 Running 0 20m redis-slave-j8zqj 1/1 Running 0 20m

Find Node Port

controlplane $ kubectl describe service frontend | grep NodePort Type: NodePort NodePort: <unset> 30080/TCP

View user interface
Once Pod is running, you will be able to view the UI through port 30080. Use URL to view page https://2886795293-30080-elsy05.environments.katacoda.com

Behind the scenes, the PHP service discovers Redis instances through DNS. You have now deployed an effective multi-tier application on Kubernetes.

2. Network Introduction

Kubernetes has advanced network capabilities that allow Pod and services to communicate within and outside the cluster network.

In this scenario, you'll learn the following types of Kubernetes services.

• Cluster IP
• Target Port
• Node Port
• External IP
• Load Balancer

The Kubernetes Service is an abstraction that defines how to access a set of Pods. The Pod set accessed through the Service is based on the label selector.

2.1 Cluster IP

Add new comment

0 comments