Shulou(Shulou.com)06/02 Report--

The streets of the city are getting busier and busier because of the growth in the number of cars, so it is a headache for motorists to find parking lots in hot areas. At the same time, however, many paid parking resources may still be underutilized in many office buildings, residential buildings, hotels and public garages.

ParkBee is such a company that provides smart parking solutions for cities. The ParkBee platform shows the available parking lots near the location of each car owner, and the parking price and the availability of parking spaces are all updated in real time. ParkBee "opens" all the parking lots in the city, solving the parking problem, saving time for car owners and helping parking lots maximize revenue.

ParkBee recently began experimenting with container deployment at the edge. Because an important part of ParkBee's overall business is a large number of parking lots, there are more than 6000 parking lots in cooperation with ParkBee, and we have served 800000 parking services so far. We must ensure that the containers in each parking lot work as expected, so it is critical to deploy applications that contain business logic.

ParkBee currently uses Kops to deploy Kubernetes, while AWS is selected for public cloud. While this approach applies to our cloud-based services, it is not that simple for our edge deployment. Our ideal goal is to have a Kubernetes cluster on every parking lot cooperated by ParkBee, which contains the edge Kubernetes node of the parking point and the Kubernetes master node in the AWS.

Half a month ago, Rancher Labs released K3smuri, which is considered to be the lightest Kubernetes distribution in history. K3s is designed to make it easier for low-resource computing platforms like raspberry pie to install and maintain Kubernetes.

In essence, K3s promises to be a lightweight, easy-to-use Kubernetes provisioner that uses only one binary. The announcement of K3s states that its main functions include:

Production Kubernetes:K3s is a standard Kubernetes distribution that has been officially certified by CNCF.

A binaries without host dependencies: everything you need to install Kubernetes on any device is contained in the binaries of this 40MB, without the need for external installers like KuberSpray, KubeADM, or RKE. Users can configure or upgrade a single-node K3s cluster with only one command.

A command to add nodes to the cluster: if you want to add other nodes to the cluster, the administrator only needs to run a command on the new node to point to the original server and pass it through secure token.

Automatically generate certificates: when the cluster starts, all certificates required to establish a TLS between the Kubernetes master server and the node are automatically created, as well as the encryption key for the service account.

Preparatory work

In this article, I will use the first version of K3s, v0.1.0. If you want to follow my article to try the same thing, you need to prepare:

Raspberry Pi 3 B+ model with microSD card with flash memory Raspbian Stretch Lite.

Local network: for convenience, I will use my own local area network at home.

Vagrant installed locally on your laptop: you can also use Docker for Mac, but in essence, K3s binaries are built for Linux, arm64, and armhf architectures.

Vagrant

If you are using Vagrant, you can create a Vagrantfile in the test directory with the following:

#-*-mode: ruby-*-# vi: set ft=ruby: VAGRANT_API = 2Vagrant.configure (VAGRANT_API) do | config | config.vm.box = "bento/ubuntu-18.04" config.vm.box_check_update = false config.vm.network "forwarded_port", guest: 6443, host: 6443 Host_ip: "0.0.0.0" config.vm.provider "virtualbox" do | vb | vb.cpus = 1 vb.gui = true vb.memory = "2048" vb.name = "k3s-master" end config.vm.provision: docker config.vm.provision "shell", inline: firewall Then click the close button.

For Windows, you can refer to Lifewire's article on turning off the firewall in Windows:

Https://www.lifewire.com/how-to-disable-the-windows-firewall-2624505

Run K3s master node

We will first use the Vagrant machine as the K3s master node; once it starts working properly, we will try to connect Raspberry Pi to the K3s master node on the local LAN.

As with any Vagrant machine, just run vagrant up and everything starts. Vagrant will run the K3s automatic installation script, open port 6443 on the local computer so that K3s nodes can join, and create the connection tokens that are needed later.

First, verify that the installation of the primary node is successful:

Root@k3s-master:~# kubectl get nodesNAME STATUS ROLES AGE VERSIONk3s-master Ready 4m51s v1.13.3-k3s.6

By default, the K3s installation script does not mark k3s-master as the primary node, but because we have pre-installed the Kubectlbinaries, we can now solve this problem:

Root@k3s-master:~# kubectl label node k3s-master kubernetes.io/role=masternode/k3s-master labeledroot@k3s-master:~# kubectl label node k3s-master node-role.kubernetes.io/master= "" node/k3s-master labeled

The installation of K3s also does not contaminate the primary node of NoSchedule. In this test, we want to ensure that Raspberry Pi can receive the test deployment, so contaminate the primary node using the following methods:

Root@k3s-master:~# kubectl taint nodes k3s-master node-role.kubernetes.io/master=effect:NoSchedulenode/k3s-master tainted

Next, we need token to connect the K3s node to the new primary node. The K3s server command should have created this / var/lib/rancher/k3s/server/node-token for you. Run the following command:

Root@k3s-master:~# cat / var/lib/rancher/k3s/server/node-token

Run the K3s node on Raspberry Pi

First, we need to prepare some initial steps for raspberry pie. First, disable swap using the following command:

Dphys-swapfile swapoff & &\ dphys-swapfile uninstall & &\ update-rc.d dphys-swapfile remove

Then, append the following text to the first line of / boot/cmdline.txt:

Cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory

Then, reboot raspberry pie. When you return, log in again, and then run the following command to download the K3s binary.

Curl-fSL "https://github.com/rancher/k3s/releases/download/v0.1.0/k3s-armhf"\-o / usr/local/bin/k3s & &\ chmod + x / usr/local/bin/k3s

Since K3s no longer uses containerd, we don't need to install Docker, but it's best to verify that all pod is working properly. You can quickly install Docker by running the following command:

Curl-fsSL https://get.docker.com | sh-& &\ usermod-aG docker pi

Get the token created from the master server and export it as an environment variable:

Export NODE_TOKEN= ""

Finally, run the K3s agent command to start the agent, and then join the master node. In this use, 192.168.0.10 is the address of the Vagrant machine running on the local laptop on my network. Be sure to replace the value with the appropriate address.

K3s agent\-docker\-server https://192.168.0.10:6443\-token ${NODE_TOKEN}\ > / root/logs.txt 2 > & 1 &

Similar to the K3s master node, this installation will not mark Raspberry Pi with the correct node label. On k3s-master, run the following command after Raspberry Pi joins the cluster:

Root@k3s-master:~# kubectl label node raspberrypi kubernetes.io/role=nodenode/raspberrypi labeledroot@k3s-master:~# kubectl label node raspberrypi node-role.kubernetes.io/node= "" node/raspberrypi labeled

If Raspberry Pi joins successfully, you should see something similar to the following when you run the command on the primary server:

Root@k3s-master:~# kubectl get nodesNAME STATUS ROLES AGE VERSIONraspberrypi Ready node 2m v1.13.3-k3s.6k3s-master Ready master 20m v1.13.3-k3s.6

Deploy a test NGINX container

To ensure that the K3s cluster really works, we can deploy a test NGINX pod and NodePort service to ensure that Raspberry Pi has created the pod and successfully opened the port.

On the K3s master Vagrant machine, create a file on / root/nginx-test.yaml with the following:

-apiVersion: v1kind: Servicemetadata: name: nginx-unprivileged-test namespace: defaultspec: type: NodePort selector: app: nginx-unprivileged-test ports:-protocol: TCP nodePort: 30123 port: 8080 name: http targetPort: 8080---apiVersion: extensions/v1beta1kind: Deploymentmetadata: name: nginx-unprivileged-test namespace: defaultspec: replicas: 1 template: metadata: labels: app: nginx-unprivileged-test spec: containers:- Image: nginxinc/nginx-unprivileged name: nginx-unprivileged-test ports:-containerPort: 8080 name: http livenessProbe: httpGet: path: / port: http initialDelaySeconds: 3 periodSeconds: 3

And then eventually deploy it to the cluster:

Root@k3s-master:~# kubectl apply-f / root/nginx-test.yamlservice/nginx-unprivileged-test createddeployment.extensions/nginx-unprivileged-test created

Because this is a NodePort service, K3s will open a port 30123 on Raspberry Pi. On my local network, Raspberry Pi is at 192.168.0.43.

Conclusion

I have noticed some things in the process of using K3s, and I would like to remind you here:

When deploying the NGINX test container, I initially used the regular nginx:latest image in Docker Hub. However, it seems that K3s does not support ports less than 1024. By default, the nginx image attempts to open port 80 in the container, which can cause some problems.

As mentioned in this article, label and taint are usually included in Kubernetes distributions, but K3s has not fully implemented this for the time being.

I fully believe that K3s will greatly facilitate the use of Kubernetes in edge computing scenarios.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.