KubeEdge Guide Part 2: In-Depth Analysis of KubeEdge Deployment and Practices

In the era of the Internet of Everything, how can we efficiently extend the powerful capabilities of cloud computing to the edge to meet the needs of real-time data processing and localized computing? KubeEdge provides the perfect answer.

Introduction

With the rapid development of the Internet of Things (IoT), edge computing has become a key technology to solve problems such as real-time data processing, network bandwidth limitations, and data privacy. Edge computing reduces data transmission latency and improves system response speed by performing computations near the data source. However, deploying edge computing platforms poses many challenges, such as limited hardware resources, complex and variable network environments, and device diversity.

KubeEdge, as an open-source platform that extends Kubernetes capabilities to the edge, provides a cloud-edge collaborative solution. This article will delve into the installation and deployment process of KubeEdge and share its effectiveness in real-world applications, helping you better understand and apply KubeEdge.

1. KubeEdge Installation and Deployment

1. Environment Preparation

Before deploying KubeEdge, you need to prepare the environment, including hardware and software configurations.

Hardware Requirements

• Cloud Node:
• Server or Virtual Machine
  • CPU: Dual-core or higher
  • Memory: 4GB or more
  • Storage: 50GB disk space
  • Network: Must be able to access the internet
• Edge Node:
• Devices supporting x86 or ARM architecture
  • CPU: Single-core or higher
  • Memory: 1GB or more
  • Storage: 20GB disk space
  • Network: Must be able to communicate with the cloud node, may require firewall or NAT traversal

Software Dependencies

• Cloud Node:
• Operating System: Ubuntu 16.04 or higher, CentOS 7 or higher
• Kubernetes Cluster: Version 1.15 or above
• Docker or other container runtime: Docker 18.06 or above
• Edge Node:
• Operating System: Ubuntu, CentOS, Debian, Raspbian, etc.
• Docker or other container runtime: Docker 18.06 or above

2. Cloud Deployment

On the cloud node, you need to deploy the Kubernetes cluster and KubeEdge cloud components, including EdgeController and CloudHub.

Installing Kubernetes

1. Install kubeadm, kubelet, and kubectl

   # Update the apt package index
   sudo apt-get update

   # Install kubeadm, kubelet, and kubectl
   sudo apt-get install -y kubeadm kubelet kubectl

2. Initialize the Kubernetes Cluster

   sudo kubeadm init --pod-network-cidr=10.244.0.0/16

3. Configure kubectl Command-Line Tool

   mkdir -p $HOME/.kube
   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
   sudo chown $(id -u):$(id -g) $HOME/.kube/config

4. Deploy Network Plugin

   # Using Flannel as an example
   kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Deploying EdgeController and CloudHub

KubeEdge provides a command-line tool called keadm for quickly deploying KubeEdge.

1. Download and Install keadm

   # Download the latest version of keadm
   wget https://github.com/kubeedge/kubeedge/releases/download/v1.9.0/keadm-v1.9.0-linux-amd64.tar.gz

   # Extract the file
   tar -zxvf keadm-v1.9.0-linux-amd64.tar.gz

   # Enter the extracted directory
   cd keadm-v1.9.0-linux-amd64

   # Install keadm
   sudo ./keadm/keadm init --kubeedge-version=1.9.0

2. Initialize the Cloud

   sudo keadm init

This command will:

• Install KubeEdge cloud components EdgeController and CloudHub.
• Generate the certificates and tokens needed for edge nodes to join.

1. Get the Command to Join the Edge Node Execute the following command to get the command required for the edge node to join the cluster:

   keadm gettoken

This command will return a token, such as:

   1234567890abcdef1234567890abcdef

3. Edge Deployment

On the edge node, you need to install EdgeCore and configure communication with the cloud.

Installing EdgeCore

1. Download and Install keadm

   # Download keadm
   wget https://github.com/kubeedge/kubeedge/releases/download/v1.9.0/keadm-v1.9.0-linux-amd64.tar.gz

   # Extract the file
   tar -zxvf keadm-v1.9.0-linux-amd64.tar.gz

   # Enter the extracted directory
   cd keadm-v1.9.0-linux-amd64

2. Join the Edge Node Use the token obtained from the cloud to join the edge node to the cluster:

   sudo ./keadm/keadm join --cloudcore-ipport=<cloudcore_ip>:10000 --token=<token> --edgenode-name=<edge_node_name>

Parameter explanation:

• cloudcore_ip: The IP address of the cloud node
• token: The token obtained from the cloud
• edge_node_name: The name of the edge node

1. Verify EdgeCore Running Status

   sudo systemctl status edgecore

If EdgeCore is running correctly, the status should be active (running).

Configuring Authentication and Communication

1. Ensure Cloud-Edge Network Connectivity

• Check if the edge node can access the cloud node's 10000 port.
• If there is a firewall or NAT, configure the necessary ports and protocols to pass through.

1. Verify Certificates and Keys

• The keadm tool will automatically generate and distribute the required certificates and keys.
• If manual configuration is needed, ensure that the certificates on the edge node match those on the cloud.

4. Deployment Verification

Node Registration

1. Check Node Status on the Cloud

   kubectl get nodes

If the edge node has successfully joined the cluster, you should see the edge node's name with a Ready status.

Application Deployment

1. Deploy an Application to the Edge Node from the Cloud Create a deployment file edge-app.yaml with the following content:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: edge-app
     labels:
       app: edge-app
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: edge-app
     template:
       metadata:
         labels:
           app: edge-app
       spec:
         nodeSelector:
           kubernetes.io/hostname: <edge_node_name>
         containers:
         - name: nginx
           image: nginx
           ports:
           - containerPort: 80

Replace <edge_node_name> with the actual name of the edge node.

2. Deploy the Application

   kubectl apply -f edge-app.yaml

3. Verify the Application Running Status

   kubectl get pods -o wide

You should see the Pod running on the edge node with a Running status.

Device Access

1. Configure Device Model and Instance Create a device model device-model.yaml:

   apiVersion: devices.kubeedge.io/v1alpha2
   kind: DeviceModel
   metadata:
     name: sensor-model
   spec:
     properties:
     - name: temperature
       description: "Temperature of the device"
       type:
         int:
           accessMode: ReadOnly
           defaultValue: 0

Create a device instance device-instance.yaml:

   apiVersion: devices.kubeedge.io/v1alpha2
   kind: Device
   metadata:
     name: sensor-device
   spec:
     deviceModelRef:
       name: sensor-modelContinuing with the translation:

yaml
spec:
nodeSelector:
nodeSelectorTerms:
- matchExpressions:
- key: kubernetes.io/hostname
operator: In
values:
-
protocol:
protocolName: bluetooth
propertyVisitors:
- propertyName: temperature
visitorConfig:
collectCycle: 10s

2. **Deploy the Device Model and Instance**

bash
kubectl apply -f device-model.yaml
kubectl apply -f device-instance.yaml
```

3. Verify Device Data

• On the edge node, device data will be transmitted through EventBus. You can subscribe to the corresponding topic in the application to collect and process the data.

2. Practical Case Studies

Case 1: Application in a Smart Factory

Project Background

A manufacturing company has a large number of production devices that need real-time monitoring of their operating status, production parameters, and fault warnings. However, due to the wide distribution of devices and the complex network environment, traditional cloud monitoring solutions face issues such as data delay and insufficient network bandwidth.

Solution

Deploy monitoring applications on edge devices using KubeEdge to achieve local data processing and real-time response.

Implementation Steps

1. Environment Deployment

• Deploy edge nodes in each production workshop and install EdgeCore.
• Deploy the Kubernetes cluster and KubeEdge cloud components on the cloud.

1. Application Deployment

• Develop data collection and monitoring applications, package them into container images.
• Use Kubernetes to deploy the applications to the corresponding edge nodes.

1. Device Access

• Define device models and instances and configure device-to-application communication.
• Use DeviceTwin to achieve real-time monitoring and control of device states.

Application Effect

• Improved Real-Time Performance: Device data is processed on the edge, reducing data transmission latency and achieving millisecond-level response.
• Reduced Network Pressure: Only critical data is uploaded to the cloud, saving network bandwidth.
• Enhanced Reliability: Edge nodes can continue to operate normally during network outages, ensuring continuous production.
• Lower Maintenance Costs: Unified platform management of devices and applications reduces the workload of operations and maintenance.

Case 2: Intelligent Traffic Management

Project Background

A city aims to optimize traffic signal control through real-time analysis of traffic data to alleviate congestion. However, the large number of roadside devices and the huge volume of data make it difficult for traditional cloud processing methods to meet the real-time requirements.

Solution

Deploy KubeEdge on roadside edge devices to achieve local processing and real-time analysis of traffic data.

Implementation Steps

1. Environment Setup

• Deploy edge nodes at key intersections and configure EdgeCore.
• Deploy the Kubernetes cluster and KubeEdge cloud components on the cloud.

1. Data Collection

• Deploy cameras and sensors to collect vehicle and pedestrian data.
• Use KubeEdge's device management function to enable device access and data transmission.

1. Real-Time Analysis

• Deploy edge computing applications for image recognition and data analysis.
• Adjust traffic signal timings dynamically based on the analysis results.

Application Effect

• Improved Traffic Flow: Real-time adjustment of signal lights improved road traffic efficiency.
• Reduced Data Transmission: Data is processed on the edge, reducing dependency on the cloud.
• Enhanced Data Security: Sensitive traffic data is processed locally, protecting citizens' privacy.
• Strong Scalability: KubeEdge supports flexible application deployment, facilitating subsequent feature expansion.

3. Common Issues and Solutions in Deployment

During the deployment of KubeEdge, you may encounter some common issues. Below are the causes and solutions for these issues.

Issue 1: Node Cannot Register

Cause Analysis

• Network Unreachable: The edge node cannot establish a connection with the cloud's CloudHub.
• Authentication Failure: The token of the edge node is expired or incorrect.
• Firewall Restrictions: Required ports are blocked by the firewall.

Solutions

• Check Network Connectivity: Ensure that the edge node can access the cloud IP and port (default is 10000).
• Verify Token: Obtain a new valid token and ensure the command parameters are correct.
• Configure Firewall: Open communication ports between the cloud and edge nodes, such as 10000, 10002, etc.

Issue 2: Application Cannot Start

Cause Analysis

• Insufficient Resources: The edge node lacks sufficient memory or CPU to run the application.
• Configuration Error: The deployment file of the application has errors, and the node selector is not configured correctly.
• Image Pull Failure: The required container image cannot be pulled from the image repository.

Solutions

• Adjust Resource Allocation: Increase the resources of the edge node or optimize the application's resource requests.
• Check Deployment File: Ensure the YAML file syntax is correct and the node selector is configured properly.
• Configure Image Repository: If using a private image repository, configure authentication; otherwise, pull the image on the edge node in advance.

Issue 3: Device Data Cannot Synchronize

Cause Analysis

• Protocol Incompatibility: The communication protocol used by the device is not supported or configured incorrectly.
• Message Loss: Network instability causes messages to fail to transmit normally.
• Application Subscription Error: The application does not subscribe to the correct topic for device data.

Solutions

• Verify Device Protocol: Ensure that the protocol used by the device is supported by KubeEdge and is correctly configured.
• Check Message Queue: Check the running status of EventBus to ensure the MQTT service is normal.
• Confirm Application Subscription: Check the subscription configuration of the application to ensure it correctly subscribes to the device data topic.

Through the in-depth analysis of KubeEdge deployment and practice, we can see that:

• KubeEdge provides powerful cloud-edge collaboration capabilities, effectively solving many challenges in edge computing.
• Attention to detail and planning are required during deployment, including environment preparation, network configuration, and component installation.
• Practical case studies demonstrate the value of KubeEdge, achieving significant results in smart factories and intelligent transportation.

Note: This article aims to provide guidance for readers on KubeEdge deployment and practice. Subsequent articles will continue to explore the KubeEdge ecosystem and future developments. Stay tuned.