K8S on Jalen's blog

K8S Notes 9: Kubernetes Command Summary

Mon, 18 Jan 2021 17:55:00 +0800

After working through the previous articles, you should now have a basic understanding of Kubernetes. Below is a summary of some basic Kubernetes commands.

Cluster-related commands

1
2
3
4


# View cluster information
$ kubectl cluster-info
Kubernetes master is running at https://192.168.233.128:6443
KubeDNS is running at https://192.168.233.128:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

Node-related commands

1
2
3
4
5


# View all nodes
kubectl get nodes

# View detailed node information
kubectl describe node名称

Deployment-related commands

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# Create a deployment
kubectl create -f 部署yml文件

# Update the deployment configuration. For the initial deployment, this command is equivalent to kubectl create
kubectl apply -f 部署yml文件

# View existing deployments
kubectl get deployment

# Delete a deployment
kubectl delete deployment 部署名称

# View detailed deployment information
kubectl describe deployment 部署名称

# Perform a rolling scale-up. For example, increase the number of replicas to 8
kubectl scale --replicas=8 deployment/deployment名称

# Edit the deployment directly and update the manifest using Vim
kubectl edit deployment/deployment名称

# Restart a deployment
kubectl rollout restart deploy 部署名称 [-n namespace名称]

Service-related commands

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Create a service and update its configuration in the same way as a deployment
# View existing services
kubectl get service
kubectl get svc

# Delete a service
kubectl delete service service名称

# View detailed service information
kubectl describe service service名称

Pod-related commands

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# View deployed Pods
kubectl get pod [-o wide]

# View detailed Pod information
kubectl describe pod pod名称

# View Pod logs; -f enables real-time updates
kubectl logs [-f] pod名称

# Enter a Pod container
kubectl exec -it pod名称 /bin/bash

NFS file sharing-related commands

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# When using NFS file sharing, verify that the file share was created successfully
exportfs

# On the host of a worker node, check whether the primary node's NFS file share is accessible
showmount -e 192.168.233.128

# Mount command for worker nodes
mount 192.168.233.128:/usr/local/data/www-data /mnt

# Automatically mount after a worker node restarts
# Add the following configuration to /etc/fstab
192.168.233.128:/usr/local/data/www-data /mnt nfs defaults 0 0

K8S Notes 8: Deploying the Pigeon Baby & Child Store with K8S

Mon, 18 Jan 2021 09:47:00 +0800

After studying the previous articles, we now have a basic understanding of how to deploy an application, create shared storage, implement load balancing through services, and expose services externally through Renetd. Next, we will move on to a practical exercise: deploying the Pigeon Store, an e-commerce web application developed with Spring Boot.

Deployment Topology

From this topology diagram, we can see that:

The shared storage area on the master node contains database scripts used to initialize the MySql database, which is deployed in a pod.
The MySql service is exposed within the cluster through the beiqin-db-service service.
The web service, developed with Spring Boot, is deployed using the openjdk:8u222 base image, and the container exposes port 80.
The Pigeon Store application is exposed externally through the beiqin-app-service service, also on port 80.
Renetd is used to map the host IP to the virtual IP of the beiqin-app-service service, ultimately making the service accessible from outside the cluster.

Deploying the Pigeon Store

Deployment Resources

We will place the deployment scripts, service JAR package, MySQL script files, and other resources in the /usr/local/data/www-data/beiqin/ directory.

Here, /usr/local/data/www-data/ is the shared storage area configured in the previous article.

The following are all the resource files required to deploy the Pigeon Store application. We will create and deploy them one by one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[root@master www-data]# tree beiqin
beiqin
├── beiqin-app-deploy.yml # Web applies deployment script files
├── beiqin-app-service.yml # Web Application Service Deployment Script File
├── beiqin-db-deploy.yml # Mysql deploys script files
├── beiqin-db-service.yml # Mysql Service Deployment Script File
├── dist
│   ├── application.yml # Application Profile
│   └── beiqin-app.jar # Spring-boot developed application jar package, which can run directly in openjdk containers
└── sql
 └── beiqin.sql # Mysql script file

Deploying the Pigeon Store

Here, we will reuse the configuration from K8S Notes 5: NFS-Based Cluster File Sharing, mounting the master node’s /usr/local/data/www-data/ directory to the /mnt directory on the node host. The details will not be repeated here.

2. Deploy and Initialize the Database

2.1 Create the `beiqin-db-deploy.yml` File

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


apiVersion: apps/v1beta1  # New version of k8s, version number.
kind: Deployment  # Script Type: Create Deployment
metadata:
 name: beiqin-db-deploy  # Name of deployment
spec:
 replicas: 1 # The number of copies, because it's mysql, only one.
 template:
 metadata:
 labels:
 app: beiqin-db-deploy  # Pod tag
 spec:
 volumes: # Create Mount Volume
 - name: beiqin-db-volume  # Mount Volume Name
 hostPath: 
 path: /mnt/beiqin/sql # Mount path (the path of the data volume on the Node host)
 containers:
 - name: beiqin-db-deploy
 image: mysql:5.7  # Use mirror: Mysql: 5.7
 ports:
 - containerPort: 3306 # Port number of container to cluster exposure: 3306
 env: # Note: env is a previously unconfigured environmental variable for containers
 - name: MYSQL_ROOT_PASSWORD  # Environmental variable 1: Mysql root password
 value: "root" # The value of the environment variable. Note the string.
 volumeMounts: # Can not open message
 - name: beiqin-db-volume
 mountPath: /docker-entrypoint-initdb.d  # Mount path, mount to this directory and automatically load the sql script file in the container when it starts

2.2 Deploy MySQL to the Cluster

1
2


# cd /usr/local/data/www-data/beiqin
$ kubectl create -f beiqin-db-deploy.yml

2.3 Check the Deployment Status

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


# View deployed pops
$ kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
beiqin-db-deploy-757d87dc77-g5wrf 1/1 Running 0 5m17s 10.244.1.12 node1 <none> <none>

# Go inside the pod container and see if mysql can log in and & execute scripts to create databases and tables
$ kubectl exec -it beiqin-db-deploy-757d87dc77-g5wrf /bin/bash

# Inside the container, login mesql
$ mysql -uroot -proot
# View the database and find that it has been created
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| beiqin |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 rows in set (0.06 sec)

# View the table and find it already created
mysql> use beiqin;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;
+---------------------+
| Tables_in_beiqin |
+---------------------+
| t_category |
| t_evaluate |
| t_goods |
| t_goods_cover |
| t_goods_detail |
| t_goods_param |
| t_promotion_seckill |
+---------------------+
7 rows in set (0.00 sec)

2.4 Edit the Database Service Script

Create beiqin-db-service.yml. This script is much simpler than the deployment script.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


apiVersion: v1
kind: Service # Type: Services
metadata:
 name: beiqin-db-service # Name of service
 labels: # The service is also a special pod that needs to be configured.
 app: beiqin-db-service
spec:
 selector: # Select associated pop tag, which is the db deployment pop created in the previous step
 app: beiqin-db-deploy
 ports:
 - port: 3310 # Service external exposure port, outside container, inside cluster
 targetPort: 3306 # Port within service container

2.5 Deploy the Service

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


$ kubectl create -f beiqin-db-service.yml
# Kubecl get svc and kubecl get service fully equivalent
$ kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
beiqin-db-service ClusterIP 10.107.5.137 <none> 3310/TCP 7s
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 27h
# Here we can see that the service's virtual IP is 10.107.5.137 and the external exposure port is 3310 (outside pod, inside the cluster)

# See more details about the service
$ kubectl describe svc beiqin-db-service
Name: beiqin-db-service
Namespace: default
Labels: app=beiqin-db-service
Annotations: <none>
Selector: app=beiqin-db-deploy
Type: ClusterIP
IP: 10.107.5.137 # Virtual IP
Port: <unset> 3310/TCP # Externally exposed port
TargetPort: 3306/TCP # Destination Port
Endpoints: 10.244.1.12:3306 # Associated pod virtual IPs and port numbers. 10.244.1.12 is the virtual IP for db deployment pops initiated.
Session Affinity: None
Events: <none>

3. Deploy the Web Application and Initialize the Service

3.1 Create the Deployment Script

Edit the beiqin-app-deploy.yml file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


apiVersion: apps/v1beta1
kind: Deployment
metadata:
 name: beiqin-app-deploy
spec:
 replicas: 2 # Number of copies: 2
 template:
 metadata:
 labels:
 app: beiqin-app-deploy
 spec:
 volumes:
 - name : beqin-app-volume
 hostPath:
 path: /mnt/beiqin/dist # Mount directory of the data host to store the jar package and application configuration
 containers:
 - name: beiqin-app-deploy
 image: openjdk:8u222-jre  # Portable mirror, using openjdk:8u222-jre
 command: ["/bin/sh"] # Note: Herecommand indicates the direction of the container when activated, and here the shell command.
 args: ["-c","cd /usr/local/beiqin/dist;java -jar beiqin-app.jar"] # Command Parameters
 volumeMounts:
 - name: beqin-app-volume
 mountPath: /usr/local/beiqin/dist # Table of contents mounted in containers

3.2 Create the Deployment

1
2
3
4
5
6
7


$ kubectl create -f beiqin-app-deploy.yml
deployment.apps/beiqin-app-deploy created
$ kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
beiqin-app-deploy-5958f57879-n9p9b 1/1 Running 0 75s 10.244.2.17 node2 <none> <none>
beiqin-app-deploy-5958f57879-nfs8s 1/1 Running 0 75s 10.244.1.19 node1 <none> <none>
beiqin-db-deploy-757d87dc77-g5wrf 1/1 Running 2 2d19h 10.244.1.17 node1 <none> <none>

3.3 Create the Service

Edit the service script and add the following content:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


$ vim beiqin-app-service.yml
apiVersion: v1
kind: Service
metadata:
 name: beiqin-app-service
 labels:
 app: beiqin-app-service
spec:
 selector:
 app: beiqin-app-deploy
 ports:
 - port: 80
 targetPort: 80

Create the service in the cluster:

1
2
3
4
5
6
7
8


$ kubectl create -f beiqin-app-service.yml 
service/beiqin-app-service created
# View service pod status
$ kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
beiqin-app-service ClusterIP 10.97.138.238 <none> 80/TCP 58s
beiqin-db-service ClusterIP 10.107.5.137 <none> 3310/TCP 2d19h
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 3d22h

At this point, the Pigeon Store has been fully deployed to the cluster environment. We can see that the service’s virtual IP is 10.97.138.238. We can now verify whether port 80 on this service IP is accessible.

3.4 Verify the Service

1

$ curl http://10.97.138.238/goods?gid=1791

4. Expose the Service Externally Using Rinetd

1
2
3


$ vim /etc/rinetd.conf
0.0.0.0 80 10.97.138.238 80
$ rinetd -c /etc/rinetd.conf

Finally, we successfully accessed the service locally through the IP address of the virtual machine’s master node.

K8S Notes 4: Deploying a Tomcat Cluster with Deployment

Fri, 15 Jan 2021 09:47:00 +0800

In the previous article, we introduced how to deploy a Tomcat cluster using the Dashboard’s graphical interface. However, in an actual cluster environment, we usually deploy the cluster by writing Deployment scripts.

Deployment

Deployment refers to the process in which Kubernetes sends instructions to Node nodes to create containers.
Kubernetes supports deployment scripts in yml format.
The deployment command is as follows:

1

kubectl create -f [部署yml脚本文件] # Create Deployment

Basic Deployment Script Format

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


apiVersion: extensions/v1beta1  # Api's version number
kind: Deployment  # The "type" of the current script indicates deployment; Service means service; Pod means Pod script
metadata: # Metadata, mainly used to configure basic information on currently deployed scripts
 name: tomcat-deploy  # Name of current deployment
spec: # Detailed definition information
 replicas: 2 # Number of copies deployed, that's a few pops.
 template: # Deployment template information
 metadata: # Deployment of metadata for templates
 labels: # Pod tag
 app: tomcat-cluster  # Custom labels are specified here
 spec: # Details of the template
 containers: # Container information
 - name: tomcat-cluster  # Name of container
 image: tomcat:latest  # Mirror of the container. Here's the latest version of Tomcat.
 ports:
 - containerPort: 8080 # Port for external exposure of containers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# Create Deployment
kubectl create -f 部署yml文件

# Update deployment configuration, if first deployed, this command is equivalent to kubectl profile
kubectl apply -f 部署yml文件

# View deployed pop
kubectl get pod [-o wide]

# View Pod Details
kubectl describe pod pod名称

# See if pop output log -f is updated in real time
kubectl logs [-f] pod名称

# View created deployments
kubectl get deployment

# Delete a deployment
kubectl delete deployment 部署名称

Manually Deploying a Tomcat Cluster

Here, we store all deployment scripts in the /usr/local/k8s/tomcat-deploy directory. You can also create your own directory for storing deployment scripts.

Create the directory

1
2


$ mkdir /usr/local/k8s/tomcat-deploy
$ cd /usr/local/k8s/tomcat-deploy

Write the deployment script

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


$ vim tomcat-deployment.yml
# Enter the following content
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
 name: tomcat-deploy
spec:
 replicas: 2
 template:
 metadata:
 labels:
 app: tomcat-cluster
 spec:
 containers:
 - name: tomcat-cluster
 image: tomcat:latest
 ports:
 - containerPort: 8080

Deploy the Tomcat cluster

1
2


$ kubectl create -f tomcat-deploy.yml
deployment.extensions/tomcat-deploy created

View the deployed pods

1
2
3
4


[root@master tomcat-deploy]# kubectl get pods
NAME READY STATUS RESTARTS AGE
tomcat-deploy-5fd4fc7ddb-7vw4f 1/1 Running 0 98s
tomcat-deploy-5fd4fc7ddb-t4wvp 1/1 Running 0 98s

We can see that two pod have been started, and both are in the Running state. These two pod are deployed on node1 and node2, respectively.

At this point, the Tomcat cluster has been deployed. We can use the kubectl describe pod [pod-name] command to view detailed information about the pod deployment.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


$ kubectl describe pod tomcat-deploy-5fd4fc7ddb-7vw4f
Name: tomcat-deploy-5fd4fc7ddb-7vw4f
Namespace: default
Priority: 0
PriorityClassName: <none>
Node: node1/192.168.233.129
Start Time: Fri, 15 Jan 2021 11:43:22 +0800
Labels: app=tomcat-cluster
 pod-template-hash=5fd4fc7ddb
Annotations: <none>
Status: Running
IP: 10.244.1.7
Controlled By: ReplicaSet/tomcat-deploy-5fd4fc7ddb
Containers:
 tomcat-cluster:
 Container ID: docker://fa36632bdf28f58e1ad61dee3c93da88df348d3a98c34531d4b6fa12a73a18f8
 Image: tomcat:latest
 Image ID: docker-pullable://tomcat@sha256:94cc18203335e400dbafcd0633f33c53663b1c1012a13bcad58cced9cd9d1305
 Port: 8080/TCP
 Host Port: 0/TCP
 State: Running
 Started: Fri, 15 Jan 2021 11:43:38 +0800
 Ready: True
 Restart Count: 0
 Environment: <none>
 Mounts:
 /var/run/secrets/kubernetes.io/serviceaccount from default-token-fkln2 (ro)
Conditions:
 Type Status
 Initialized True 
 Ready True 
 ContainersReady True 
 PodScheduled True 
Volumes:
 default-token-fkln2:
 Type: Secret (a volume populated by a Secret)
 SecretName: default-token-fkln2
 Optional: false
QoS Class: BestEffort
Node-Selectors: <none>
Tolerations: node.kubernetes.io/not-ready:NoExecute for 300s
 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
 Type Reason Age From Message
 ---- ------ ---- ---- -------
 Normal Scheduled 4m1s default-scheduler Successfully assigned default/tomcat-deploy-5fd4fc7ddb-7vw4f to node1
 Normal Pulling 4m kubelet, node1 Pulling image "tomcat:latest"
 Normal Pulled 3m45s kubelet, node1 Successfully pulled image "tomcat:latest"
 Normal Created 3m45s kubelet, node1 Created container tomcat-cluster
 Normal Started 3m45s kubelet, node1 Started container tomcat-cluster

Accessing the Tomcat Cluster Externally Using NodePort

We deployed an tomcat cluster above, but this cluster can only be accessed from within the cluster. How can we expose tomcat for external access? Looking back at our Deployment deployment script, we can see the following two lines:

1
2
3


# Tomcat-deploy.yml files
ports:
 - containerPort: 8080

We only set the container’s exposed port to 8080, without configuring any settings for external access.

As shown below, we can deploy a Service. This Service is also a pod and has its own virtual IP address and port. The service pod is deployed on the master node. When an external request arrives, it is first sent to port 8000 of the service and then distributed to the two Tomcat containers according to the load-balancing rules. The service here can be understood as a load balancer on the K8S cluster.

Creating a Tomcat Service

Create the script

Similar to deploying Deployment, we create a service script file in the /usr/local/k8s/tomcat-service/ directory.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


$ cd /usr/local/k8s/tomcat-service
$ vim tomcat-service.yml
apiVersion: v1 # Version
kind: Service # Deployment type: Service
metadata: # Metadata
 name: tomcat-service # The service name is tomcat-service
 labels: # Pod labels (because a service is also a pod)
 app: tomcat-service # Custom label name: tomcat-service
spec: # Detailed configuration
 type: NodePort # Set the service type to NodePort, meaning that a port will be opened and mapped to the Tomcat container
 selector: # Selector used to select the pods to which this service will bind by label
 app: tomcat-cluster # Select pods with the tomcat-cluster label, namely the Tomcat pods deployed in the previous step
 ports: # Port configuration
 - port: 8000 # Port on which the current service receives data
 targetPort: 8080 # Target port, which points to the port of the child Tomcat containers
 nodePort: 32500 # Port exposed externally by the child Tomcat containers (directly accessible from outside)

Deploy the service

1
2


$ kubectl create -f tomcat-service.yml
service/tomcat-service created

This message indicates that the service has been created.

View the service details

1
2
3
4


$ kubectl get service
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 18h
tomcat-service NodePort 10.107.253.196 <none> 8000:32500/TCP /+++++ 2m3s

K8S Notes 5: NFS-Based Cluster File Sharing

Fri, 15 Jan 2021 09:47:00 +0800

In the previous article, we introduced how to deploy a Tomcat cluster using an yml script and the kubectl command. We mainly covered how to create a deployment and a service that exposes ports for external access. The deployed service acts as a proxy and load balancer.

Because multiple pod instances provide services simultaneously, handling shared data or files can be difficult. In this section, we will introduce a solution: sharing files from a server through NFS and using a mount command to mount the shared folder into pod containers. This way, every pod accesses the same files, and any file modified by one pod is updated across the entire cluster in real time.

Introduction to NFS

NFS (Network File System) is a network file system developed by SUN. It is a Unix presentation-layer protocol that allows users to access files elsewhere on a network as if they were using their own computer.

NFS is a TCP-based application. Its core implementation uses RPC (Remote Procedure Call) to transfer files while ensuring that the caller can use remote files as conveniently as local files.

How can multiple Pod instances in a cluster read and write the same data? As shown in the diagram below, we can add a new node that provides an NFS service, while our Tomcat Pod communicates with this node through NFS.

First, the shared folder of the NFS service is www-data
Then, the /mnt folders of node1 and node2 are bound to www-data through the NFS protocol
Finally, use the mount command to mount the /mnt folder of each node to the /tomcat/webapps folder in the container

Procedure

A Node is required as the NFS service node. We will directly use the master node as the shared file node. Perform the following operations on the master:

First, install the NFS tools and rpcbind.
1

$ yum install -y nfs-utils rpcbind
Create a shared folder. In this example, it is /usr/local/data/www-data
1

$ mkdir /usr/local/data/www-data

Configure the NFS shared directory

1
2


# Note that 192.168.233.128 is the master's IP address, rw means readable and writable, and sync means synchronous sharing
$ echo "/usr/local/data/www-data 192.168.233.128/24(rw,sync)" > /etc/exports

Start the nfs and rpc services, and configure both services to start automatically at boot

1
2
3
4
5


$ systemctl start nfs
$ systemctl start rpcbind
# Configure the services to start automatically at boot
$ systemctl enable nfs
$ systemctl enable rpcbind

Check whether the nfs file share was configured successfully

1
2
3
4


$ exportfs
# The following output indicates that the NFS shared folder was configured successfully
/usr/local/data/www-data
		192.168.233.128/24

Using the NFS Service on Clients

On the host where the client Node is located, install the NFS toolset. You only need to install nfs-tools; there is no need to install rpcbind.
1 2

$ yum install -y nfs-utils $ systemctl enable nfs # Configure it to start automatically at boot

Check whether the NFS service on the master node is accessible

1
2
3
4


$ showmount -e 192.168.233.128 # 192.168.233.128 is the NFS service provider, namely the IP address of the host where the master node is located
# The following output indicates that the service is accessible
Export list for 192.168.233.128:
/usr/local/data/www-data 192.168.233.128/24

Use the mount command to mount the directory

1

$ mount 192.168.233.128:/usr/local/data/www-data /mnt

Verify that the mount was successful

Create a file named test.txt in the www-data folder on the master node
1

$ echo "我是主节点，hello" > /usr/local/data/www-data/test.txt
Then check whether the file exists in the /mnt directory on the client node

The file is accessible, indicating that the mount was successful.

Using NFS Shared Files in Containers

In the previous step, we mounted the shared files on every node. We now need to mount the /mnt folder on each node into the Tomcat container in the pod.

You can update this Tomcat cluster using the kubel apply command, or use kubel delete to delete the cluster-related resources and then recreate the cluster. Here, we will use the second method.

Remove the old Tomcat Deployment and Service

1
2
3
4
5
6
7
8


# View the deployment list
$ kubectl get deployment
# Delete the deployment named tomcat-deploy
$ kubectl delete deployment tomcat-deploy
# View the service list
$ kubectl get service
# Delete the service named tomcat-deploy
$ kubectl delete service tomcat-deploy

Modify the Deployment configuration file and add the mount configuration. Comments have been added to all newly added lines

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


apiVersion: extensions/v1beta1
kind: Deployment
metadata:
 name: tomcat-deploy
spec: 
 replicas: 2
 template:
 metadata:
 labels:
 app: tomcat-cluster
 spec:
 volumes: # Create a mounted data volume
 - name: web-app # Data volume name
 hostPath: # Path of the data volume on the host
 path: /mnt
 containers:
 - name: tomcat-cluster
 image: tomcat:latest
 ports:
 - containerPort: 8080
 volumeMounts: # Create a container data volume
 - name: web-app # Data volume name
 mountPath: /usr/local/tomcat/webapps # Path mounted in the container

Recreate deployment

1
2
3
4


# Create the deployment
$ kubectl create -f tomcat-deploy.yml
# Check the deployment status
$ kubectl get deployment

Check whether the mount was successful

We can log in to the host where each pod is located and use docker ps to view the running containers, as shown below

We can then use the docker exec -it [container-ID] /bin/bash command to enter the container and check whether the mounted files exist in the /usr/local/tomcat/webapps folder.

This approach is too cumbersome. Can we use the kubectl command on the master node to enter a container on a child node? The answer is yes.
1 2 3 4

# Check the pod status $ kubectl get pod # Enter the container $ kubectl exec -it [pod名称] /bin/bash

This completes the configuration of NFS-based file sharing for the K8S cluster.

Configuring Automatic NFS Mounting on Clients

Mounts created using the mount command will be lost after the system restarts, so /etc/fstab must be configured.

1
2


# Add the following configuration to /etc/fstab
192.168.233.128:/usr/local/data/www-data /mnt nfs defaults 0 0

K8S Notes 6: Implementing Service Load Balancing with Rinetd

Fri, 15 Jan 2021 09:47:00 +0800

In the previous article, we introduced how to use NFS for file sharing and how to mount shared files into the containers of each pod.

Implementing Load Balancing with Service

Here, we use Service load balancing directly instead of exposing ports on the host nodes. Services within the cluster communicate with one another through the K8S internal network. The special pod named tomcat-service handles traffic forwarding and load balancing.

Modify tomcat-service.yml as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


apiVersion: v1
kind: Service
metadata:
 name: tomcat-service
 labels:
 app: tomcat-service # Service is a special pop that needs to be set up.
spec:
# Type: NodePort #Service
 selector:
 app: tomcat-cluster # Specify bound pod
 ports:
 - port: 8000 # Service was exposed inside the K8s cluster. Port
 targetPort: 8080 # Maped container exposure end mouth
# # External exposure at every Node node in the cluster Port

Apply the Service changes:

1
2
3
4
5
6
7
8


$ kubectl apply -f tomcat-service.yml
# View service status
$ kubectl get service
# Output message
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 23h
tomcat-service ClusterIP 10.99.160.131 <none> 8000/TCP 2m23s
#Here you can see the virtual IP for service is 10.99.160.131.

Add the user test file index.jsp to the NFS shared directory to verify the load-balancing behavior.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# Execute the following order in Master Node (NFS Server)
$ mkdir /usr/local/data/www-data/test/
# Prepare a user tested jsp file
$ echo "IP:<%=request.getLocalAddr()%>" > /usr/local/data/www-data/test/index.jsp
# View Service Internal IP
$ kubectl get service tomcat-service
# Using curl testing, 10.99.160.131 for the ClusterIP obtained in the previous step
$ curl 10.99.160.131:8000/test/index.jsp
# Return to ip for processing requested pod containers
# IP:10.244.2.10
# IP:10.244.1.10

We can see that requests are randomly forwarded to different Pods, as indicated by the different virtual IP addresses displayed.

Port Forwarding Tool Rinetd

In the preceding steps, we implemented load balancing within the cluster. During testing, the address used to access the index.jsp page is curl 10.99.160.131:8000/test/index.jsp. This IP is the virtual IP address of the cluster service and cannot be accessed externally. So how can we map the IP address 192.168.233.128 of the network interface on the master host to this virtual IP address? The answer is Rinted.

Rinetd is a Transmission Control Protocol redirection tool for the Linux operating system
It forwards data from a source IP address and port to a destination IP address and port
In Kubernetes, it is used to expose Service resources externally

Installing Rinetd

Rinetd can only be installed from source code.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# Enter to /usr/ local directory
$ cd /usr/local
# Download rinetd installation package
$ wget http://www.boutell.com/rinetd/http/rinetd.tar.gz
# Other Organiser
# Unpressure
$ tar -zxvf rinetd.tar.gz
# Enter the depressure directory
$ cd rinetd
# Modify rinnetd.c in directory, change port range
$ sed -i 's/65536/65535/g' rinetd.c
# Create a rinted dependent directory, which is mandatory for the software, which must be created manually
$ mkdir -p /usr/man/
# Installation of a C-language compiler
$ yum install -y gcc
# Compile and install
$ make && make install

Configuring Rinetd

We need to add the configuration file /etc/rinetd.conf.

1
2
3
4


$ vim /etc/rinetd.conf
# Add IP map, which means forwarding all requests for access to the 8000 port on the virtual IP 10.99.16.131 mouth
0.0.0.0 8000 10.99.160.131 8000
# Or direct execution of echo "0.0.0.0.8000 10.99.160.131.800 " /etc/rined.conf

Running Rinetd.conf

1

$ rinetd -c /etc/rinetd.conf

Checking the Port Mapping

Use netstat -nptl to verify that port 8000 is open on rinetd.

Use the following address in a browser to access the service provided by rinted + service:

http://192.168.233.128:8000/test/index.jsp

K8S Notes 7: Updating Cluster Configuration and Setting Resource Limits

Fri, 15 Jan 2021 09:47:00 +0800

In the previous article, we introduced how to use NFS for file sharing and how to mount shared files in each Pod’s container.

Adjusting the Cluster Configuration

Update the cluster configuration:

1

$ kubectl apply -f yml文件路径

Delete a deployment or service:

1
2
3
4


# Delete Deployment
$ kubectl delete deployment 部署名称
# Delete Service
$ kubectl delete service 服务名称

Setting Cluster Resource Limits

We mainly add the resources configuration option to the container configuration to set resource limits.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


containers:
 - name: tomcat-cluster
 image: tomcat:latest
 resources:
 requests: # Minimum resource required to run the container, if not satisfied, cannot run
 cpu: 1 # One nuclear cpu can be decimal, for example 0.5, which means that this container can be deployed as long as the host is 0.5 nuclear cpu is idle.
 memory: 500Mi  # 500M RAM
 limits: # Most occupied resources during container operation
 cpu: 2 # Up to 2 corecpu
 memory: 1024Mi # Up to 1G RAM

Testing Resource Adjustments and Deployment

We modify the tomcat-deploy.yml file on the server, add resource limits, and increase the number of replicas to 3.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


apiVersion: extensions/v1beta1
kind: Deployment
metadata:
 name: tomcat-deploy
spec: 
 replicas: 3 #Number of copies changed from 2 to 3
 template:
 metadata:
 labels:
 app: tomcat-cluster
 spec:
 volumes: 
 - name: web-app
 hostPath:
 path: /mnt
 containers:
 - name: tomcat-cluster
 image: tomcat:latest
 resources: # Additional resource limitations
 requests:
 cpu: 0.5
 memory: 200Mi
 limits:
 cpu: 2
 memory: 500Mi
 ports:
 - containerPort: 8080
 volumeMounts:
 - name: web-app
 mountPath: /usr/local/tomcat/webapps

Update the cluster configuration:

1

kubectl apply -f tomcat-deploy.yml

Check the cluster’s Pod information. The number of Pods has increased to 3.

It is worth noting that K8S follows a “resources first” principle when deploying Pods. In other words, a Pod is preferentially deployed to the node with more available resources.

Check whether the configuration has taken effect using the command kubectl describe pod tomcat-deploy-857545df88-26v5t.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


[root@master tomcat-deploy]# kubectl describe pod tomcat-deploy-857545df88-26v5t
Name: tomcat-deploy-857545df88-26v5t
Namespace: default
Priority: 0
PriorityClassName: <none>
Node: node2/192.168.233.130
Start Time: Fri, 15 Jan 2021 18:50:38 +0800
Labels: app=tomcat-cluster
 pod-template-hash=857545df88
Annotations: <none>
Status: Running
IP: 10.244.2.11
Controlled By: ReplicaSet/tomcat-deploy-857545df88
Containers:
 tomcat-cluster:
 Container ID: docker://8f769d695c7f1713027a043a8e11edcf1ad3cb55ae731ca925c0573482174792
 Image: tomcat:latest
 Image ID: docker-pullable://tomcat@sha256:94cc18203335e400dbafcd0633f33c53663b1c1012a13bcad58cced9cd9d1305
 Port: 8080/TCP
 Host Port: 0/TCP
 State: Running
 Started: Fri, 15 Jan 2021 18:50:43 +0800
 Ready: True
 Restart Count: 0
 Limits: # Resource constraints are in effect
 cpu: 2
 memory: 500Mi 
 Requests:
 cpu: 500m
 memory: 200Mi
 Environment: <none>
 Mounts:
 /usr/local/tomcat/webapps from web-app (rw)
 /var/run/secrets/kubernetes.io/serviceaccount from default-token-fkln2 (ro)
Conditions:
 Type Status
 Initialized True 
 Ready True 
 ContainersReady True 
 PodScheduled True 
Volumes:
 web-app:
 Type: HostPath (bare host directory volume)
 Path: /mnt
 HostPathType: 
 default-token-fkln2:
 Type: Secret (a volume populated by a Secret)
 SecretName: default-token-fkln2
 Optional: false
QoS Class: Burstable
Node-Selectors: <none>
Tolerations: node.kubernetes.io/not-ready:NoExecute for 300s
 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
 Type Reason Age From Message
 ---- ------ ---- ---- -------
 Normal Scheduled 8m36s default-scheduler Successfully assigned default/tomcat-deploy-857545df88-26v5t to node2
 Normal Pulling 8m35s kubelet, node2 Pulling image "tomcat:latest"
 Normal Pulled 8m31s kubelet, node2 Successfully pulled image "tomcat:latest"
 Normal Created 8m31s kubelet, node2 Created container tomcat-cluster
 Normal Started 8m31s kubelet, node2 Started container tomcat-cluster

K8S on Jalen's blog

K8S Notes 9: Kubernetes Command Summary

K8S Notes 8: Deploying the Pigeon Baby & Child Store with K8S

Deployment Topology

Deploying the Pigeon Store

Deployment Resources

Deploying the Pigeon Store

1. Create an NFS File Share on the Master and Mount It on the Node

2. Deploy and Initialize the Database

2.1 Create the beiqin-db-deploy.yml File

2.2 Deploy MySQL to the Cluster

2.3 Check the Deployment Status

2.4 Edit the Database Service Script

2.5 Deploy the Service

3. Deploy the Web Application and Initialize the Service

3.1 Create the Deployment Script

3.2 Create the Deployment

3.3 Create the Service

3.4 Verify the Service

4. Expose the Service Externally Using Rinetd

K8S Notes 4: Deploying a Tomcat Cluster with Deployment

Deployment

Basic Deployment Script Format

Common kubectl Commands Related to Deployment

Manually Deploying a Tomcat Cluster

Accessing the Tomcat Cluster Externally Using NodePort

Creating a Tomcat Service

K8S Notes 5: NFS-Based Cluster File Sharing

Introduction to NFS

Cluster File Sharing

Procedure

Using the NFS Service on Clients

Using NFS Shared Files in Containers

Configuring Automatic NFS Mounting on Clients

K8S Notes 6: Implementing Service Load Balancing with Rinetd

Implementing Load Balancing with Service

Port Forwarding Tool Rinetd

Installing Rinetd

Configuring Rinetd

Running Rinetd.conf

Checking the Port Mapping

K8S Notes 7: Updating Cluster Configuration and Setting Resource Limits

Adjusting the Cluster Configuration

Setting Cluster Resource Limits

Testing Resource Adjustments and Deployment

2.1 Create the `beiqin-db-deploy.yml` File