Design and implementation of cluster management system for automatic screw machine based on Kubernetes

1.1. Introduction and development of Kubernetes

In the past few decades, China’s machinery manufacturing industry has undergone significant transformation, with the development of automation technologies improving the assembly efficiency of enterprises [1]. Under the background of Industry 4.0 [2], the complexity of industrial production has been increasing, and traditional manual operations and simple mechanized production methods are no longer sufficient to meet the requirements of modern industrial production. The domestic demand for automatic screwdrivers remains substantial. As a critical production tool, automatic screwdrivers have been widely applied across various industries, greatly enhancing product quality and production efficiency [3]. However, under manual management, automatic screwdrivers require a significant amount of human labor, are prone to errors, and have slow response times [4]. Furthermore, automatic screwdrivers experience substantial idle time during the manufacturing process, making cluster management and reasonable task allocation difficult.

Applying Kubernetes to the management of automatic screwdriver clusters is akin to giving the production line a “smart brain”. It can adjust task allocation according to demand, achieving optimal resource utilization. The Kubernetes architecture adopts the microservices design principle [5], consisting of multiple independent modular components that work in coordination with the operating system's resource objects. By utilizing Kubernetes, a scalable enterprise-level cloud platform can be quickly established and managed [6]. Through intelligent scheduling and automated repair systems, it ensures the availability and fault tolerance of the system, minimizing downtime and waiting time. Moreover, by leveraging LXD [7] container technology, Kubernetes provides the ability to automate the deployment, operation, and scaling of applications on the cloud platform. This significantly improves production efficiency and reduces operational and maintenance costs, driving the intelligence and reliability of manufacturing processes [8].

1.2. The related work of Kubernetes

Li et al. (2024) applied microservice and container technology in industrial software development but did not involve motion control or real-time scheduling. Xu et al. (2023) proposed a container-based industrial cloud platform but lacked optimization for screw fastening tasks. Toka (2021) studied low-latency edge computing with Kubernetes but did not apply it to numerical control equipment. The proposed system fills the gap by combining container orchestration, real-time scheduling, and embedded motion control for automatic screw machine clusters.

2.1. Introduction of Kubernetes

Kubernetes [9] is an open-source container orchestration platform for automated deployment, management, and scaling of containerized applications. A cluster consists of a Master node and multiple Node nodes. The Master includes kube-apiserver, kube-scheduler, kube-controller-manager, and etcd. Nodes run kubelet, kube-proxy, and container runtime [10-11].

Fig. 1Architecture diagram of Kubernetes

2.2. Analysis of cluster management system technology

Traditional cluster management systems face challenges such as complex resource scheduling, poor real-time performance, and insufficient adaptability to embedded hardware when applied to large-scale automatic screw machine clusters. These systems struggle with the real-time task allocation of screw fastening, cross-node fault handling of equipment, and high availability assurance of motion control services, resulting in low resource utilization and unstable production.

As an efficient cluster management platform for automatic screw machines, Kubernetes solves the above pain points through container orchestration, node-level equipment management, real-time resource scheduling, and full-link monitoring. Aiming at the characteristics of screw fastening tasks (periodic, repetitive, deadline-sensitive), Kubernetes optimizes task allocation through improved scheduling strategies, enhances the security of embedded control systems, ensures high availability of equipment clusters, and supports automated operation and maintenance of industrial equipment. Kubernetes optimizes the allocation of CPU, memory and I/O resources for screw machine control through efficient scheduling algorithms, resource quotas, node affinity and auto-scaling, combined with real-time performance monitoring, to further improve the overall operating efficiency of the cluster and ensure the stable operation of motion control applications in dynamic production environments.

2.3. Automatic screw machining platform

As shown in Fig. 2, this is the model diagram of the automatic screw machine designed in this study. The automatic screw machine achieves automatic delivery, tightening, and inspection of screws through the coordinated operation of its feeding system, control system, drive system, and fastening system. This has improved production efficiency and product quality in multiple industries, including communications, optoelectronics, home appliances, automobiles, and toys [12].

Fig. 2Automatic screw machining platform model

With technological advancements, automatic screw machines have demonstrated characteristics of high efficiency, high precision, automation, intelligence, flexibility, adaptability, safety, and reliability in cluster management. They also play an increasingly important role in data management and analysis, adapting to ever-changing production demands and enhancing overall production performance. As a result, the demand for automatic screw machines in cluster management is growing. The key requirements for cluster management include:

1) High efficiency and high precision: Automatic screw machines need to improve fastening speed while ensuring tightening accuracy to meet the demands of large-scale production.

2) Automation and intelligence: By using automated control systems to reduce human intervention, the stability and consistency of the production process can be improved.

3) Flexibility and adaptability: The automatic screw machine must be able to handle different types and specifications of screws, as well as products of varying materials and thicknesses, to meet diverse production needs.

4) Safety and reliability: Automatic screw machines are typically equipped with various safety protection features, such as overload protection and power failure protection, to ensure the safety and stability of the equipment during operation.

5) Data management and analysis: With the advancement of Industry 4.0, cluster management for automatic screw machines also needs to incorporate data collection, analysis, and optimization, to further improve production efficiency and quality.

6) Real-time performance: The screw fastening task has clear timing constraints (task period $T=$100 ms, execution time $E=$20 ms, deadline $D=$100 ms, jitter tolerance ≤ 5 ms), requiring the cluster system to complete task scheduling and response within the deadline.

3.1. Design of Kubernetes system architecture

Based on the distributed cluster management cloud platform for the automatic screw machine, the Linux operating system is used to configure the environment for the physical nodes of the cluster and deploy the Machinekit system [13]. As shown in Fig. 3, LXD container technology is employed to enable the rapid startup of the Machinekit operating system. The I/O pins of the BeagleBone Black development board are used to control the motion of the automatic screw machine’s axis. As illustrated in Fig. 3, the Kubernetes cloud platform structures its cluster into one Master node and three Node nodes. The Master node acts as the control node, providing an open API interface to the backend service modules and processing control commands received from the backend. All Node nodes serve as Worker nodes, executing containerized tasks assigned by the Master node. Additionally, Kubectl commands are executed on the Master node.

Fig. 3Kubernetes node deployment architecture

3.2. Implementation of Kubernetes core modules

3.2.1. Deployment of Kubernetes node

The Kubernetes cloud platform serves as the core foundation for managing multiple screw machines, providing the necessary platform support for the operation of backend applications. It is required to have stability, efficiency, and high availability [14]. The backend application adopts a microservices architecture, which allows services within the system to be independently deployed and run. As shown in Fig. 4, to ensure high availability of the services, the system deploys the same service unit on multiple replica nodes, thus preventing service interruptions caused by failures of a single node. Among them, etcd is responsible for storing the configuration and state information of the cluster. kube-apiserver provides API interface services to other resources or components, kube-scheduler is responsible for scheduling resources, and kube-controller-manager manages different resources to ensure that resources operate according to predefined rules [15].

Fig. 4Kubernetes Node deployment architecture diagram

The automatic screw machine management cloud platform is a multi-node distributed project deployed based on LXD containers, with Node nodes running under the management of the Master node. All applications are deployed on these nodes. As shown in Table 1, the Master node hosts services such as etcd, kube-apiserver, kube-scheduler, and kube-controller-manager, while the Node nodes have components like kubelet, kube-proxy, and container runtimes installed. These components are responsible for tasks such as container creation, network access, and task deployment [16].

Table 1Node configuration information

Part	Name	IP address	Element	Hardware configuration
Master	Virtual machine Ubuntu20.04	192.168.3.120	Etcd, kube-apiserver, kube-controller-manager, kube-scheduler, LXD	CPU: 2 Cores, Memory: 4 GB, Hard disk: 40 GB, Network: 100 Mbps
Node1	Screw machine 1	192.168.3.121	kube-proxy, kubelet, LXD	BeagleBone Black, CPU: 1 Core ARM Cortex-A8, Memory: 512 MB, Storage: 4 GB eMMC, Network: 100 Mbps
Node2	Screw machine 2	192.168.3.122	kube-proxy, kubelet, LXD	BeagleBone Black, CPU: 1 Core ARM Cortex-A8, Memory: 512 MB, Storage: 4 GB eMMC, Network: 100 Mbps
Node3	Screw machine 3	192.168.3.123	kube-proxy, kubelet, LXD	BeagleBone Black, CPU: 1 Core ARM Cortex-A8, Memory: 512 MB, Storage: 4 GB eMMC, Network: 100 Mbps

3.2.2. Kubernetes pod selection

As shown in Fig. 5, a Pod is the basic deployment unit in Kubernetes. It encapsulates one or more containers, which share network and storage resources and can work together [17]. The Pod simulates a logical host environment, enabling inter-process communication between containers, sharing a file system, and using the same network port. The design of the Pod is intended to support tightly coupled applications, simplifying deployment and management. However, Pods are inherently transient and are typically managed by controllers such as the ReplicaSet to enable self-healing, replication, and scaling functionality [18].

Fig. 5Pod container schematic

Kubernetes virtualizes the cluster environment required by large software systems, enabling green deployments across data centers and providing intelligent auto-scaling capabilities. Docker containers and Linux containers are two important containerization solutions [19]. Docker containers package the system environment required by the application from the bottom up, enabling seamless cross-platform operation of applications, and are categorized as application containers. Linux containers, on the other hand, are a virtualization technology based on the containerized OS level, classified as system containers. LXD (Linux Daemon) is primarily used to manage LXC [20] (Linux Containers), addressing issues such as the inability of LXC to enable certain security features by default. LXD provides a complete set of underlying tools for creating and managing containers, making LXC usage more efficient. Therefore, the LXD Linux container solution is adopted.

Fig. 6Core architecture diagram of Kubernetes scheduler

The native Kubernetes scheduler lacks real-time performance [21]. Traditional RM (Rate Monotonic) sets priority only by task period [22], which cannot handle deadline-sensitive tasks. This paper proposes QRM [23] (Quick Rate Monotonic):

As shown in Fig. 7, the task allocation process for the automatic screw machine is designed to assign more tasks to lightly loaded devices while reducing the workload of heavily loaded devices, transferring tasks to the lighter ones. At the same time, real-time monitoring of machine status and task execution ensures that, in case of a failure or anomaly, tasks are immediately reassigned to other available machines, ensuring continuous and efficient production.

As shown in Eq. (1), the Rate-Monotonic (RM) scheduling algorithm achieves fast machine prioritization by inversely associating the screw machine’s work cycle with its priority:

1

$P_i=\frac{1}{T_i},$

where $T_i$ is the execution period of task $i$.

Fig. 7Kubernetes task assignment flowchart

Given an independent task set $S=\left[t_1,t_2,t_3,\dots ,t_n\right]$, each task $t_i$ is represented by the tuple $t_i=\left[E_i,T_i,D_i\right]$ ($i=$1, 2,..., $n$), where $D_i$ represents the deadline of task $t_i$, $T_i$ represents its period, and $E_i$ represents its execution time. If the CPU utilization of the task set satisfies certain conditions, then the task set is suitable for scheduling using the Rate-Monotonic (RM) scheduling algorithm:

2

$U={\sum }_{i=1}^n\frac{E_i}{T_i},$

3

$U<n\left(2^{1/n}-1\right)=L\left(n\right).$

The Eq. (3) can be used to calculate that when the number of tasks $n\to \infty$, ${L\left(n\right)}_{max}$ the system’s CPU utilization reaches its maximum value of 69.31 %. The actual CPU utilization of the screw machine control system is measured as 58.2 %, which is lower than the bound, ensuring schedulability.

Based on the RM algorithm, this study proposes an improved scheduling algorithm called QRM, specifically designed for the task environment of an automatic screw machine control system, to better meet its real-time requirements. The QRM algorithm adopts a linear hybrid priority calculation method, which combines static task priority and dynamic deadline factor, and the weight coefficient $\xi$ is tuned based on industrial field experience ($\xi =$0.6 in this study). The task priority is calculated using Eq. (4):

4

$P_i=\xi Q+\left(1-\xi \right)D_i,$

where $D_i$ is the deadline of the task, and for periodic tasks $T_i=D_i$. The value of $P$ is set according to the nature of the task, with a higher $P$ indicating a higher priority for the task.

The dynamic waiting time judgment formula is shown in Eq. (5):

5

$N=D-E-W,$

where $N$ represents the remaining time that the automatic screw machine control system can wait for a real-time task, while $W$ denotes the time the task has already waited. To ensure that tasks do not miss their deadlines, Eq. (4) is used to determine which tasks can no longer wait on the current device. By analyzing the value of $N$, these tasks are identified and migrated to other devices for execution, avoiding the risk of exceeding the deadline.

Compared with RM and EDF algorithms, QRM takes into account both task periodicity and deadline urgency, and is more suitable for the screw fastening scenario with fixed periodicity and strict deadline; compared with the native Kubernetes scheduler, QRM reduces the scheduling latency by 72.4 % and eliminates deadline miss.

Based on the RM algorithm, this study proposes an improved scheduling algorithm called QRM, specifically designed for the task environment of an automatic screw machine control system, to better meet its real-time requirements. The operator assigns a $Q$ value to each type of real-time task based on experience, and the task priority is calculated using Eq. (4), ensuring both the timeliness and efficiency of task scheduling.

3.3. Kubernetes platform setup

3.3.2. Cluster planning

As shown in Table 2, this study proposes the corresponding server hardware configurations for different deployment environments. The specific hardware configurations vary between the testing environment and the production environment.

During the operating system initialization phase, a series of steps must be performed to ensure optimal system performance and security. These steps include disabling the firewall, SELinux, and Swap, adding entries to the Hosts file, adjusting kernel parameters, and synchronizing system time. For the testing environment, we will configure the local virtual machines according to the recommended settings for the testing environment to ensure consistency in development and testing. As shown in Fig. 9, the example code for deploying the Docker engine on the Node is provided.

Fig. 8Single Master cluster architecture diagram

Table 2Set up the configuration requirements table for the local and production environments

Server configuration requirements
Local test environment	Master/Node	CPU	2 Cores
		Memory	4 GB
		Hard disk	40 GB
Production environment	Master	CPU	8 Cores
		Memory	16 GB
		Hard disk	100 GB
	Node	CPU	16 Cores
		Memory	64 GB
		Hard disk	500 GB

Fig. 9Sample code for node deployment docker containers

3.3.4. Deploying dashboard

The Kubernetes Dashboard is a web-based user interface that allows users to interact directly with the Kubernetes cluster. Through the dashboard, users can easily deploy containerized applications, troubleshoot them, and manage the entire cluster and its related resources. The dashboard provides an intuitive view that enables users to get an overview of the applications running on the cluster, as well as create or modify individual Kubernetes resources such as Deployments, Jobs, DaemonSets, etc. For example, users can use the deployment wizard to scale an existing deployment, initiate a rolling update, restart Pods, or deploy new applications. Additionally, the dashboard provides detailed information about the status of Kubernetes resources in the cluster, as well as any errors that may occur, helping users better monitor and maintain the health of the cluster.

As shown in Fig. 10, when operating on the Master1 node, after uploading the recommended.yaml file to the /opt/k8s directory, a service account is created and bound to the default cluster-admin cluster role [26].

Fig. 10Create a service account and add the administrator sample code

The Kubernetes cloud platform uses the Heapster container cluster monitoring and performance analysis tool to visualize cluster resource data. Heapster retrieves resource information from all Node nodes by calling the Kubernetes cluster API server and collects data from the cAdvisor on the Master node’s kubelet [27]. This data is pushed to the backend service module for storage and then visualized on the frontend cloud platform resource display interface. As shown in Fig. 11, the Kubernetes frontend interface displays information about the host, including system information, the number of containers, CPU usage, memory usage, and more.

Fig. 11Kubernetes host information

Nodes are the machines in a Kubernetes cluster, which can be either virtual machines or physical machines. As shown in Fig. 12, in the Dashboard, you can view the status of each node, resource usage (CPU and memory), Pods distribution, and other information. Additionally, you can view detailed information about the nodes, including the Pods running on the node and the events associated with the node.

In Kubernetes, a Pod is the smallest deployable unit and can contain one or more containers. As shown in Fig. 13, through the Kubernetes Dashboard, you can view detailed information about Pods, including their status, restart count, IP address, running containers, and resource usage. Additionally, you can perform actions on Pods, such as restarting, deleting, or viewing logs.

Machinekit is a tool used for controlling CNC machines, and it can run on Kubernetes. As shown in Fig. 14, in the Kubernetes Dashboard, you can view the status and configuration of the Machinekit application running on the Kubernetes cluster. This includes resources such as Machinekit’s Deployments, Services, Pods, and more, as well as their logs and monitoring data. Through the Dashboard, you can manage and monitor the operation of Machinekit on Kubernetes, ensuring the stable operation of automated screw machines.

Fig. 12Information about Kubernetes nodes

Fig. 13Information about Kubernetes pods

Fig. 14Machinekit runs on the Kubernetes platform

4.1. Construction of test platform

The main hardware components of the automated screw machine include: the BeagleBone Black [28] development board, stepper motor drivers, stepper motors, servo motors, switch power supplies, touchscreens, relays, and more. As shown in Fig. 15, the BeagleBone Black development board, stepper motor drivers, relays, and other components are connected to the 12V output of the switch power supply. The input of the switch power supply is connected to the AC servo motor driver, which is then connected to the 220V power source. The I/O outputs of the BeagleBone Black development board are connected to the inputs of the stepper motor driver, including pulse and direction signals. Finally, the stepper motor and AC servo motor are connected to the corresponding outputs of their respective drivers, and the motor phase sequence is checked. The computer is connected to the BeagleBone Black development board, and the Machinekit software is configured to ensure proper communication for initial setup and debugging.

Container overhead test: Compared with bare-metal deployment, LXD container increases CPU overhead by 2.1 %, memory overhead by 3.5 %, and I/O latency by 1.2 ms, which meets the real-time requirements of resource-constrained embedded hardware.

The test platform for this study consists of three automated screw machine prototypes. Each automated screw machine is equipped with a fixture on the $Y$-axis, which can hold two workpieces. The electric screwdriver uses a Leadshine ACM1H-0604 servo motor, and the driver is a Leadshine L5P-400 servo driver. The electric screwdriver parameters are set to a torque of 0.4 N·m and a speed of 800 rpm.

Fig. 15Machinekit control system circuit construction

The test adopts a controlled variable design: 3 screw machines run simultaneously (As shown in Fig. 16), each workpiece fastens 4 screws, test duration is 6 hours, 5 repeated trials are carried out, and the average value is taken for statistical analysis. The workload is fixed (camera front housing bearing cover), and the only variable is the management mode (manual vs Kubernetes+QRM).

Fig. 16Automatic screw machining platform physical picture

As shown in Fig. 17, a screw locking test was conducted on the bearing cover of the camera front housing.

Fig. 17Camera front cover screw lock pay physical picture

4.2. Test results and analysis

4.2.1. Kubernetes cluster management system test

Response time testing is crucial for the Kubernetes-based automated screw machine cluster management system, as it directly impacts the system's real-time performance and overall production efficiency. This type of testing ensures that the system can quickly adapt to changes and demands in the production process, schedule and execute tasks in a timely manner, and meet the real-time requiremeFigurents of automated screw machine control [29].

The native Kubernetes scheduler lacks real-time performance. Traditional RM (Rate Monotonic) sets priority only by task period, which cannot handle deadline-sensitive tasks. This paper proposes QRM (Quick Rate Monotonic).

As shown in 18, the average response time accessed through Cluster IP on the Kubernetes cluster node is 3.1 ms. Through testing, we can verify the effectiveness and real-time performance of the QRM scheduling algorithm, ensuring that tasks are completed before the deadline, thereby improving production efficiency. Additionally, response time testing helps identify system performance bottlenecks, optimize resource allocation, improve resource utilization, and reduce idle and waiting times. This is crucial for the stability and reliability of the system [30], as it ensures the system can maintain stable operation under varying loads and conditions. The test results also demonstrate the system’s ability to recover quickly in the event of a failure, which is vital for minimizing production downtime and enhancing production efficiency. Meanwhile, response time testing is also essential for quality control, as it ensures the accuracy of the automated screw machine's fastening process, reduces missed or incorrect locks, and improves product quality. Through this testing, users can verify the advantages of the Kubernetes management model over traditional manual management in terms of improving production efficiency and provide data support for the system’s continuous improvement.

Fig. 18Test the response time of the host and Node

Network performance testing is a core component in ensuring that the network meets established performance standards and supports critical business applications. By evaluating key metrics such as data transmission rate, latency, throughput, and packet loss rate, users can gain deep insights into the network’s actual performance. These tests not only help identify potential performance bottlenecks but also verify the accuracy of network configurations, check network security, and quickly locate and resolve network issues.

As shown in Fig. 19, the network performance of Flannel’s VXLAN mode (between pods) incurs a 34 % loss compared to direct host-to-host connectivity, which generally meets the network testing requirements (loss of 30 %-40 %).

Fig. 19Node Inter-node network test

Network performance testing is essential for ensuring the stability of network services, optimizing resource allocation, enhancing network reliability, and providing data support for decision-making. The test results enable organizations to make informed decisions regarding network upgrades, resource management, and business expansion. Additionally, network performance testing brings many benefits, including improving user experience, reducing costs, increasing maintenance efficiency, and effectively managing risks.

Fig. 20Automatic screw machine head path interface

a) Screw machine 1 batch head path interface

b) Screw machine 2 batch head path interface

c) Screw machine 3 batch head path interface

As shown in Fig. 20, the Kubernetes front-end interface displays the Machinekit operation interface of the running containers and the bit paths of the three screw machines. This visual representation of resources allows the working status of the automated screw machines to be more intuitively presented to the operators, helping them better plan the task allocation for the screw machine cluster.

4.3. Efficiency analysis of automatic screw machining

The processing efficiency of automated screw machines is crucial to the economic benefits and market competitiveness of the production process. It not only helps enterprises identify and solve production bottlenecks, reduce waste, and lower costs, but also ensures product quality consistency, reduces defects and rework, thus improving product quality. Additionally, efficiency analysis can optimize resource allocation and drive improvements in processing technology and manufacturing techniques.

Baseline and measurement method: The manual management mode is taken as the baseline, with the same hardware, workload and test duration; the number of completed workpieces is counted every 0.5 hours, and 5 repeated trials are carried out to eliminate random errors. Independent sample t-test is used for statistical analysis, and the difference is significant ($P<$0.05). Detailed data can be found in Table 3.

As shown in Fig. 21, the screw fastening data curves under the two management modes are plotted based on the data recorded in Table 3. The analysis shows that under the manual management mode, the average number of workpieces processed per screw machine in 0.5 hours is 35. However, under the Kubernetes management mode, the average number of workpieces processed per screw machine in 0.5 hours is 50. Over the same period, the Kubernetes management mode increased production efficiency by 42.86 % compared to the manual management mode.

As shown in Fig. 22, within 6 hours, by applying the Quick Response Manufacturing (QRM) scheduling algorithm, we monitored the number of workpieces processed by the three screw machines. In the initial phase (0-1 h), the processing quantity of the three machines remained relatively stable. As time progressed (2-3 h), the processing efficiency of each machine gradually improved, and the QRM scheduling algorithm effectively balanced the workload across the machines, avoiding resource waste. In the mid-phase (3-5 h), Screw Machine 2 experienced a brief equipment failure, leading to a decrease in processing quantity.

Fig. 21Screw machining data graph under two management modes

a) Screw machine 1 processing data diagram

b) Screw machine 2 processing data diagram

c) Screw machine 3 processing data diagram

Fig. 22Comparison of screw machining quantity under QRM scheduling algorithm

a) QRM scheduling algorithm is introduced before screw machining quantity diagram

b) Screw machining quantity after introducing QRM scheduling algorithm

However, the QRM scheduling algorithm redistributed the tasks within 100 ms, allowing Screw Machines 1 and 3 to compensate for this decline, thereby maintaining overall production efficiency. In the final phase (5-6 h), the processing quantities of all machines stabilized. Therefore, the QRM scheduling algorithm effectively improved the production efficiency of the three screw machines within the 6-hour period, ensuring the continuity and stability of the production process.

As shown in Fig. 23, a comparison is made between the manual management mode and the Kubernetes management mode, showing the number of workpieces completed by the three screw machines every 0.5 hours. The Kubernetes management mode has brought higher stability and reliability to the processing system, effectively reducing production interruptions caused by operational errors or human intervention. By ensuring the stability of the number of processed workpieces, Kubernetes significantly improved the production efficiency of the screw machines.

Fig. 23Statistical chart of screw machining data in each time period under two modes

4.4. Automatic screw machine locking accuracy analysis

In automated manufacturing, the accuracy of screw fastening is crucial for ensuring product quality, improving production efficiency, and reducing costs. This process directly impacts the reliability and safety of the product, as precise fastening ensures the structural stability and durability of the product. High fastening accuracy not only indicates efficient resource utilization in the production process but also reduces rework and scrap caused by incorrect fastenings, thus effectively saving costs. Therefore, by analyzing the screw fastening accuracy results based on the number of missed screws and different management modes, the screw fastening accuracy under the manual management mode and Kubernetes management mode are shown in Table 4 and Table 5, respectively.

After performing statistical analysis on the screw fastening accuracy under the manual management mode and the Kubernetes management mode, it can be concluded that in the Kubernetes management mode, the average growth rate of screw fastening quantity is 400 screws/hour, which is higher than the 283 screws/hour in the manual management mode. Furthermore, in the Kubernetes management mode, the average number of missed screws is approximately 0.57, and the average accuracy rate is 99.62 %. In contrast, the manual management mode has an average of about 2.62 missed screws and an average accuracy rate of 97.49 %. The calculation results show the variance of missed screws under both management modes:

As shown in Fig. 24, through statistical analysis of the number of missed screws under the manual management mode and the Kubernetes management mode, it was found that the average number of missed screws in the Kubernetes management mode is 0.57, which is significantly lower than the 2.62 screws in the manual management mode. The variance of missed screws in the Kubernetes management mode is 0.18, which is also much lower than the 1.19 in the manual management mode. Therefore, adopting the Kubernetes management mode can significantly reduce the number of missed screws in the production process, improving production efficiency and product quality.

Fig. 24Screw lock with accuracy box type drawing

As shown in Fig. 25, under the manual management mode, after a 0.5-hour test period, the screw fastening accuracy of all three screw machines was no lower than 97.97 %. Moreover, as the test progressed, the accuracy improved and mostly remained above 98 %. However, due to factors such as inconsistency in manual operations or operator fatigue, there were slight declines in accuracy during specific time periods (0-0.5 h, 5-5.5 h). In contrast, under the Kubernetes management mode, during the same test period, the screw fastening accuracy of all three machines exceeded 99 %, with perfect 100 % accuracy achieved in multiple time periods. Throughout the entire test, the Kubernetes management mode demonstrated higher stability and achieved 100 % accuracy in several intervals, clearly showing the significant advantage of the Kubernetes management mode in improving fastening accuracy.

Fig. 25Comparison of the number and accuracy of screw locks

a) The number and accuracy of screw lock before introducing QRM scheduling algorithm

b) The number and accuracy of screw lock after QRM scheduling algorithm is introduced

Through comparative analysis, it can be concluded that the Kubernetes management mode shows a significant advantage over traditional manual management in improving screw fastening accuracy. Its automation and intelligent scheduling capabilities result in more stable fastening accuracy, achieving 100 % accuracy in most test periods. This effectively reduces human errors, enhances production efficiency and product quality, and demonstrates the potential of automation management technology to improve production stability and reliability in modern manufacturing.