CN118069217A - Radar software and hardware decoupling architecture implementation method based on container technology - Google Patents
Radar software and hardware decoupling architecture implementation method based on container technology Download PDFInfo
- Publication number
- CN118069217A CN118069217A CN202410170937.7A CN202410170937A CN118069217A CN 118069217 A CN118069217 A CN 118069217A CN 202410170937 A CN202410170937 A CN 202410170937A CN 118069217 A CN118069217 A CN 118069217A
- Authority
- CN
- China
- Prior art keywords
- container
- image
- software
- radar
- server
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 33
- 238000005516 engineering process Methods 0.000 title claims abstract description 26
- 238000012544 monitoring process Methods 0.000 claims abstract description 33
- 230000006870 function Effects 0.000 claims abstract description 25
- 238000012545 processing Methods 0.000 claims description 14
- 238000009434 installation Methods 0.000 claims description 4
- 230000003993 interaction Effects 0.000 claims description 4
- 238000011161 development Methods 0.000 description 16
- 238000012423 maintenance Methods 0.000 description 16
- 238000012360 testing method Methods 0.000 description 12
- 230000009286 beneficial effect Effects 0.000 description 7
- 238000013461 design Methods 0.000 description 6
- 230000000694 effects Effects 0.000 description 4
- 230000002708 enhancing effect Effects 0.000 description 4
- 230000001965 increasing effect Effects 0.000 description 4
- 230000005012 migration Effects 0.000 description 4
- 238000013508 migration Methods 0.000 description 4
- 230000005540 biological transmission Effects 0.000 description 3
- 230000007613 environmental effect Effects 0.000 description 3
- 238000005457 optimization Methods 0.000 description 3
- 230000006399 behavior Effects 0.000 description 2
- 230000008859 change Effects 0.000 description 2
- 230000010354 integration Effects 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 230000008901 benefit Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 239000012141 concentrate Substances 0.000 description 1
- 230000010485 coping Effects 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 230000008676 import Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 238000002955 isolation Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000012805 post-processing Methods 0.000 description 1
- 238000007781 pre-processing Methods 0.000 description 1
- 238000013515 script Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/76—Adapting program code to run in a different environment; Porting
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/368—Test management for test version control, e.g. updating test cases to a new software version
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- 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/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- 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/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45562—Creating, deleting, cloning virtual machine instances
-
- 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/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45575—Starting, stopping, suspending or resuming virtual machine instances
-
- 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/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45591—Monitoring or debugging support
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method for realizing a radar software and hardware decoupling architecture based on a container technology, which relates to the technical field of radars and solves the problem of how to realize the software and hardware decoupling of the radars; splitting radar software according to service functions to obtain a plurality of software modules; installing a container engine on a server, and pulling an operating system base image ImageBase; running a basic mirror image ImageBase to form a container, logging in a corresponding container, copying source codes of the software modules into the container, and saving the container state of the successfully compiled software modules as a new mirror image ImageNew; pulling a third party container monitoring platform mirror image ImageMonitor; boot image ImageNew and image ImageMonitor; the container monitoring platform is accessed through a browser; the mirror image ImageNew is imported to another server to run; and the decoupling of software and hardware is realized.
Description
Technical Field
The invention belongs to the field of radars, and particularly relates to a method for realizing a radar software and hardware decoupling architecture based on a container technology.
Background
After radar is software-treated, a shelf server is used as an operation platform, signal processing and data processing are realized through software, a plurality of processing parameters are opened, and fine processing is realized. When radar use requirements change, the radar processing system can be used for coping by adjusting a plurality of parameters, and even can be used for enhancing software processing functions by upgrading software. However, since the architecture of some software is not open at the time of design, the computing resources such as the server are already determined at the beginning of design, and are not easy to change, and slightly complex software is difficult to upgrade, so that it is difficult to quickly adapt to the requirements of users.
Virtualization technology and container technology are well established. The virtualization technology integrates a plurality of servers into one virtual server, runs a plurality of virtual machines, and each virtual machine has an own operating system on which an application program can be installed. The designs of the virtual machines are isolated from each other and from the virtual hosts. The container is a lightweight virtual machine and also has the function of isolating the host and each application program, but the container has high starting speed and less occupied resources, so that the running performance loss of the application program is small. The radar software processing function module can be designed into a component by utilizing a virtualization technology and a container technology, the component is loaded into a container, and the container can be deployed, operated and migrated by a container monitoring and management system.
Therefore, a method for realizing a radar software and hardware decoupling architecture based on a container technology is provided.
Disclosure of Invention
The present invention aims to solve at least one of the technical problems existing in the prior art; therefore, the invention provides a method for realizing a radar software and hardware decoupling architecture based on a container technology, which is used for solving the technical problem of how to realize software and hardware decoupling and optimal design of radar software through the container technology and a virtualization technology.
In order to achieve the above object, a first aspect of the present invention provides a method for implementing a radar software and hardware decoupling architecture based on container technology, including the following steps:
S1: splitting radar software according to service functions to obtain N software modules; wherein N is an integer greater than 0;
The maintainability, expandability, code quality and test efficiency of the software are effectively improved, and a foundation is laid for continuous optimization and development of radar software;
S2: installing a container engine on a server, and pulling an operating system base image ImageBase;
the deployment efficiency, the running stability, the safety and the resource utilization rate of the application program are improved, and powerful support is provided for the business development of enterprises;
S3: running a basic image ImageBase to form a container, logging in the container, copying source codes of a software module into the container, solving software dependence in the container, compiling the software, and saving the state of the container to which the software which is successfully compiled at present belongs as a new image ImageNew;
The development efficiency can be improved, the consistency is ensured, the management and the deployment are easy, and the test and the debugging are easy;
S4: pulling a third party container monitoring platform mirror image ImageMonitor;
The method has the beneficial effects of quick deployment, uniformity, standardization, stability guarantee, integration, compatibility and the like, and is beneficial to improving development efficiency, reducing fault risk and enhancing maintainability of a system;
S5: boot image ImageNew and image ImageMonitor;
the method realizes automatic deployment, enhances system stability, improves fault tolerance and simplifies operation and maintenance work; these effects help to improve usability and reliability of the system, reducing operation and maintenance costs and risks;
s6: the container monitoring platform is accessed through a browser; the development efficiency of users is improved, and the operation and maintenance cost and risk are reduced;
S7: the mirror image ImageNew is imported to another server to run, so that software and hardware decoupling is realized;
The method has the advantages of improving the deployment speed, ensuring the environment consistency, simplifying the operation and maintenance, enhancing the flexibility of the system and realizing the decoupling of software and hardware, and the effects are beneficial to improving the usability, the reliability and the maintainability of the system and reducing the operation and maintenance cost and the risk.
Further, the software module comprises a radar signal processing module, a radar control module, a target identification module, a map generation module, a data processing module, a man-machine interaction module and a system management module;
Whether to split the software components is determined according to whether the service functions are independent, and after the splitting is completed, a complete unit test and a regression test are required to be performed to ensure the integrity of the software functions.
Further, installing a container engine on the server, pulling an operating system base image ImageBase, comprising the following steps:
Downloading and installing a container engine on a server; wherein the container engine comprises a Docker and a Kubernetes;
after the installation is completed, starting a container engine service;
Pulling an operating system base image ImageBase using a command line tool of the container engine;
the base image ImageBase comprises an operating system and a basic software package;
Server resources can be better utilized by containerization, dynamic allocation and scheduling of the resources are realized, and when the resource demand of a certain container is increased, more resources can be automatically allocated; when the demand is reduced, the resources can be automatically recovered, so that the optimal utilization of the resources is realized.
Further, pulling the third party container monitoring platform image ImageMonitor, comprising the steps of:
determining the name and version of the third party container monitoring platform image ImageMonitor to be pulled;
Opening a terminal or command line interface, and operating by using a Docker command line tool or a Docker API;
pulling a mirror image:
waiting for the Docker to download the image from the designated warehouse;
After the downloading is completed, checking the mirror image ImageMonitor of the third-party container monitoring platform;
By pulling the mirror image of the third-party container monitoring platform, the configured container monitoring platform environment can be quickly obtained, the time for manual configuration and deployment is greatly reduced, and the development efficiency is improved.
Further, the image related startup parameters and the restart policy are set to "always" so that the image can be started up with the physical server.
Further, the container monitoring platform can see all mirror images, containers, the running state of the containers, control the running state of the containers, modify the starting parameters of the containers, and monitor and display the log and consumed calculation, storage, network and other resources of the running containers.
Further, the image ImageNew is imported to another server to run, including the following steps:
Creating a mirror ImageNew: on the origin server, mirror ImageNew is created using Dockerfile or other tools. Ensuring that the required software and configuration is contained in the image;
export an image: exporting the created image into a tar file or other image formats by using the exporting function of the Docker;
transmission mirror image: transmitting the exported image file to a target server, and using FTP, SCP or other file transmission modes to complete the step;
importing a mirror image: importing the transmitted image file into a new image by using the importing function of the Docker on the target server;
the operation container comprises: on the target server, the imported image is used to create and run the container.
Through the steps, one created Docker image can be directly imported to another server to run without recompilation or modification, and decoupling of software and hardware is achieved in the mode, because the same environment and configuration can be obtained no matter which server is run, and the same Docker image is used.
Compared with the prior art, the invention has the beneficial effects that:
According to the method, radar software is split according to service functions to obtain a plurality of software modules; installing a container engine on a server, and pulling an operating system base image ImageBase; running a basic mirror image ImageBase to form a container, logging in a corresponding container, copying source codes of the software modules into the container, and saving the container state of the successfully compiled software modules as a new mirror image ImageNew; pulling a third party container monitoring platform mirror image ImageMonitor; boot image ImageNew and image ImageMonitor; the container monitoring platform is accessed through a browser; the mirror image ImageNew is imported to another server to run; the software and hardware decoupling is realized, the transplanting and migration capacity of the software among different operating systems is enhanced, and a technical foundation is laid for the clustered management of the radar software.
Drawings
In order to more clearly illustrate the embodiments of the invention or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described, it being obvious that the drawings in the following description are only some embodiments of the invention, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flow chart of the present invention;
fig. 2 is a flowchart showing the operation of step S7 in the present invention.
Detailed Description
The technical solutions of the present invention will be clearly and completely described in connection with the embodiments, and it is obvious that the described embodiments are only some embodiments of the present invention, not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
Referring to fig. 1-2, an embodiment of a first aspect of the present invention provides a method for implementing a radar software and hardware decoupling architecture based on container technology, including the following steps:
S1: dividing radar software into a plurality of software modules according to service function modules;
The radar software is split into a plurality of software modules according to the service function modules, so that the maintainability, expandability, code quality and test efficiency of the software can be effectively improved, and a foundation is laid for continuous optimization and development of the radar software;
It should be further noted that, in the step S1, the "splitting into a plurality of software modules according to the service function module" mainly determines whether to split the software components according to whether the service function is independent, and after the splitting is completed, a complete unit test and a regression test are required to be performed to ensure the integrity of the software function;
In a specific embodiment, the radar software is split according to the service function module to obtain a radar signal processing module, a radar control module, a target identification module, a map generation module, a data processing module, a man-machine interaction module and a system management module;
The radar signal processing module is used for receiving and processing radar signals, extracting target information, generating a target report and the like;
the radar control module is used for controlling the operations of radar such as transmitting, receiving, scanning and the like, and communicating and interacting with an external system;
The target recognition module is used for recognizing and classifying the received target signals and determining information such as the type, the position and the speed of the target;
the map generation module is used for generating a three-dimensional map according to the radar data and the map information and providing the three-dimensional map for other modules;
the data processing module is used for preprocessing, post-processing and analyzing the received data, extracting useful information and generating a report or a data product;
The man-machine interaction module is used for interacting with an operator and providing a friendly user interface and operation experience;
The system management module is used for managing hardware and software resources of the radar system and ensuring normal operation and safety of the system;
The service function modules can be split and combined according to actual requirements so as to meet different application scenes and requirements; meanwhile, the reusability, maintainability and expandability of the radar software can be improved by splitting the radar software according to the service function module;
after the radar software is split into a plurality of modules, the functions of each module are relatively independent, so that the independent module update and improvement can be more conveniently carried out during maintenance and upgrading without comprehensively modifying the whole software;
By modular design, when new functions or features need to be added, only new modules need to be added or existing modules need to be expanded, and the whole software does not need to be reconstructed. This allows the expansibility of the radar software to be enhanced;
the code amount of each module is relatively small after splitting the software into a plurality of modules, which makes the code easier to understand and maintain. Meanwhile, through the modularized design, code multiplexing can be better realized, repeated codes are reduced, and code quality is improved;
After the radar software is split into a plurality of modules, each module can be independently tested and debugged. The testing and debugging work is more convenient and quick, and the development efficiency is improved.
S2: installing a container engine on a server, and pulling an operating system base image ImageBase; the container engine is installed on the server, and the base mirror image imageBase of the operating system is pulled, so that the deployment efficiency, the running stability, the safety and the resource utilization rate of an application program can be improved, and powerful support is provided for the business development of enterprises;
in one particular embodiment, it is ensured that the server already has a basic network connection and operating system environment;
downloading and installing container engines, such as Docker or Kubernetes; the container engine is a key tool for realizing containerization, and can pack the application program and the dependent items thereof into an independent and portable container, so that the application program can run rapidly and reliably in different environments;
after the installation is completed, starting a container engine service;
Pulling an operating system base image using a command line tool or API of the container engine; by using the base image ImageBase, applications can be quickly built and deployed; the basic image comprises an operating system and a basic software package, so that the time and effort for constructing a new image can be saved;
The container engine provides an isolation mechanism to ensure that each container runs in an independent running environment and is not interfered with each other, so that the stability and the safety of the system are improved;
Server resources can be better utilized by containerization, dynamic allocation and scheduling of the resources are realized, and when the resource demand of a certain container is increased, more resources can be automatically allocated; when the demand is reduced, the resources can be automatically recovered, so that the optimal utilization of the resources is realized.
S3: running a basic image ImageBase to form a container, logging in the container, copying source codes of a software module into the container, solving software dependence in the container, compiling the software, and saving the state of the container to which the software which is successfully compiled at present belongs as a new image ImageNew;
The development efficiency can be improved, the consistency is ensured, the management and the deployment are easy, and the test and the debugging are easy;
by solving the software dependencies and compiling in the container, the tedious process of installing and configuring the dependencies in the local development environment can be avoided, thereby improving the development efficiency.
The use of the base image ImageBase as the base of the container can ensure that the software environment is consistent across all containers. This can avoid problems caused by inconsistent environments and ensure consistency of software in various environments.
The compiled container state of the software is stored as a new mirror image ImageNew, so that the management and deployment can be conveniently performed; the new image can be easily copied and deployed to other servers or environments, and rapid deployment and expansion are realized.
By developing and testing within the container, different environments and scenarios can be more easily simulated for more comprehensive testing and debugging. This helps to discover and solve potential problems, improving the quality and stability of the software.
S4: pulling a third party container monitoring platform mirror image ImageMonitor;
The method has the beneficial effects of quick deployment, uniformity, standardization, stability guarantee, integration, compatibility and the like, and is beneficial to improving development efficiency, reducing fault risk and enhancing maintainability of a system;
in one particular embodiment, the name and version of the third party container monitoring platform image ImageMonitor to be pulled is determined;
Opening a terminal or command line interface, and operating by using a Docker command line tool or a Docker API;
pulling a mirror image:
Waiting for the Docker to download the image from the designated repository may take some time, depending on the network speed and the size of the image;
after the downloading is completed, the pulled mirror list is checked:
in the list, the third party container monitoring platform image just pulled should be visible.
Now that the third party container monitoring platform mirror ImageMonitor has been successfully pulled, it can be used to build and run the container monitoring platform;
By pulling the third party container monitoring platform mirror image, a configured container monitoring platform environment can be quickly obtained. The time of manual configuration and deployment is greatly reduced, and the development efficiency is improved;
the third-party container monitoring platform mirror image is used, so that the same configuration and version can be ensured to be used in a plurality of environments, and the uniformity and standardization of the system are improved;
the third-party container monitoring platform is generally subjected to extensive testing and optimization, and has higher stability and reliability; the mirror image can be used for reducing the fault risk caused by improper configuration or environmental difference;
the pulled third-party container monitoring platform image is tightly integrated with container technologies such as Docker and the like, compatibility with the mainstream container technologies is ensured, and better monitoring and management capability can be obtained when the container technologies are used for application development and deployment.
S5: the method comprises the steps of starting up the mirror ImageNew and the mirror ImageMonitor, setting a mirror related starting parameter and a restarting strategy to be 'always' so that the mirror can be started up along with the starting up of the physical server;
the method realizes automatic deployment, enhances system stability, improves fault tolerance and simplifies operation and maintenance work; these effects help to improve usability and reliability of the system, reducing operation and maintenance costs and risks;
boot image ImageNew:
start ImageNew mirror:
Boot image ImageMonitor:
start ImageMonitor mirror:
Setting a mirror image related start-up parameter:
For ImageNew and ImageMonitor images, the configuration file of the Docker or the environment variables may be used to set the relevant startup parameters; the specific parameter settings depend on the functionality and requirements of the mirror image;
for example, environmental variables or command line parameters may be added to the configuration file of the Docker to configure the behavior of the image;
Setting the restart policy to "always":
Dock provides Restart Policies (Restart Policies) for deciding the Restart behavior of the container at the time of exit;
Setting the restart policy to "always" (always) will cause the container to automatically restart all the time when it is withdrawn;
ensuring that the mirror image starts up with the start-up of the physical server:
to ensure that the Docker container is automatically started when the physical server is started, the Docker daemon process needs to be set to be started automatically, and the specific method depends on an operating system and a Docker installation mode;
In a Linux system, systemd or init.d scripts can be used for configuring the starting self-starting of the Docker daemon, and a specific configuration method can be found in Docker official documents;
By setting the restart policy of the mirror image to be 'always', when the physical server is restarted, the corresponding container is automatically started without manual intervention, thereby being beneficial to realizing automatic deployment and operation and maintenance and reducing manual intervention and errors;
Setting the restart policy to "always" can ensure that the system can automatically restart the container when the container is abnormally withdrawn or crashed, thereby increasing the stability of the system. This is especially important for critical business and continuously running applications;
By setting the restarting strategy, the container can be automatically restarted when the container fails, and service interruption caused by the container failure is reduced. This helps to promote fault tolerance of the system, ensuring availability and continuity of service;
through automatic deployment and restarting strategies, operation and maintenance flow can be simplified, manual intervention and errors are reduced, operation and maintenance personnel can concentrate on other important tasks more, and working efficiency and accuracy are improved.
S6: the container monitoring platform can be accessed through a browser; improving development efficiency of users, reducing operation and maintenance cost and risk
The container monitoring platform can see all mirror images, containers, the running state of the containers, control the running state of the containers, modify the starting parameters of the containers, and monitor and display the running log and consumed resources of the containers, storage, network and the like;
s7: the mirror ImageNew can be directly imported into another server to run without recompilation, so that software and hardware decoupling is realized;
The method improves the deployment speed, ensures the environment consistency, simplifies the operation and maintenance, enhances the flexibility of the system and realizes the decoupling of software and hardware. These effects help to improve usability, reliability and maintainability of the system, reducing operation and maintenance costs and risks;
Specifically, the premise that the mirror image ImageNew in S7 can be directly imported into another server to run is that the other server needs to install the container engine with the same version in advance, and after importing, the mirror image ImageNew can realize 'one-time compiling and multiple-place running';
In one particular embodiment, a mirror ImageNew is created: creating an image ImageNew on the origin server using Dockerfile or other means to ensure that the required software and configuration is contained in the image;
Export an image: using the export function of dock, export the created image into a tar file or other image format, and the specific command may be similar to dock save-o < export file name > < image name >;
transmission mirror image: and transmitting the exported image file to the target server. This may be accomplished using FTP, SCP or other file transfer means;
Importing a mirror image: and importing the transmitted image file into a new image by using the importing function of the Docker on the target server. The specific command may be similar to a docker load-i < import filename >;
The operation container comprises: on the target server, the container is created and run using the imported image, and the specific command may be similar to a dock run-it < imported image name >.
Through the steps, one created Docker image can be directly imported to another server for operation without recompilation or modification, and decoupling of software and hardware is realized in the mode, because the same environment and configuration can be obtained no matter which server is operated, as long as the same Docker image is used;
by directly importing an already created image, the same environment and configuration can be deployed quickly on another server. The deployment time is greatly shortened, and the working efficiency is improved;
the same mirror image is used for running on a plurality of servers, so that the consistency and standardization of the environment can be ensured, the problems and errors caused by environmental differences can be reduced, and the stability and reliability of the system can be improved;
By directly importing the image, the workload of manual configuration and deployment can be reduced. The operation and maintenance personnel only need to pay attention to the creation and management of the mirror image, and do not need to pay attention to the specific environment and configuration of each server. The operation and maintenance flow is simplified, and the working efficiency is improved;
Deployment using mirroring allows the same environment and configuration to be easily run on different servers. The system provides greater flexibility for the expansion and migration of the system, and the number and configuration of the servers can be flexibly adjusted according to the requirements;
The decoupling of software and hardware is realized through the importing and running of the mirror image. This means that the dependencies between software and hardware are separated, making the deployment and operation of the software more independent of the hardware environment. This helps to improve portability and maintainability of the system.
The containerization of the radar software removes the radar software itself and the degree of coupling between the software and the hardware, thereby greatly increasing the migration and migration capabilities of the software between different operating systems (different Linux release or Windows version operating systems). And a technical foundation is laid for software and hardware decoupling of radar software and clustering management of future radar software.
The above embodiments are only for illustrating the technical method of the present invention and not for limiting the same, and it should be understood by those skilled in the art that the technical method of the present invention may be modified or substituted without departing from the spirit and scope of the technical method of the present invention.
Claims (7)
1. The implementation method of the radar software and hardware decoupling architecture based on the container technology is characterized by comprising the following steps:
splitting radar software according to service functions to obtain N software modules; wherein N is an integer greater than 0;
Installing a container engine on a server, and pulling an operating system base image ImageBase;
Running a basic mirror image ImageBase to form a container, logging in a corresponding container, copying source codes of the software modules into the container, and saving the container state of the successfully compiled software modules as a new mirror image ImageNew;
pulling a third party container monitoring platform mirror image ImageMonitor;
Boot image ImageNew and image ImageMonitor;
The container monitoring platform is accessed through a browser;
The image ImageNew is imported to another server for running.
2. The method for implementing a radar software and hardware decoupling architecture based on container technology according to claim 1, wherein the software modules include a radar signal processing module, a radar control module, a target recognition module, a map generation module, a data processing module, a man-machine interaction module, and a system management module.
3. The method for realizing the radar software and hardware decoupling architecture based on the container technology according to claim 1, wherein the method for realizing the radar software and hardware decoupling architecture based on the container technology is characterized in that a container engine is installed on a server, and an operating system base image ImageBase is pulled, and the method comprises the following steps:
Downloading and installing a container engine on a server; wherein the container engine comprises a Docker and a Kubernetes;
after the installation is completed, starting a container engine service;
Pulling an operating system base image ImageBase using a command line tool of the container engine;
the base image ImageBase comprises an operating system and a basic software package.
4. The method for implementing the radar software and hardware decoupling architecture based on the container technology according to claim 1, wherein the pulling of the third party container monitoring platform image ImageMonitor comprises the following steps:
determining the name and version of the third party container monitoring platform image ImageMonitor to be pulled;
opening a terminal or command line interface, and operating by using a Docker command line tool;
pulling a mirror image:
waiting for the Docker to download the image from the designated warehouse;
After the download is completed, the third party container monitoring platform image ImageMonitor is viewed.
5. The implementation method of a container technology-based radar software and hardware decoupling architecture according to claim 1, wherein the image-related start-up parameters and the restart policy are set to "always".
6. The implementation method of the radar software and hardware decoupling architecture based on the container technology according to claim 1, wherein the container monitoring platform is used for monitoring the running states of the mirror image, the container and the container; controlling the operating state of the container; the container start-up parameters are modified.
7. The method for implementing a container technology-based radar software and hardware decoupling architecture according to claim 1, wherein the image ImageNew is imported to another server for running, and the method comprises the following steps:
On the origin server, creating mirror ImageNew using Dockerfile;
exporting the created image into an image format of a tar file by using an export function of a Docker;
transmitting the exported image file to a target server;
importing the transmitted image file into a new image by using the importing function of the Docker on the target server;
on the target server, the imported image is used to create and run the container.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410170937.7A CN118069217A (en) | 2024-02-06 | 2024-02-06 | Radar software and hardware decoupling architecture implementation method based on container technology |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410170937.7A CN118069217A (en) | 2024-02-06 | 2024-02-06 | Radar software and hardware decoupling architecture implementation method based on container technology |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN118069217A true CN118069217A (en) | 2024-05-24 |
Family
ID=91109102
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410170937.7A Pending CN118069217A (en) | 2024-02-06 | 2024-02-06 | Radar software and hardware decoupling architecture implementation method based on container technology |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN118069217A (en) |
-
2024
- 2024-02-06 CN CN202410170937.7A patent/CN118069217A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN101876940B (en) | Automatic test method and device | |
| CN110752947A (en) | K8s cluster deployment method and device, and deployment platform | |
| CN112527349A (en) | Dynamic deployment strategy optimization and continuous deployment service guarantee system | |
| CN110673923B (en) | XWIKI system configuration method, XWIKI system and computer equipment | |
| CN102279765A (en) | Pre-compiling hosted managed code | |
| CN108616384B (en) | Centralized service management deployment tool and method | |
| CN112269640A (en) | Method for realizing life cycle management of container cloud component | |
| CN114077423A (en) | Airport APP development container architecture based on mobile cross-platform | |
| CN112363731A (en) | Application automation deployment method and device and computer readable storage medium | |
| CN116502437B (en) | Signal-level simulation platform clouding method based on cloud+end architecture | |
| CN116594640A (en) | RISC-V oriented extensible segmentation automatic mirror image construction technology | |
| CN106850598B (en) | Uniform resource management system and method for whole-ship computing environment | |
| EP4293498A1 (en) | Application modification method, and system, cluster, medium and program product | |
| CN111522623B (en) | Modularized software multi-process running system | |
| CN110674043A (en) | Application debugging processing method and server | |
| CN118012453A (en) | Software deployment method, device, electronic equipment, storage medium and program product | |
| CN113849399A (en) | Automatic testing system and method for multi-machine cooperative software under multi-localization platform | |
| CN112565416A (en) | Cloud-native-based large-scale edge android equipment nanotube system and nanotube method thereof | |
| CN116225617A (en) | Management migration method and device for container instance, electronic equipment and storage medium | |
| CN118069217A (en) | Radar software and hardware decoupling architecture implementation method based on container technology | |
| CN115129348A (en) | Resource updating method, device and equipment of application program and readable storage medium | |
| CN114003343A (en) | Cloud native application construction method and device and computer equipment | |
| CN114327498A (en) | Automated deployment method, system, electronic device and computer readable medium | |
| CN114327870A (en) | Execution management module, system and vehicle | |
| CN114253564A (en) | Container cluster mirror image template generation method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication |