KR102582777B1 - Lightweight KubeEdge configuration method and apparatus for edge computing environment - Google Patents

Abstract

The present invention discloses a lightweight cube edge configuration method and device for an edge computing environment. According to the present invention, a method of configuring a lightweight CubeEdge system for an edge computing environment using a lightweight CubeEdge tool for a CubeEdge system including a cloud core and an edge core, wherein the lightweight CubeEdge tool is a kernel-based virtual Creating a virtual machine using a Kernal Virtual Machine (KVM) and establishing a networking environment; All nodes including a master node on the cloud core side and a plurality of edge nodes on the edge core side install a container and set a container runtime; The master node generating a master node token; The plurality of edge nodes transmitting the master node token to a worker node; and forming a cluster by combining the worker node with the master node using the master node token.

Description

Lightweight KubeEdge configuration method and apparatus for edge computing environment}

The present invention relates to a lightweight cube edge configuration method and device for an edge computing environment.

As the number of mobile devices grows rapidly, service providers are increasingly applying edge computing to adapt to large data volumes along with low latency requirements when rolling out services.

Application developers are moving toward configuring Kubernetes at the edge through open source projects such as KubeEdge, Akri, and Google Anthos, along with large cloud providers (Microsoft Azure, Amazon Web Service, etc.).

Since Kubernetes is not suitable for edge computing, KubeEdge, a lightweight version of Kubernetes, was proposed.

CubeEdge allows operators to deploy and manage services with containerization at the edge through a centralized management interface. To deploy a service in the CubeEdge system, you must design the service in the CubeEdge system.

Therefore, in order to accelerate service development, an easy and fast CubeEdge system configuration solution is needed, but CubeEdge installation requires many complex configuration processes.

U.S. Patent Publication No. 2021-0232498

In order to solve the problems of the prior art described above, the present invention seeks to propose a lightweight cube edge configuration method and device for an edge computing environment that can automatically configure the cube edge system.

In order to achieve the above-described object, according to an embodiment of the present invention, a lightweight CubeEdge system for an edge computing environment is configured using a lightweight CubeEdge tool for a CubeEdge system including a cloud core and an edge core. The method includes: creating a virtual machine and establishing a networking environment using the lightweight CubeEdge tool using a Kernel Virtual Machine (KVM); All nodes including a master node on the cloud core side and a plurality of edge nodes on the edge core side install a container and set a container runtime; The master node generating a master node token; The plurality of edge nodes transmitting the master node token to a worker node; and forming a cluster by combining the worker node with the master node using the master node token.

In the step of building the networking environment, the lightweight CubeEdge tool sets up a LAN for forming a Kubernetes cluster on the cloud core side and a LAN for connecting the Kubernetes cluster and the plurality of edge nodes. may include.

Before the step of all nodes installing containers, the lightweight CubeEdge tool may further include the step of disabling swap memory for all nodes.

All of the nodes can set the Cgroup driver, which is defined as a mechanism for controlling specific subsystems of the kernel, including devices, CPU, RAM, network access, etc., to the container runtime.

The master node may be a Kubernetes API server.

Before generating the master node token, the master node may further include installing Kubernetes and CubeEdge.

Before transmitting the master node token to the worker node, the step of installing Cube Edge by the plurality of edge nodes may be further included.

According to another aspect of the present invention, a computer-readable recording medium storing a program for performing the above method is provided.

According to another aspect of the present invention, a lightweight cube edge system configuration device for an edge computing environment including a cloud core and an edge core, comprising: a processor; And a memory connected to the processor, wherein the memory creates a virtual machine using a kernel-based virtual machine (Kernal Virtual Machine, KVM) and builds a networking environment, and the master node and the edge of the cloud core. Let all nodes, including a plurality of edge nodes on the core side, install containers, let all nodes set the container runtime, let the master node generate a master node token, and let the plurality of edge nodes set up the master node. A lightweight cube edge system configuration device that stores program instructions executed by the processor to transfer a node token to a worker node and allow the worker node to combine with the master node using the master node token to form a cluster. provided.

According to the present invention, there is an advantage of being able to automatically build a lightweight cube edge system without a complicated setup process.

Figure 1 is a diagram showing the detailed configuration of a general cube edge system.
Figure 2 is a diagram for explaining the process of configuring a lightweight cube edge system according to this embodiment.

Since the present invention can make various changes and have various embodiments, specific embodiments will be illustrated in the drawings and described in detail.

However, this is not intended to limit the present invention to specific embodiments, and should be understood to include all changes, equivalents, and substitutes included in the spirit and technical scope of the present invention.

The CubeEdge system is an open source edge computing platform designed to extend Kubernetes containerized orchestration capabilities to hosts at the edge, supporting network application deployment and metadata synchronization between cloud and edge devices.

Figure 1 is a diagram showing the detailed configuration of a general cube edge system.

Referring to FIG. 1, the CubeEdge system includes a cloud core (CloudCore, 100) and an edge core (EdgeCore, 102).

The cloud core 100 is an extended Kubernetes controller that controls metadata of edge nodes and pods for transmitting data to identified edge nodes.

The cloud core 100 may include an edge controller (EdgeController) 110, a device controller (DeviceController) 112, and a cloud hub (Cloud Hub) 114.

The edge controller 110 manages a plurality of edge nodes (devices) existing in the edge cluster.

To this end, the edge controller 110 connects the Kubernetes API server (K8s API Server, master node, 130) and a plurality of edge nodes, and registers the plurality of edge nodes with the Kubernetes API server 130 through this. .

The device controller 112 manages the metadata/state of edge nodes in the edge cluster and manages the edge nodes through synchronization between the edge and the cloud.

The cloud hub 114 provides a communication function between the cloud core 100 and the edge core 102, especially between the edge controller 110 and the edge node.

The edge core 102 may include an Edge Hub (120), a MetaManager (122), an EdgeD (124), and a Device Twin (126).

The edge hub 120 interacts with the cloud core 100 for edge computing and provides communication between the cloud core 100 and the edge core 102 to report the status of edge nodes to the cloud side and manage resources between them. Sync updates.

The meta manager 122 manages the status of containers of edge nodes managed through edge D 124. To this end, the meta manager 122 exchanges metadata with the device controller 112.

EdgeD (124) manages containers on edge nodes and operates pods in the CubeEdge system.

Every edge node must have a Kubelet, an agent that operates containers. Register the edge node with the Kubernetes API server 130 through the edge hub 120 and cloud hub 114. Kubelet receives operations to be performed on each edge node, such as starting, stopping, and terminating application containers from the Kubernetes API server 130. It also sends the edge node and container status back to the Kubernetes API server 130.

The device twin 126 stores the state of the edge node and manages the resource state.

The device twin 126 collects the resource status of each edge node through a mapper 140, receives the collected resource status through an event bus 142, and stores it in its DB.

Event bus 142 is an MQTT client that interacts with an MQTT server and provides publish/subscribe (pub/sub) functionality to other components.

Thereafter, the resource status is transmitted to the device controller 112 through communication between the edge hub 120 and the cloud hub 114 and synchronized so that the same content can be stored and managed on the cloud side and the edge side.

Service Bus (Service Bus) 144 receives messages from users who want to utilize edge node resources and delivers them to Edge D (124) through the meta manager (122) so that the tasks requested by the user can be performed in the container. .

Edge nodes may include Docker, a container runtime interface, and a container runtime.

Below, these configurations are described in detail.

CRI (Container Runtime Interface) is a plug-in interface that provides the kubelet with the ability to use various container runtimes. Kubernetes plugins also use CRI to run and observe containers. CRI includes gRPC APIs, protocol buffers, and libraries.

The Open Container Initiative (OCI) runtime is a low-level runtime that performs container life cycle management, creates and runs containers.

Containerd is the basic CRI of the Docker engine, and Containerd provides minimal functions for running containers and managing images and snapshots on nodes. Execution tasks are delegated to the OCI runtime to run and terminate the container. Containerd performs the following tasks to launch a new container:

CRI-O is a container runtime built to provide a link between the high-level Kubernetes CRI and OCI runtime.

Docker uses Containerd as the default container runtime.

You can create and manage containers using the container runtime. However, tools are needed to manage and coordinate these containers in a cluster system. Since one service generally consists of multiple containers, a container orchestration tool is used for container life cycle management.

A variety of container orchestration tools are available, such as Kubernetes, Apache Mesos, Docker Swarm, etc.

Typically, containers are deployed on hosts in replicated groups called pods. Container orchestration tools schedule deployments, and the most appropriate hosts are selected to deploy containers based on predefined constraints such as idle compute units, available memory, network bandwidth, etc.

Container orchestration tools manage the container's lifecycle while the container runs on the host. Container orchestration tools can be used in any environment where containers can run, from personal computers to private cloud instances running on Amazon Web Services (AWS), DigitalOcean, and more.

Docker Engine is an open source containerization platform based on Linux containers for building and containerizing applications. It extends current container technology by providing lightweight containers and an API for managing container images of multi-container applications.

Docker Engine can help deploy applications from one environment to another regardless of their environment settings, and can create all network functions in the service function chain as containers.

Docker containers depend on the kernel of the host running the Docker engine. It isolates user space only at the operating system level and consumes resources when running applications. Basically, a container consists of a process that is isolated from the rest of the processes by a namespace. Containers running on Docker share the host OS kernel. Build containers on top of the operating system using Linux kernel features such as storage, networking, and control groups. Docker bundles an application's software into a package that contains everything it needs to run, such as the OS, application code, runtime, system tools, libraries, etc. Therefore, applications can run on other Linux systems regardless of their custom configuration. Additionally, a Docker container is created by adding a read-write file system on top of the Docker image's read-only file system.

Figure 2 is a diagram for explaining the process of configuring a lightweight cube edge system according to this embodiment.

Referring to FIG. 2, steps to be performed in both the cloud core and edge core and steps to be performed in individual cores are distinguished through the lightweight CubeEdge tool according to this embodiment.

The lightweight CubeEdge tool according to this embodiment may be defined as program instructions executed on a device including a processor and memory.

A processor may include a central processing unit (CPU) capable of executing a computer program or another virtual machine.

Memory may include non-volatile storage devices, such as non-removable hard drives or removable storage devices. Removable storage devices may include compact flash units, USB memory sticks, etc. Memory may also include volatile memory, such as various types of random access memory.

Program instructions for configuring the lightweight CubeEdge system are stored in the memory.

Applies to all nodes

The following process is performed on both the nodes included in the cloud core and the nodes included in the edge core.

The lightweight CubeEdge tool according to this embodiment creates a virtual machine (VM) using a kernel-based virtual machine (Kernal Virtual Machine, KVM) (step 200).

After creating a virtual machine, the lightweight CubeEdge tool establishes a networking environment by setting up at least two LANs inside the KVM (step 202).

One LAN is for forming the cloud-side Kubernetes cluster of the CubeEdge system, and the other is for connecting the cloud-side Kubernetes cluster and the edge nodes of the CubeEdge system.

Afterwards, a network interface is added to each virtual machine, and on the cloud side, a network interface corresponding to the number of edge nodes is added to the Kubernetes API server 130.

To prevent the cube-scheduler from allocating pods to nodes that are low on CPU/memory or have reached specified CPU/memory limits, you must disable swap memory (swap area) on all nodes on the cloud core side and edge core side.

Since the CubeEdge system is based on Kubernetes, the lightweight CubeEdge tool disables swap memory for all nodes included in the cloud and edge cores (step 204).

Afterwards, all nodes install containers (step 206).

Each node of the CubeEdge system sets the Cgroup driver to the runtime of the container (step 208).

Here, Cgroup is a mechanism for controlling specific subsystems of the kernel, including devices, CPU, RAM, network access, etc.

cloud node

Install Kubernetes (K8s) on the master node (step 210).

Here, the master node is the Kubernetes API server 130.

Afterwards, CubeEdge is installed on the master node (step 212).

Set up a master node and have the master node generate tokens (step 214).

Finally, obtain the master node token (step 216).

edge node

Install CubeEdge on the edge node (step 218).

Transfer the master node token to the worker node (step 220).

Finally, the worker nodes combine with the master node using the master node token to form a cluster (step 222).

The above-described embodiments of the present invention have been disclosed for illustrative purposes, and those skilled in the art will be able to make various modifications, changes, and additions within the spirit and scope of the present invention, and such modifications, changes, and additions will be possible. should be regarded as falling within the scope of the patent claims below.

Claims (10)

A method of configuring a lightweight CubeEdge system for an edge computing environment using a lightweight CubeEdge tool for a CubeEdge system including a cloud core and an edge core,
The lightweight CubeEdge tool creates a virtual machine and builds a networking environment using a Kernel Virtual Machine (KVM);
All nodes including a master node on the cloud core side and a plurality of edge nodes on the edge core side install a container and set a container runtime;
The master node generating a master node token;
The plurality of edge nodes transmitting the master node token to a worker node; and
A lightweight Cube Edge system configuration method comprising forming a cluster by combining the worker node with the master node using the master node token. According to paragraph 1,
The step of building the networking environment is,
A lightweight CubeEdge system configuration method comprising the step of setting, by the lightweight CubeEdge tool, a LAN for forming a Kubernetes cluster on the cloud core side and a LAN for connecting the Kubernetes cluster and the plurality of edge nodes. . According to paragraph 1,
A lightweight CubeEdge system configuration method further comprising disabling swap memory for all nodes, by the lightweight CubeEdge tool, before installing containers on all nodes. According to paragraph 1,
A lightweight Cube Edge system configuration method in which all nodes set a Cgroup driver, which is defined as a mechanism for controlling specific subsystems of the kernel including devices, CPU, RAM, network access, etc., to the container runtime. According to paragraph 1,
A method of configuring a lightweight Cube Edge system in which the master node is a Kubernetes API server. According to paragraph 1,
A lightweight Cube Edge system configuration method further comprising installing Kubernetes and Cube Edge in the master node before generating the master node token. According to paragraph 1,
A method of configuring a lightweight CubeEdge system further comprising installing CubeEdge in the plurality of edge nodes before transferring the master node token to the worker node. A computer-readable recording medium storing a program for performing the method according to claim 1. A lightweight CubeEdge system configuration device for an edge computing environment including a cloud core and an edge core,
processor; and
Including a memory connected to the processor,
The memory is,
Create a virtual machine and build a networking environment using a kernel virtual machine (KVM),
All nodes, including a master node on the cloud core side and a plurality of edge nodes on the edge core side, install containers,
Have all of the above nodes set the container runtime,
causing the master node to generate a master node token,
causing the plurality of edge nodes to transmit the master node token to a worker node,
So that the worker node combines with the master node using the master node token to form a cluster,
A lightweight cube edge system configuration device that stores program instructions executed by the processor. According to clause 9,
The program instructions are for disabling swap memory for all nodes before all nodes install containers.