CN110990149B - Load balance test method based on ICOS system - Google Patents
Load balance test method based on ICOS system Download PDFInfo
- Publication number
- CN110990149B CN110990149B CN201911120939.0A CN201911120939A CN110990149B CN 110990149 B CN110990149 B CN 110990149B CN 201911120939 A CN201911120939 A CN 201911120939A CN 110990149 B CN110990149 B CN 110990149B
- Authority
- CN
- China
- Prior art keywords
- load balancing
- creating
- amphorae
- network
- octavia
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000010998 test method Methods 0.000 title claims abstract description 19
- 238000012360 testing method Methods 0.000 claims abstract description 12
- 241000883510 Kolla Species 0.000 claims description 12
- 238000012986 modification Methods 0.000 claims description 12
- 230000004048 modification Effects 0.000 claims description 12
- 238000012423 maintenance Methods 0.000 claims description 4
- 230000008676 import Effects 0.000 claims description 3
- 238000012544 monitoring process Methods 0.000 abstract description 4
- 238000012827 research and development Methods 0.000 abstract description 4
- 238000004891 communication Methods 0.000 abstract description 3
- 239000000306 component Substances 0.000 description 8
- 238000000034 method Methods 0.000 description 6
- 230000008569 process Effects 0.000 description 3
- 238000003860 storage Methods 0.000 description 3
- 241000611184 Amphora Species 0.000 description 2
- 101150042248 Mgmt gene Proteins 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 2
- 230000008859 change Effects 0.000 description 2
- 238000011161 development Methods 0.000 description 2
- 230000006870 function Effects 0.000 description 2
- 239000008358 core component Substances 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 239000002184 metal Substances 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000011160 research Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5083—Techniques for rebalancing the load in a distributed system
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
- G06F9/45508—Runtime interpretation or emulation, e g. emulator loops, bytecode interpretation
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Data Exchanges In Wide-Area Networks (AREA)
Abstract
The load balancing test method based on the ICOS system provided by the invention is characterized in that a virtual network card is added to a control node to be communicated with a tenant network where an amphoray VM is located so as to complete load balancing configuration and related monitoring operation at the bottom layer. The invention aims at the test requirement of load balance of the ICOS system which can completely cover the function, and deeply explores the management network, the port, the mirror image and the like required by the Octavia communication. The efficiency and the cost of research and development and test are greatly improved.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a load balancing test method based on an ICOS system.
Background
The wave tide cloud data center operating system (icloud OpenStack, abbreviated as ICOS) is an intelligent operating system which is rich in functions, high in availability, safe, comprehensive in supporting tools and oriented to next-generation cloud data centers and cloud native applications, and is based on open source OpenStack and combined with self-research of cloud and sea series products. The InCloud OpenStack cloud operating system takes a mainstream OpenStack platform as a core, and carries out a large amount of deep optimization and development on OpenStack core components such as Nova (computing), circle (block storage), Swift (object storage), Neutron (network), Glance (mirror image), Ironic (bare metal), Heat (resource orchestration), Trove (database) and the like.
The openstack octavia is a background program supported by openstack lbaas and provides load balancing for virtual machine traffic. Essentially like trove, api calling both non and neutron generates a virtual machine with haproxy and keepalived software installed and connects to the target network. There are 4 components of octavia, housekeeper, worker, api, health-manager, octavia agent.
Currently, when OpenStack is applied to a cloud operating system with ICOS, ICS, and ICM as cores in the wave tide, how to develop a test method for saving research and development costs and test costs by exploring a management network, a port, and a mirror image required for Octavia communication is an urgent problem to be solved when OpenStack is applied to an Octavia deep test.
Disclosure of Invention
In view of the above problems, an object of the present invention is to provide a load balancing test method based on an ICOS system, in which a virtual network card is added to a control node to communicate with a tenant network where an amphorae VM is located, so as to complete load balancing configuration and related monitoring operations at the bottom layer.
In order to achieve the purpose, the invention is realized by the following technical scheme: a load balancing test method based on an ICOS system comprises the following steps:
s1: adding a virtual network card to the control node to communicate with a tenant network where the amphoray VM is located;
s2: assigning security groups to the amphorae VMs to restrict incoming and outgoing management traffic;
s3: creating a management port through the neutron, entering a container, and creating a corresponding ovs port at a br-int network bridge of a control node, thereby creating a virtual network card;
s4: setting IP for the management port;
s5: importing a load balancing mirror image;
s6: creating an instance type used by the key pair and the load balance;
s7: carrying out configuration modification on a control node which is deployed in advance and executing the configuration modification;
s8: testing a load balancing service on the control node.
Further, the step S1 includes:
creating a tenant network, creating a network and a sub-network, and performing interface operation;
the amphorae VM of the load balancer is managed by the Octavia component.
Further, the step S2 includes:
assigning an entry udp of the amphorae VM for the octavia-health-manager to monitor processes within the amphorae VM;
an entry tcp of the amphorae VM is designated, and the entry tcp is used for SSH to log in the amphorae VM and perform maintenance operation;
another entry tcp of the amphorae VM is designated for communicating with the agent within the amphorae VM to generate a specific load balancing service.
Further, the step S3 includes:
creating three management ports, wherein host names of the three management ports respectively correspond to three control nodes;
respectively entering the containers of the three control nodes.
Further, the step S4 includes:
entering each control node, ensuring the existence of/etc/kolla/config/octavia/dhclient. conf, and if not, creating a directory and a file;
the mac of the created ovs interface is modified on each control node and a dhcp client is started on the home control node, thereby configuring IP for the management port.
Further, the step S5 includes:
and putting the load balancing mirror image into any directory of the control nodes which are deployed in advance, and executing a mirror image import instruction under the directory.
Further, the step S6 includes:
creating a key pair by executing a preset instruction;
an instance type specifying the specifications of the amphorae VM is created for Octavia on the ICOS page.
Further, the step S7 includes:
deploying three control nodes in advance, and modifying the network, the mirror image parameters, the instance type and the key pair configuration parameters of the control nodes;
and after the configuration modification is finished, issuing the configuration to a corresponding module of the octavia component.
Further, the step S8 includes:
creating a load balancing service on a network load balancing interface of the skyline;
an ampora-x 64-haproxy. qcow2 was used to automatically create a virtual machine starting with ampora under the admin project.
Compared with the prior art, the invention has the beneficial effects that: the invention provides a load balancing test method based on an ICOS system, which guarantees the integrity of the test, avoids omission and misuse, and completes the configuration of load balancing and related monitoring operation at the bottom layer by adding a virtual network card to a control node to communicate with a tenant network where an amphorae VM is located in combination with the experience of real research and development test.
The invention aims at the test requirement of load balance of the ICOS system which can completely cover the function, and deeply explores the management network, the port, the mirror image and the like required by the Octavia communication. The efficiency and the cost of research and development and test are greatly improved.
Therefore, compared with the prior art, the invention has prominent substantive features and remarkable progress, and the beneficial effects of the implementation are also obvious.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the provided drawings without creative efforts.
FIG. 1 is a flow chart of the method of the present invention.
Detailed Description
The following description of the embodiments of the present invention will be made with reference to the accompanying drawings.
The first embodiment is as follows:
fig. 1 shows a load balancing test method based on an ICOS system, which includes the following steps:
s1: and adding a virtual network card to the control node to communicate with the tenant network where the amphoray VM is located.
Firstly, a tenant network is created, a network and a sub-network are created, and interface operation can be performed; the amphorae VM of the load balancer is then managed by the Octavia component.
S2: a security group is assigned to the amphorae VM to restrict incoming and outgoing management traffic.
The method specifically comprises the following steps: assigning an entry udp of the amphorae VM for the octavia-health-manager to monitor processes within the amphorae VM; an entry tcp of the amphorae VM is designated, and the entry tcp is used for SSH to log in the amphorae VM and perform maintenance operation; another entry tcp of the amphorae VM is designated for communicating with the agent within the amphorae VM to generate a specific load balancing service.
S3: and creating a management port through the neutron, and creating a corresponding ovs port in the br-int bridge of the control node by the access container, thereby creating the virtual network card.
Firstly, creating three ports, wherein the hostnames of the three ports respectively correspond to three control nodes; then, the containers of the three control nodes are entered respectively.
S4: an IP is set for the management port.
Firstly, entering each control node, ensuring the existence of/etc/kolla/config/octavia/dhclient. conf, and if the existence does not exist, creating a directory and a file; then, the mac of the created ovs interface is modified on each control node and a dhcp client is started on the hosting control node, thereby configuring IP for the management port.
S5: and importing the load balancing mirror image.
The method specifically comprises the following steps: and putting the load balancing mirror image into any directory of the control nodes which are deployed in advance, and executing a mirror image import instruction under the directory.
S6: instance types used for key pair and load balancing are created.
Firstly, a key pair is created by executing a preset instruction; an instance type specifying the specifications of the amphorae VM is then created for Octavia on the ICOS page.
S7: and carrying out configuration modification on the control nodes which are deployed in advance and executing the configuration modification.
Deploying three control nodes in advance, and modifying the network, the mirror image parameters, the instance type and the key pair configuration parameters of the control nodes; and after the configuration modification is completed, the configuration is sent to a corresponding module of the octavia component.
S8: testing a load balancing service on the control node.
Creating a load balancing service on a network load balancing interface of the skyline; an ampora-x 64-haproxy. qcow2 was used to automatically create a virtual machine starting with ampora under the admin project.
Example two:
the embodiment provides a load balancing test method based on an ICOS system, which comprises the following steps:
1. creating a management network:
the octa-worker, octa-housekeeper, and octa-health-manager modules in the octa component need to communicate with the amphorae VM within the tenant network (i.e., the octa management network) to complete the configuration of load balancing and related monitoring operations at the bottom level. Therefore, a virtual network card needs to be added to the control node to communicate with the tenant network where the amphoray VM is located.
Firstly, a tenant network is created, a network and a subnet are created, the interface operation is available, a network segment cannot be overlapped with a management network, a storage network and a cidr of an overlay binding network of a control node, project of the network is admin, the network name is default to lb _ mgmt _ net, an Octavia component is mainly used for managing an amphoray VM for realizing a load balancer and belongs to an Octavia management network, so that a virtual machine is strictly created on the network, and the amphoray VM can be automatically created on the network by creating the load balancer later.
Select "not enable gateway" when creating a subnet.
openstack network create lb_mgmt_net--project admin
openstack subnet create--subnet-range 192.168.0.0/24--allocation-pool start＝192.168.0.2,end＝192.168.0.200--gateway none--network lb_mgmt_net lb_mgmt_subnet。
2. Creating a security group:
the amphorae VM needs to specify security groups to restrict incoming and outgoing management traffic.
Inlet udp 5555 for the octavia-health-manager to monitor processes within the amphorae VM
An entry tcp 22 for SSH to log in the amphorae VM for maintenance operation with less use
An entry tcp 9443 for communicating with an agent within an amphorae VM to generate specific load balancing services
The commands are as follows:
openstack security group create lb_mgmt_sec_group–project admin；
openstack security group rule create-protocol udp-dst-port 5555< security group ID >;
openstack security group rule create-protocol tcp-dst-port 22< security group ID >;
openstack security group rule create-protocol tcp-dst-port 9443< security group ID >.
3. Creating a management port:
the management port, that is, the virtual network card in the control node, which communicates with the Octavia management network, needs to create a port at neutron by using a command line, and enter the container to create a corresponding ovs port at the br-int bridge of the control node, thereby creating the virtual network card.
Firstly, three neutron ports are created, and each port corresponds to a control node;
1) and creating three ports, wherein the hostnames of the three ports respectively correspond to the three control nodes. The commands are as follows:
neutron port-create-name Octavia-mgmt-port 01-security-group < security group ID > -device-owner Octavia: health-mgr-binding: host _ ID [ < host > lb _ mgmt _ net (network name) - -, - -parent-ID [ < s management network tenant ID of tenant >
2) Containers entering three control nodes respectively:
then respectively logging in each control node, entering a neutron _ openvswitch _ agent container, and executing the following ovs-vsctl command (note that mac and id of the corresponding port are respectively replaced);
docker exec-it-u 0neutron_openvswitch_agent bash
the following commands are executed:
ovs-vsctl-may-exists add-port br-int o-hm 0-set Interface o-hm0type internal-set Interface o-hm0 external-ids, i.e. iface-status is active, i.e. set Interface o-hm0 external-ids, i.e. attach-mac < mac of port created by previous command > -set Interface o-hm0 external-ids, i.e. iface-id < id of port created by previous command >
4. Set IP for management Port (o-hm 0):
1) entering each control node, ensuring the existence of/etc/kolla/config/octavia/dhclient. conf, if not, creating a directory and a file, wherein the content of the dhclient. conf file is as follows:
request subnet-mask,broadcast-address,interface-mtu；
do-forward-updates false；
2) the following operations are performed on each control node to modify the mac of the created ovs interface and start a dhcp client on the hosting control node, thereby configuring IP for the management port:
ip link set dev o-hm0 address < MAC address, corresponding to the MAC address of ovs port >;
wherein, the mac address is the mac of the ovs port established on the host control node
After mac configuration is correct, IP is obtained from the dhcp server of the tenant network
dhclient-v o-hm0-cf/etc/kolla/config/octavia/dhclient.conf；
5. Importing a load balancing mirror image:
the image amphora-x64-haproxy. qcow2 is placed under any directory of deployment nodes and executed under the directory:
openstack image create amphora-x64-haproxy--public--container-format＝bare--disk-format qcow2--file amphora-x64-haproxy.qcow2--tag amphora
6. creating a key pair:
the following three commands are executed:
mkdir-p/etc/kolla/config/octavia/.ssh；
ssh-keygen-b 2048-t rsa-N""-f
/etc/kolla/config/octavia/.ssh/octavia_ssh_key；
nova keypair-add
-pub-key ═ etc/kolla/config/octavia/. ssh/octavia _ ssh _ key.pub octavia _ ssh _ key-user < user id of octavia >
7. Create instance types used for load balancing:
an appropriate navigator is created for Octavia to specify the specifications of the amphorae VM, and the "compute & store-resource specification" is created on the ICOS page, and the development environment generally needs 2cpu, 2G memory, and 20G hard disk, and if the production or POC environment recommends 8cpu, 8G memory, and 100G hard disk.
8. Configuration modification and execution modification:
operating at a deployment node:
assuming three control nodes, each named control01, control02, control03,
three directories and files are created at the deployment node: the/etc/kolla/config/octavia/{ control node name }/octavia. conf file:
/etc/kolla/config/octavia/control01/octavia.conf
/etc/kolla/config/octavia/control02/octavia.conf
/etc/kolla/config/octavia/control03/octavia.conf
the contents of the octavia. conf are as follows, and the management port IP should correspond to the control node:
[certificates]
specified in the sh file of the fifth step when the ca _ private _ key _ passphrase ═ foobar # certificate is generated (default is this, not changed)
[health_manager]
bind_port＝5555
bind _ IP ═ IP acquired by the management port on the corresponding node in the fifth step >
controller _ IP _ port _ list ═ IP > acquired by the management port on the corresponding node in the fifth step 5555
heartbeat_key＝insecure
[controller_worker]
amp _ boot _ network _ list ═ id of management network created at the second step >
amp _ image _ tag ═ amphora < seventh step: tag parameter > when mirror is imported (this by default, not to change)
amp _ secgroup _ list ═ id of security group created in the third step >
amp _ viewer _ id ═ viewer id created in the ninth step >
amp _ ssh _ key _ name ═ octavia _ ssh _ key < key pair name > created in step seven (this is by default, without change)
loadbalancer_topology＝SINGLE
After the configuration is completed, the reconfigure octavia issues the configuration to each module of the octavia component, and executes the following commands:
kolla-ansible reconfigure-i/root/multinode-t Octavia
9. testing the load balancing service:
after the configuration is completed, the creation operation of the load balancing service can be completed on a load balancing interface, which is a network of skyline.
After the load balancing is established, automatically establishing a virtual machine starting with the ampora under the admin project by utilizing the ampora-x 64-positive. Meanwhile, members of the resource pool provide specific services such as HTTP for virtual machines created by other images.
The invention is further described with reference to the accompanying drawings and specific embodiments. It should be understood that these examples are for illustrative purposes only and are not intended to limit the scope of the present invention. Further, it should be understood that various changes or modifications of the present invention can be made by those skilled in the art after reading the teaching of the present invention, and these equivalents also fall within the scope defined by the present application.
Claims (9)
1. A load balance test method based on an ICOS system is characterized by comprising the following steps:
s1: adding a virtual network card to the control node to communicate with a tenant network where the amphoray VM is located;
s2: assigning security groups to the amphorae VMs to restrict incoming and outgoing management traffic;
s3: creating a management port through the neutron, entering a container, and creating a corresponding ovs port at a br-int network bridge of a control node, thereby creating a virtual network card;
s4: setting IP for the management port;
s5: importing a load balancing mirror image;
s6: creating an instance type used by the key pair and the load balance;
s7: carrying out configuration modification on a control node which is deployed in advance and executing the modification;
s8: testing a load balancing service on the control node.
2. The ICOS system based load balancing test method of claim 1, wherein said step S1 includes:
creating a tenant network, creating a network and a sub-network, and performing interface operation;
the amphorae VM of the load balancer is managed by the Octavia component.
3. The ICOS system based load balancing test method of claim 1, wherein said step S2 includes:
assigning an entry udp of the amphorae VM for the octavia-health-manager to monitor the progress within the amphorae VM;
an entry tcp of the amphorae VM is designated, and the entry tcp is used for SSH to log in the amphorae VM and perform maintenance operation;
another entry tcp of the amphorae VM is designated for communicating with the agent within the amphorae VM to generate a specific load balancing service.
4. The ICOS system based load balancing test method of claim 1, wherein said step S3 includes:
creating three management ports, wherein host names of the three management ports respectively correspond to three control nodes;
respectively entering the containers of the three control nodes.
5. The ICOS system based load balancing test method of claim 1, wherein said step S4 includes:
entering each control node, ensuring the existence of/etc/kolla/config/octavia/dhclient. conf, and if not, creating a directory and a file;
the mac of the created ovs interface is modified on each control node and a dhcp client is started on the hosting control node, thereby configuring the IP for the management port.
6. The ICOS system based load balancing test method of claim 1, wherein said step S5 includes:
and putting the load balancing mirror image into any directory of the control nodes which are deployed in advance, and executing a mirror image import instruction under the directory.
7. The ICOS system based load balancing test method of claim 1, wherein said step S6 includes:
creating a key pair by executing a preset instruction;
an instance type specifying the specifications of the amphorae VM is created for Octavia on the ICOS page.
8. The ICOS system based load balancing test method of claim 1, wherein said step S7 includes:
deploying three control nodes in advance, and modifying the network, the mirror image parameters, the instance type and the key pair configuration parameters of the control nodes;
and after the configuration modification is completed, the configuration is sent to a corresponding module of the octavia component.
9. The ICOS system based load balancing test method of claim 1, wherein said step S8 includes:
creating a load balancing service on a network load balancing interface of the skyline;
an ampora-x 64-haproxy. qcow2 was used to automatically create a virtual machine starting with ampora under the admin project.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911120939.0A CN110990149B (en) | 2019-11-15 | 2019-11-15 | Load balance test method based on ICOS system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911120939.0A CN110990149B (en) | 2019-11-15 | 2019-11-15 | Load balance test method based on ICOS system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110990149A CN110990149A (en) | 2020-04-10 |
| CN110990149B true CN110990149B (en) | 2022-06-14 |
Family
ID=70084498
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911120939.0A Active CN110990149B (en) | 2019-11-15 | 2019-11-15 | Load balance test method based on ICOS system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110990149B (en) |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102710503B (en) * | 2012-05-15 | 2017-03-15 | 郑州云海信息技术有限公司 | A kind of network load balancing method based on " sea of clouds OS " |
-
2019
- 2019-11-15 CN CN201911120939.0A patent/CN110990149B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN110990149A (en) | 2020-04-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11611487B2 (en) | Model driven process for automated deployment of domain 2.0 virtualized services and applications on cloud infrastructure | |
| CN108536519B (en) | Method for automatically building Kubernetes main node and terminal equipment | |
| CN108062248B (en) | Resource management method, system, equipment and storage medium of heterogeneous virtualization platform | |
| US10148493B1 (en) | API gateway for network policy and configuration management with public cloud | |
| CN106301829B (en) | A kind of method and apparatus of network service dilatation | |
| JP6403800B2 (en) | Migrating applications between enterprise-based and multi-tenant networks | |
| US9246765B2 (en) | Apparatus and methods for auto-discovery and migration of virtual cloud infrastructure | |
| EP2823393B1 (en) | Offline provisioning of virtual machines | |
| CN109194502B (en) | Management method of multi-tenant container cloud computing system | |
| US20170034012A1 (en) | Fast Provisioning Service for Cloud Computing | |
| Nogales et al. | Design and deployment of an open management and orchestration platform for multi-site nfv experimentation | |
| CN107357660A (en) | The distribution method and device of a kind of virtual resource | |
| WO2014014477A1 (en) | Migrating applications between networks | |
| CN111880902A (en) | Pod creation method, device, equipment and readable storage medium | |
| JP2016522509A (en) | Automatic configuration of access to virtual infrastructure manager by virtual network function manager | |
| CN108111332A (en) | Using the mixing cloud management system and method for SDN | |
| CN106533713A (en) | Application deployment method and device | |
| US11425054B1 (en) | User-configured multi-location service deployment and scaling | |
| CN112099913A (en) | Method for realizing safety isolation of virtual machine based on OpenStack | |
| Mamatas et al. | A service-aware virtualized software-defined infrastructure | |
| US11765244B1 (en) | Latency-based service discovery and routing for multi-location service-oriented applications | |
| WO2014036716A1 (en) | Telecommunication information networking architecture-based system for mapping logical delivery point to physical delivery point | |
| CN110990149B (en) | Load balance test method based on ICOS system | |
| CN114363164B (en) | Cloud network service arrangement control method, system, storage medium and electronic equipment | |
| Hao | Edge Computing on Low Availability Devices with K3s in a Smart Home IoT System |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |