Examination system and examination deployment method based on cloud computing and k8s cluster deployment

Abstract

Provided in the present invention are an examination system and examination deployment method based on cloud computing and K8s cluster deployment. The system comprises: a content delivery network (CDN): caching static resources in the examination system into a global node server of the CDN, such that users can proximally access and load the static resources during examination; an access control list (ACL): controlling a request source; a website application firewall (WAF): scanning a user request, matching same with a behavior feature library of a cloud computing platform, if an abnormal or threatening behavior is matched, intercepting the user request, otherwise, releasing the user request; and a server load balancer (SLB): forwarding the user request to a K8s cluster, distinguishing same and then forwarding same to a corresponding service. The present invention uses the cloud computing platform and the K8S cluster to deploy the examination system, thus greatly improving the load capacity, observability and security of the examination system.

Description

Examination system and examination deployment method based on cloud computing and K8s cluster deployment Technical Field

[0001] The present invention relates to the technical field of cloud computing and K8s cluster, and in particular to an examination system and an examination deployment method based on cloud computing and K8s cluster deployment. Background Art

[0002] Traditional examination systems are mostly deployed in local computer rooms and are only for internal access, unable to provide external services; traditional examination systems are mostly deployed in a bare-bones manner, making operations such as operation and maintenance and upgrades more cumbersome; traditional examination systems are not perfect at the monitoring level and cannot provide more complete underlying system monitoring data; traditional examination systems cannot use new technology products provided by cloud computing at a relatively low cost, such as k8s clusters and unified file storage services.

[0003] When using cloud computing services, they are often exposed to the public, posing security risks. Since the exam system is for school use and not accessible to external users, access to cloud computing services needs to be restricted to specific schools. This is typically achieved using a VPN or dedicated line, but this is costly and difficult to maintain. However, ACL-based access control can achieve this requirement at zero cost. By collecting the public IP addresses of each campus and adding them to the ACL whitelist, only schools on the whitelist can access the cloud computing services.

[0004] Patent document CN115499310A (application number: CN202211038600.8) discloses a method and system for cloud-based business application migration based on a cloud computing platform container service, belonging to the field of cloud computing platforms. The specific steps of the method described are as follows: S1 creates a Kubernetes container service, produces a program application package and a Docker image; S2 selects a Kubernetes cluster service based on the business scenario and submits an application; S3 utilizes Kustomize packages, Docker images, and Chart packages for deployment to meet the needs of containerized cloud migration of business applications; S4 performs full lifecycle management of deployed and released applications. However, this patent fails to solve existing technical problems and fails to meet the requirements of the present invention.

[0005] Summary of the Invention

[0006] In view of the defects in the prior art, the purpose of the present invention is to provide an examination system and examination deployment method based on cloud computing and K8s cluster deployment.

[0007] The examination system based on cloud computing and K8s cluster deployment provided by the present invention includes:

[0008] Content Delivery Network (CDN): Caches static resources in the exam system to CDN's global node servers, allowing users to access and load static resources locally during the exam.

[0009] Access Control List (ACL): controls the source of requests;

[0010] Website Application Firewall (WAF): Scans user requests and matches them against the cloud computing platform's behavioral signature database. If an abnormal or threatening behavior is matched, the user request is intercepted; otherwise, the user request is allowed to proceed.

[0011] Load balancing SLB: forwards user requests to the K8s cluster, differentiates them, and then forwards them to the corresponding services.

[0012] Preferably, the K8s cluster includes: Concerto SVC, rStudio SVC and Shiny SVC;

[0013] Concerto SVC provides test questions and saves test results. rStudio SVC obtains Concerto SVC test results through a pre-written program and provides a query method. Finally, the pre-written program is run in Shiny SVC for score query.

[0014] The Concerto SVC includes: building a test system using the open source software Concerto, deploying Concerto SVC on a Kubernetes cluster to expose Concerto Pod services and evenly forwarding user requests to the corresponding Concerto Pods on the backend; when an abnormality occurs on the backend Concerto Pod, Concerto SVC removes the abnormal Concerto Pod from the SVC; when the backend Concerto Pod returns to normal, Concerto SVC re-adds the normal Concerto Pod to the SVC to continue processing user requests;

[0015] The Concerto Pod is a minimal entity that runs the Concerto open source software. The Pod can run in multiple copies. The more copies there are, the better the performance of Concerto SVC.

[0016] Preferably, when a student user accesses the examination system to take an examination, Concerto SVC forwards the student user's request to Concerto Pod for load balancing. Concerto Pod stores the student user's data in the relational database module RDS, and stores the examination resource files in the network attached storage module NAS. The data in the NAS module is read and used by all Concerto Pods. Concerto Pod runs on the ECS cluster, and the ECS cluster provides resources to Concerto Pod. ECS is the underlying physical resource pool of the K8s cluster. K8s abstracts the CPU, memory and storage space of the ECS cluster into a resource pool. When a Pod needs to be created, resources are drawn from the resource pool to run the Pod.

[0017] Preferably, after the test, all data is stored in the RDS database in the form of metadata. When developers query data, they first access the rStudio SVC service of the K8s cluster, which forwards the request to the rStudio Pod for processing. R language program code is written based on the rStudio Pod, and the program code is stored in NAS. The R language program code is used to read data from the RDS database and display it in the form of a GUI on the web page for data query.

[0018] Preferably, the R language program code is developed by rStudio Pod and stored in NAS, and the R language program code written by rStudio Pod is read and run in Shiny Pod sharing;

[0019] The teacher accesses Shiny SVC to check student test scores. Shiny SVC forwards the request to Shiny Pod for processing. Shiny Pod provides a web runtime environment for the R language and accesses NAS, databases, and web pages based on the resources provided by the ECS cluster.

[0020] The examination deployment method based on cloud computing and K8s cluster provided by the present invention includes:

[0021] Step 1: Use the Content Delivery Network (CDN) to cache static resources in the exam system to CDN's global node servers, allowing users to access and load static resources locally during the exam.

[0022] Step 2: Control the request source through the access control list (ACL);

[0023] Step 3: The website application firewall (WAF) scans the user request and matches it with the behavior signature library of the cloud computing platform. If an abnormal or threatening behavior is matched, the user request is blocked; otherwise, the user request is allowed to proceed.

[0024] Step 4: The load balancing SLB forwards the user request to the K8s cluster, differentiates it, and forwards it to the corresponding service.

[0025] Preferably, the K8s cluster includes: Concerto SVC, rStudio SVC and Shiny SVC;

[0026] Concerto SVC provides test questions and saves test results. rStudio SVC obtains Concerto SVC test results through a pre-written program and provides a query method. Finally, the pre-written program is run in Shiny SVC for score query.

[0027] The Concerto SVC includes: building a test system using the open source software Concerto, deploying Concerto SVC on a Kubernetes cluster to expose Concerto Pod services and evenly forwarding user requests to the corresponding Concerto Pods on the backend; when an abnormality occurs on the backend Concerto Pod, Concerto SVC removes the abnormal Concerto Pod from the SVC; when the backend Concerto Pod returns to normal, Concerto SVC re-adds the normal Concerto Pod to the SVC to continue processing user requests;

[0028] The Concerto Pod is a minimal entity that runs the Concerto open source software. The Pod can run in multiple copies. The more copies there are, the better the performance of Concerto SVC.

[0029] Preferably, when a student user accesses the examination system to take an examination, Concerto SVC forwards the student user's request to Concerto Pod for load balancing. Concerto Pod stores the student user's data in the relational database module RDS, and stores the examination resource files in the network attached storage module NAS. The data in the NAS module is read and used by all Concerto Pods. Concerto Pod runs on the ECS cluster, and the ECS cluster provides resources to Concerto Pod. ECS is the underlying physical resource pool of the K8s cluster. K8s abstracts the CPU, memory and storage space of the ECS cluster into a resource pool. When a Pod needs to be created, resources are drawn from the resource pool to run the Pod.

[0030] Preferably, after the test, all data is stored in the RDS database in the form of metadata. When developers query data, they first access the rStudio SVC service of the K8s cluster, which forwards the request to the rStudio Pod for processing. R language program code is written based on the rStudio Pod, and the program code is stored in NAS. The R language program code is used to read data from the RDS database and display it in the form of a GUI on the web page for data query.

[0031] Preferably, the R language program code is developed by rStudio Pod and stored in NAS, and the R language program code written by rStudio Pod is read and run in Shiny Pod sharing;

[0032] The teacher accesses Shiny SVC to check student test scores. Shiny SVC forwards the request to Shiny Pod for processing. Shiny Pod provides a web runtime environment for the R language and accesses NAS, databases, and web pages based on the resources provided by the ECS cluster.

[0033] Compared with the prior art, the present invention has the following beneficial effects:

[0034] (1) The examination system is deployed on a cloud computing platform and Kubernetes cluster, which greatly improves the load capacity, observability, and security of the examination system;

[0035] (2) By deploying the examination system using a cloud computing platform, mainstream technologies such as CDN and WAF can be used at a very low cost compared to the traditional deployment method of building a computer room. This also speeds up website access and enhances website security.

[0036] (3) By deploying the examination system through the Kubernetes cluster, compared with the traditional physical machine deployment method, it is possible to cluster and manage the various services of the examination system at a very low cost, elastically scale the number of replicas, and view the real-time load status of each service. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] Other features, objects and advantages of the present invention will become more apparent upon reading the detailed description of non-limiting embodiments with reference to the following drawings:

[0038] FIG1 is a framework diagram of the examination system of the present invention. DETAILED DESCRIPTION

[0039] The present invention will be described in detail below with reference to specific embodiments. The following examples will help those skilled in the art to further understand the present invention, but are not intended to limit the present invention in any form. It should be noted that, for those skilled in the art, several changes and improvements can be made without departing from the scope of the present invention. These all fall within the scope of protection of the present invention.

[0040] Example:

[0041] When deploying Concerto through K8s and testing it, it was found that when there are multiple Pod copies of Concerto and the load balancing polling strategy is used, when a user logs in and then refreshes the page, the user's request will be forwarded to another Pod copy. However, the Pod copy does not have the session data of the user after logging in, so the page will jump to the user login page instead of the logged-in page. This problem is usually called "Session state is not shared". Of course, this problem is also caused by Concerto using a stateful session instead of a stateless token. To solve this problem, you only need to add a strategy to the load balancing, that is, identification and forwarding based on client cookies. Simply put, the load balancing will mark the client with a cookie and record the cookie forwarded to a Pod copy of a backend, forming a one-to-one relationship. When there is another client request, the client's cookie will be used to determine which Pod copy to forward the request to. If the client does not have a cookie, the new cookie is marked and forwarded to the next Pod replica using the polling strategy. If the client has a cookie, the corresponding Pod replica is found according to the relationship table between cookies and Pod replicas and forwarded to the corresponding Pod replica. In this way, the user's login status will not be lost and the load balancing polling strategy is still maintained.

[0042] The solution to the "Session state is not shared" problem is to add a configuration of nginx.ingress.kubernetes.io / affinity:Cookie.

[0043] In traditional deployments, rStudio and Shiny are typically deployed on the same server, making file sharing relatively simple. Specifically, if rStudio and Shiny are configured to use the same file directory, R files developed in rStudio can be directly shared with Shiny for web display. However, in the Kubernetes architecture, rStudio and Shiny run in separate Docker containers, isolating their resources. While it's possible to share data between Pod replicas on the host's ECS instance by sharing a directory on the host, when there are multiple Pod replicas, rStudio and Shiny may not be on the same host ECS instance. Therefore, R files developed in rStudio cannot be shared with Shiny. To address this issue, we introduced a "third-party" role, namely NAS file storage. Using NAS file storage, a directory is shared between rStudio and Shiny. This allows rStudio and Shiny to share a common directory, allowing simultaneous reading and writing regardless of the number of Pod replicas.

[0044] The specific configuration steps are:

[0045] (1) Create a NAS-based data volume named rstudio-data.

[0046] (2) Mount the data volume to the / home / rstudio path of rStudio. After mounting, rStudio stores the data files in this path, which is equivalent to storing them in NAS.

[0047] (3) Mount the same data volume to Shiny's / src / shiny-server path. After mounting, Shiny reads the files in the / src / shiny-server path, which is equivalent to reading the files in NAS.

[0048] This means that based on the third-party role of NAS, rStudio and Shiny, two originally independent containers, can share file directories and can be cross-host. For example, rStudio is on host A, and Shiny is on host B, but they can still share files through NAS.

[0049] As shown in Figure 1, the examination system deployed through the cloud computing platform and Kubernetes cluster mainly includes:

[0050] Content Delivery Network (CDN): Full name: Content Deliver Network. It can cache static resources in the examination system, such as CSS, JS, jpg, and other resources, to the CDN's global node servers. Users of the examination system can access them nearby and load static resources faster, avoiding the need for all requests to be processed by the examination system's source station, thereby reducing the pressure on the examination system's source station.

[0051] Access Control List (ACL): This short for Access Control List, controls the source of requests, such as prohibiting requests from a specific public IP address or allowing only requests from specific public IP addresses. CDNs also support ACLs and provide comprehensive request statistics, making it easier to query and assess the load on the exam system.

[0052] The Web Application Firewall (WAF) scans user requests and matches them against the cloud computing platform's own behavioral signature library. If a match is found for unusual or threatening behavior, the request is intercepted, preventing it from reaching the exam system's origin server. If no anomalies are detected, the request is allowed. The core of this module is the behavioral signature library, which relies on a massive, accurate, and real-time updated set of behavioral characteristics. This is the strength of the cloud computing platform, something that in-house firewalls cannot match. Therefore, this module significantly enhances the security of the exam system.

[0053] Server Load Balancer (SLB): This forwards user requests to the Kubernetes cluster. Because a Kubernetes cluster contains many different services, the SLB must differentiate user requests and forward them to the appropriate service. Differentiating services uses different domain names. For example, the domain name for the Concerto SVC is concerno.example.com, while the domain name for the rStudio SVC is rstudio.example.com. The SLB forwards requests to different services based on the domain name.

[0054] The path of user requests is: client → CDN → ACL → WAF → SLB.

[0055] Kubernetes cluster: A next-generation virtualization solution that runs as a cluster, capable of hosting massive business systems while providing complete service lifecycle management and observability. The exam system's subsystems run in a Kubernetes cluster, including Concerto SVC, rStudio SVC, Shiny SVC, and the pods corresponding to each SVC.

[0056] Concerto SVC: The full name is Concerto Service. Concerto is open source software, mainly used to build a test system. The traditional deployment method of Concerto is to deploy Concerto directly on a physical server. Although the deployment method is simple, the maintenance cost is high when facing high elasticity pressure. In contrast, when deploying Concerto SVC on a Kubernetes cluster, although the deployment threshold is relatively high, it can run automatically for a long time after deployment, reducing a lot of maintenance costs. The main function of Concerto SVC is to expose the services of Concerto Pod and forward user requests evenly to the backend Concerto Pod; when the backend Concerto Pod is abnormal, Concerto SVC will remove the abnormal Concerto Pod from SVC to prevent users from continuing to request the abnormal Pod; when the backend Concerto Pod returns to normal, Concerto SVC will re-add the normal Concerto Pod to SVC to continue processing user requests.

[0057] rStudio SVC: full name rStudio Service, i.e. rStudio service.

[0058] RStudio is open source software. Developers can write R programs to read Concerto data from the database and display and query it. Its SVC and Pod principles are the same as those of Concerto SVC and Concerto Pod.

[0059] Shiny SVC: full name Shiny Service, that is, Shiny service.

[0060] Shiny is open source software that provides a web-based runtime environment for R packages. R packages written in rStudio SVC are shared with Shiny SVC via NAS, which then runs the R packages via the web. Concerto SVC, rStudio SVC, and Shiny SVC collaborate in this way: Concerto SVC provides exam questions and stores exam results, while rStudio SVC writes programs that retrieve Concerto SVC's exam results, providing various query methods. Finally, Shiny SVC runs the programs, allowing teachers to check scores. The principles of SVC and Pod are the same as those described above for Concerto SVC and Concerto Pod.

[0061] Student side:

[0062] When a student user accesses the examination system to take an exam, Concerto SVC forwards the student user's request to Concerto Pod (Concerto1, Concerto2, ...., ConcertoX) for load balancing. Concerto Pod ultimately processes the student user's request. Concerto Pod stores the student user's data (behavioral data, personal information, exam data) in the RDS database module, while some images, audio and video resources such as those used in the exam are stored in the NAS module. The data in the NAS module is read and used by all Concerto Pods, avoiding data inconsistencies between multiple Concerto Pods. Concerto Pods (all Pods are similar) actually run on the ECS cluster, which provides CPU, memory, network and other resources to Concerto Pods.

[0063] Developer:

[0064] After students take the exam, all data is stored in the RDS database as metadata, which is not convenient for the school to access. To query the exam data visually, developers will access the rStudio SVC service of the Kubernetes cluster, which then forwards the request to the rStudio Pod (a web-based R language code development tool, a Web IDE) for final processing. Developers will write R language program code based on the rStudio Pod, and the program code is stored in the NAS. The R language program code mainly reads data from the RDS database and displays it on the web page in the form of a GUI. Data can be queried by querying the student ID, teacher name, etc.

[0065] Teacher side:

[0066] After the R language program code is developed using the rStudio Pod, it will be stored in the NAS. Since they are all in the same Kubernetes cluster and use the same NAS, Shiny Pod (an environment that can run the R language) can share and read the R language program code written by the rStudio Pod and run it.

[0067] Therefore, the teacher accesses Shiny SVC to check the student's test scores, and Shiny SVC forwards the request to Shiny Pod for final processing. Shiny Pod provides a web runtime environment for the R language, and at the same time accesses NAS, accesses databases, displays web pages, etc. based on the CPU, memory, network and other resources provided by the ECS cluster.

[0068] Concerto Pod: The smallest unit that runs the Concerto open source software and is the terminal that actually processes user requests. The underlying pod is a Docker container that encapsulates the Concerto runtime environment. A pod can run in multiple copies, also known as replicas. The more replicas, the better the Concerto SVC performance.

[0069] rStudio Pod: The principle is the same as the above Concerto Pod.

[0070] Shiny Pod: The principle is the same as the Concerto Pod mentioned above.

[0071] ECS: Elastic Compute Service, also known as Elastic Compute Service, is a virtualized computing server provided by cloud computing platforms and can be compared to traditional physical servers. Although there are some improvements compared to traditional physical servers, ECS servers are still relatively independent, and clustered management and scheduling are difficult. In the architecture, ECS serves as the underlying physical resource pool of the Kubernetes cluster. That is, Kubernetes is used to manage multiple ECSs. In this way, multiple ECSs are called ECS clusters, and the Kubernetes above is called a Kubernetes cluster. Kubernetes abstracts the CPU, memory, and storage space of the ECS cluster into a resource pool. When a Pod needs to be created, some resources are extracted from the resource pool to run the Pod.

[0072] RDS: Relationship Database Service. This module is primarily used to store metadata related to the exam system, such as exam question data and score data.

[0073] NAS (Network Attached Storage) is a module that provides shared storage for the three SVCs in the exam system. For example, files created in the rStudio SVC can be directly read in the Shiny SVC.

[0074] Examination systems are usually attended by candidates in a concentrated manner, so capacity (also called load capacity) is a key performance indicator. Unknown or unpredictable loads are one of the challenges of modern application services. Common approaches to this are: 1. Providing 1-2 times the peak capacity to reduce costs; 2. Providing 2-N times the peak capacity to ensure availability, ignoring costs. Examinations fit this situation perfectly, with centralized requests and unpredictable loads. In the future, the examination system may be open to non-campus participants. To cope with unknown system capacity, while taking costs into consideration and reducing manual configuration work, before initially deploying the Concerto system, consideration was given to using a Kubernetes cluster to host the Concerto examination system. This way, the elastic scaling replica function of Kubernetes could be utilized. This feature is provided by the Kubernetes system and is implemented by: 1. Specifying the CPU and memory usage of the Concerto Pod; 2. Enabling autoscaling for the Concerto Pod and configuring the maximum number of replicas and the scaling metric. The scaling metric is memory or CPU usage. For example, if CPU usage exceeds 80%, add one replica; or if memory usage reaches 100%, add one replica. The Kubernetes system monitors the Concerto Pod's resource usage and triggers scaling if usage reaches the trigger metric. Once configured, all this is handled automatically by the Kubernetes system, requiring no human intervention.

[0075] Those skilled in the art will appreciate that, in addition to implementing the system, device, and various modules provided by the present invention in purely computer-readable program code, it is entirely possible to implement the same program in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, embedded microcontrollers, and the like by logically programming the method steps. Therefore, the system, device, and various modules provided by the present invention can be considered a hardware component, and the modules included therein for implementing various programs can also be considered structures within the hardware component; the modules for implementing various functions can also be considered both software programs for implementing the method and structures within the hardware component.

[0076] The above describes specific embodiments of the present invention. It should be understood that the present invention is not limited to the specific embodiments described above, and those skilled in the art may make various changes or modifications within the scope of the claims, which do not affect the essence of the present invention. The embodiments of this application and the features in the embodiments may be combined with each other in any manner unless there is a conflict.

Claims

1. An examination system based on cloud computing and K8s cluster deployment, characterized in that: include: Content Delivery Network (CDN): Cache static resources in the examination system to the CDN's global node servers, so that users can access and load static resources nearby during the examination. Access Control List (ACL): controls the source of requests; Website Application Firewall (WAF): Scans user requests and matches them with the behavior feature library of the cloud computing platform. If abnormal or threatening behavior is matched, the user request is intercepted; otherwise, the user request is released. Load balancing SLB: forwards user requests to the K8s cluster, differentiates them, and then forwards them to the corresponding services.

2. According to the examination system based on cloud computing and K8s cluster deployment according to claim 1, it is characterized in that: The K8s cluster includes: Concerto SVC, rStudio SVC and Shiny SVC; Concerto SVC provides test questions and saves test results. rStudio SVC obtains Concerto SVC test results through a pre-written program and provides a query method. Finally, the pre-written program is run in Shiny SVC for score query. The Concerto SVC includes: building a test system through the open source software Concerto, deploying Concerto SVC on the K8s cluster to expose the services of Concerto Pod, and evenly forwarding user requests to the corresponding Concerto Pod in the backend; when the Concerto Pod in the backend is abnormal, Concerto SVC removes the abnormal Concerto Pod from SVC; when the Concerto Pod in the backend returns to normal, Concerto SVC re-adds the normal Concerto Pod to SVC to continue processing user requests; The Concerto Pod is a minimal entity that runs the Concerto open source software. The Pod can run in multiple copies. The more copies there are, the better the performance of the Concerto SVC.

3. According to the examination system based on cloud computing and K8s cluster deployment according to claim 2, it is characterized in that: When a student user accesses the examination system to take an examination, Concerto SVC forwards the student user's request to Concerto Pod for load balancing. Concerto Pod stores the student user's data in the relational database module RDS and stores the examination resource files in the network attached storage module NAS. The data in the NAS module is read and used by all Concerto Pods. Concerto Pod runs on the ECS cluster, and the ECS cluster provides resources to Concerto Pod. ECS is the underlying physical resource pool of the K8s cluster. K8s abstracts the CPU, memory, and storage space of the ECS cluster into a resource pool. When a Pod needs to be created, resources are drawn from the resource pool to run the Pod.

4. According to the examination system based on cloud computing and K8s cluster deployment according to claim 2, it is characterized in that: After the exam, all data will be stored in the RDS database in the form of metadata. When developers query data, they first access the rStudio SVC service of the K8s cluster, which forwards the request to the rStudio Pod for processing. R language program code is written based on the rStudio Pod and stored in the NAS. The R language program code is used to read data from the RDS database and display it in the form of a GUI on the web page for data query.

5. According to the examination system based on cloud computing and K8s cluster deployment according to claim 2, it is characterized in that: After the R language program code is developed by rStudio Pod and stored in NAS, the R language program code written by rStudio Pod can be read and run in Shiny Pod sharing; The teacher accesses Shiny SVC to check the student's test scores. Shiny SVC forwards the request to Shiny Pod for processing. Shiny Pod provides a web operating environment for the R language and accesses NAS, databases, and web pages based on the resources provided by the ECS cluster.

6. A test deployment method based on cloud computing and K8s cluster, characterized in that: include: Step 1: Use the content delivery network (CDN) to cache static resources in the test system to CDN's global node servers, so that users can access and load static resources nearby during the test; Step 2: Control the request source through the access control list ACL; Step 3: Scan the user request through the website application firewall WAF and match it with the behavior feature library of the cloud computing platform. If an abnormal or threatening behavior is matched, the user request is blocked; otherwise, the user request is released; Step 4: The user request is forwarded to the K8s cluster through the load balancing SLB, and then forwarded to the corresponding service after differentiation.

7. The test deployment method based on cloud computing and K8s cluster according to claim 6 is characterized in that: The K8s cluster includes: Concerto SVC, rStudio SVC and Shiny SVC; Concerto SVC provides test questions and saves test results. rStudio SVC obtains Concerto SVC test results through a pre-written program and provides a query method. Finally, the pre-written program is run in Shiny SVC for score query. The Concerto SVC includes: building a test system through the open source software Concerto, deploying Concerto SVC on the K8s cluster to expose the services of Concerto Pod, and evenly forwarding user requests to the corresponding Concerto Pod in the backend; when the Concerto Pod in the backend is abnormal, Concerto SVC removes the abnormal Concerto Pod from SVC; when the Concerto Pod in the backend returns to normal, Concerto SVC re-adds the normal Concerto Pod to SVC to continue processing user requests; The Concerto Pod is a minimal entity that runs the Concerto open source software. The Pod can run in multiple copies. The more copies there are, the better the performance of the Concerto SVC.

8. The test deployment method based on cloud computing and K8s cluster according to claim 7 is characterized in that: When a student user accesses the examination system to take an examination, Concerto SVC forwards the student user's request to Concerto Pod for load balancing. Concerto Pod stores the student user's data in the relational database module RDS and stores the examination resource files in the network attached storage module NAS. The data in the NAS module is read and used by all Concerto Pods. Concerto Pod runs on the ECS cluster, and the ECS cluster provides resources to Concerto Pod. ECS is the underlying physical resource pool of the K8s cluster. K8s abstracts the CPU, memory, and storage space of the ECS cluster into a resource pool. When a Pod needs to be created, resources are drawn from the resource pool to run the Pod.

9. The test deployment method based on cloud computing and K8s cluster according to claim 7 is characterized in that: After the exam, all data will be stored in the RDS database in the form of metadata. When developers query data, they first access the rStudio SVC service of the K8s cluster, which forwards the request to the rStudio Pod for processing. R language program code is written based on the rStudio Pod and stored in the NAS. The R language program code is used to read data from the RDS database and display it in the form of a GUI on the web page for data query.

10. The test deployment method based on cloud computing and K8s cluster according to claim 7, characterized in that: After the R language program code is developed by rStudio Pod and stored in NAS, the R language program code written by rStudio Pod can be read and run in Shiny Pod sharing; The teacher accesses Shiny SVC to check the student's test scores. Shiny SVC forwards the request to Shiny Pod for processing. Shiny Pod provides a web operating environment for the R language and accesses NAS, databases, and web pages based on the resources provided by the ECS cluster.

Images