kubernetes Practice 2

1. Sample message boards deployed on Kubernetes

This scenario illustrates how to use Kubernetes and Docker to launch a simple, multitier Web application. The Guestbook sample application stores visitor's notes in Redis through JavaScript API calls. Redis contains a master (for storage) and a set of replicated redis'slaves'.

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

Tags: Java Docker Kubernetes

Posted on Sun, 07 Nov 2021 11:45:39 -0500 by haydndup