Image assembly method

The dynamic assembly of software containers using predefined modular units addresses inefficiencies in retail terminals by optimizing resource usage and speed through tailored, on-demand container assembly, adapting to hardware and software changes.

JP7596415B2Active Publication Date: 2024-12-09エヌ·シー·アール·ヴォイクス·コーポレイション
View PDF 5 Cites 0 Cited by

Patent Information

Application Number
JP2023012462
Authority / Receiving Office
JP · JP
Patent Type
Patents
Current Assignee / Owner
Priority Date
2022-09-21
Filing Date
2023-01-31
Publication Date
2024-12-09
Estimated Expiration
2043-01-31

AI Technical Summary

Technical Problem

Existing software container solutions for self-service and point-of-sale terminals in retail environments are resource-intensive and inefficient due to the need for large, pre-built containers that include unnecessary code for various peripheral devices, leading to slower download and execution speeds and increased resource consumption.

Method used

A method and system for dynamically assembling software containers using predefined modular units, each containing specific executable instructions tailored to the terminal's hardware and software requirements, facilitated by a proxy that communicates with a container engine and registry to create a manifest on the fly, optimizing resource usage and adaptability.

Benefits of technology

This approach reduces container size and enhances download and execution speeds by ensuring only necessary code is included, adapting quickly to hardware and software changes, and optimizing resource usage in resource-constrained retail environments.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 0007596415000001
    Figure 0007596415000001
  • Figure 0007596415000002
    Figure 0007596415000002
  • Figure 0007596415000003
    Figure 0007596415000003
Patent Text Reader

Abstract

To allow SSTs (self-service terminals) or POS terminals having different operating systems (Linux, Windows etc.) and different software applications to upgrade software running thereon or to change connected peripheral devices.SOLUTION: A computer-implemented method for assembling an executable image file for execution as a software container element is provided, the method comprising assembling an executable image file for execution as a software container element from a plurality of predefined modular image files, each predefined modular image file comprising at least one layer defining executable instructions.SELECTED DRAWING: Figure 1
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] The present invention provides an executable for execution as a software container. image The present invention relates to a method and computing device for assembling a file.

[0002] In particular, the present invention provides a method for implementing a viable self-service or point-of-sale terminal according to the needs of the particular self-service or point-of-sale terminal. image This invention relates to, but is not limited to, a methodology for dynamically assembling a file. image The file consists of several predefined modular image Assembled from files, each of which is an executable image It has specific layers that represent the executable instructions required to compose the entire file. [Background technology]

[0003] Self-service terminals (SSTs) and / or point-of-sale (POS) terminals are known for use in the retail industry from time to time. SSTs and POS terminals are typically used to enable customers to conduct transactions with a retail establishment. Each SST or POS terminal in any retail establishment may be connected to different peripheral devices.

[0004] Each SST or POS terminal may also run different software, such as having a different underlying operating system (Linux, Windows, etc.) and different software applications. This typically depends on the retail establishment in which the SST or POS terminal is used and the intended use of the SST or POS terminal at the retail establishment. From time to time, the software running on the SST or POS terminal may also be upgraded or the connected peripheral devices may be changed.

[0005] Due to the variability that often exists between terminals, software developers have begun to use software containers to contain the software that needs to run on an SST or POS terminal. Software containers help avoid complex platform dependencies because they isolate the software that runs, meaning that the software container can run on one or more processors of the terminal, regardless of the terminal's computing environment.

[0006] This is because software containers contain all of the software (application code and any software dependencies) and need to be able to run in any computing environment. Furthermore, because these containers run in their own isolated computing environment (with the exception of certain predefined communication paths with other software / hardware outside of the software container (e.g., access to certain files, certain ports, etc.)), this also makes them particularly secure.

[0007] Thus, software containers are an effective way of packaging and distributing software for use on SST and POS terminals. When software or hardware upgrades are performed on a terminal, new software containers that comprise those upgrades can be executed on the terminal.

[0008] Also, since containers can be pre-built, this may help to avoid complex builds on every terminal. It is noted that software containers differ from virtual machines in that they do not require a hypervisor to be installed on the computing device. Software containers are also typically lighter weight and run faster than virtual machines.

[0009] Additionally, virtual machines virtualize entire computer systems, whereas software containers virtualize operating systems. Software containers also share a single operating system, whereas each virtual machine has its own operating system.

[0010] To deploy software containers, a container engine (such as Docker, RKT, CRI-O, and LXD) is used. A container engine accepts user requests or requests from the API server of a container orchestrator (such as Kubernetes, Swarm, Mesos, etc.) and retrieves containers (specific image of format) image It can pull files, prepare container mount points, prepare the metadata needed to run the software container, and invoke the container runtime.

[0011] A container runtime is a part of a container engine. A container runtime (such as runc, containerd, crun, railcar, katacontainers, etc.) is a process that runs a container. image It uses the mount points and metadata provided by the container engine to communicate with the kernel (of the host OS) running on the computing device to execute the files and thereby create a software container.

[0012] When implementing multiple containers across multiple computing devices, software container orchestrator platforms are often used, which can schedule container workloads across multiple computing devices (e.g., SST or POS terminals) and also provide standardized application definition files (e.g., kube YAML, docker compose, etc.).

[0013] Kubernetes is an example of a container orchestration platform, which is a cluster of units that includes a control unit called the Kubernetes master that manages the cluster, and at least one node (or worker) that runs workloads (containers).

[0014] One part of the Kubernetes orchestrator platform is the kubelet, which is an agent that runs on every worker that is part of a Kubernetes system. During operation, the kubelet receives commands (from the API server on the Kubernetes master) that tell it which containers should run on the computing devices.

[0015] In Kubernetes, these containers are provided within "pods". Typically, a single pod contains a single container, but a pod can contain multiple containers. The kubelet passes information to the container engine (e.g., via the Container Runtime Interface (CRI)) about which containers should run on the computing device to execute the software containers via a container runtime in the container engine.

[0016] The container runtime is responsible for determining which containers can be run. image When you run a file, a software container is created, so a software container is essentially a container with an associated executable. image This is a runtime instance of a file.

[0017] In this sense, executable containers image The file contains at least all of the software that needs to be executable as a software container element. image A file. More specifically, a container imageThe file is typically a binary file that contains all the necessary requirements to run the software container, along with any metadata that describes the needs and capabilities of the software container.

[0018] container image The file itself is made up of several layers that define the executable instructions needed to run a software container. For example, image The file may include several layers that define the executable code for the software application, several layers that define code for any software dependencies on which the software application relies, and several layers that define code for any required configuration settings.

[0019] container image Files are often containers image The registry is stored in each container. image Files are containers image A specific container that defines layers and metadata within a file image For example, the Open Container Initiative (OCI) image The format is tar files for each layer, and image As a JSON-formatted manifest file that specifies metadata associated with the files. image Define the file.

[0020] When deploying software containers on SST and POS terminals, the containers may be customized by end users (e.g., staff associated with a retail establishment) according to the needs of the particular terminal. image When containers are built from scratch, this can lead to unnecessarily propagating knowledge of how to build containers, and problems during the build process can result in containers that don't function as expected. image This approach also often does not scale well to changes in the real world, which is why new containers image This can only be achieved by building

[0021] So the pre-built containers image The files can be prepared in advance: pre-built containers that should work for any device. image A single container that contains all the software that may possibly be needed, independent of the hardware / software that runs on any given device, to provide files to the user. image Alternatively, a file can be created for each unique terminal that contains a permutation of a subset of the possible software from all possible software that may be needed on the terminal. image A set of unique containers that contain files image You may create the file.

[0022] However, a single container image Creating a file can be a suboptimal operation in terms of resources (disk, RAM, etc.) for the container (and therefore the running container). image For example, if a different piece of code is required for each of 10 specific peripheral devices that can be connected to a terminal, the software container image The file contains all ten pieces of code to ensure that it contains everything needed, independent of the hardware / software running on a particular device. image It needs to be included in the file.

[0023] This results in container sizes that are much larger than necessary for many devices (e.g., devices with only one peripheral device). image The file is then created. Having such a size means image The speed at which files can be downloaded and upgraded, and the speed at which containers can run, determines the image This can result in slower performance than if the file contained only the code needed for that particular device. In reality, there are many different peripheral devices (>10) that can be connected to a device, so it is not practical to use a single pre-built imageThe size of the file may have to be significantly larger.

[0024] For each real-world permutation of software needed on a particular device, a container image When a file is created, it is created in many containers. image This presents a problem in that it may be necessary to build, distribute, and manage

[0025] For example, if a different piece of code is required for each of 10 specific peripheral devices that can be connected to a terminal, a custom piece of code must be created for each real-world combination. image To ensure the file exists, a subset of the 10 parts of the code (e.g. image 1- part 1, image 2-part 1+ image 2. image 3-part 1 + part 3, etc.) image This would result in roughly 1000 different image In practice, there are many different peripheral devices (more than 10) that can be connected to a terminal, so a unique container is required. image The number can be well over 1000.

[0026] In the resource-constrained "edge" environment of a retail store, neither of these approaches are acceptable. Summary of the Invention

[0027] It is an object of the present invention to at least partially alleviate one or more of the above mentioned problems.

[0028] The objective of certain embodiments of the present invention is to provide an executable software container element for execution. image Its purpose is to help assemble files dynamically.

[0029] The objective of certain embodiments of the present invention is to provide a specific container for each terminal installation (terminal type, peripheral device set, product, etc.). image The goal of this study is to help avoid the need to build

[0030] The objective of certain embodiments of the present invention is to provide a container according to the specific needs of the SST or POS terminal. image It helps to optimize the way files are assembled.

[0031] An objective of certain embodiments of the present invention is to be able to quickly adapt to some changes in the hardware or software on the terminal. image The aim of this is to help provide a way to structure the files.

[0032] The objective of certain embodiments of the present invention is to provide a method for creating a plurality of predefined modular image The goal is to help provide a container registry that contains files for each modular image The file is executable to run as a software container to be executed on the SST or POS terminal. image It contains a single layer, which contains executable instructions that may be needed within the file.

[0033] The objective of certain embodiments of the present invention is to provide a method for creating a plurality of predefined modular image The files provided are to help you with each individual module. image The file includes at least one layer that defines executable instructions for communicating with each peripheral device that may be connected to the SST and / or POS terminal.

[0034] It is an object of certain embodiments of the present invention to help provide a proxy communicatively disposed between a container engine and a container registry, the proxy being capable of communicating with the container engine via a number of predefined modular container registries. image Executable from file image A container that allows you to assemble files imageConfigured to create a manifest.

[0035] An objective of certain embodiments of the present invention is to help provide a proxy that communicates with container engines and container registries, which proxy compiles containers "on the fly" according to the container requirements. image It is configured to dynamically create a manifest for

[0036] According to a first aspect of the present invention, an executable for execution as a software container element is provided. image A computer-implemented method for assembling a file comprising a plurality of predefined modular programs for execution as software container elements, the method comprising: image From the file, run the executable image The step of assembling the files includes each predefined modular image A computer-implemented method is provided in which a file includes at least one layer that defines executable instructions.

[0037] Suitably, the method comprises the steps of: image At least one of the first predefined modules in the file image file, and several predefined modules image At least one second predefined modular image From the file, run the executable image and assembling a file, thereby forming the first predefined modular image At least one of the or each of the files includes at least one layer defining executable instructions, the executable instructions being based on at least one of the second predefined modular image Without executable instructions defined by at least one layer of files, a software container element cannot be executed.

[0038] Suitably, the method comprises the steps of: imageAt least one first predefined modular image Provide files and at least one base operating system image The file and at least one software dependency image At least one second predefined modular image and providing the file.

[0039] Suitably, the method comprises: image File and / or printer drivers image File and / or scale drivers image Files and / or laser scanner drivers image At least one peripheral device driver as a file image It further includes providing the file.

[0040] Suitably, the method includes a driver layer and / or a common layer and / or a utility layer. image As a file, software dependencies image It further includes providing the file.

[0041] Suitably the method comprises: image In response to the execution of a file, the executable image The method further includes providing a software container element as an element that includes executable software defined by the file and is executable on one or more processors of the computing device.

[0042] Suitably the method further comprises providing the executable software as software that is executable independent of the computing environment.

[0043] Suitably, the method further comprises executing the executable software in the isolated computing environment via the software container element.

[0044] Suitably, the method comprises, prior to assembly, performing a viable image Executable for execution as a software container element via a container engine element configured to execute the file image The method further includes requesting the file.

[0045] Suitably the method comprises: image Requests for files are sent to the container image Registry or container runtime element and container image and transmitting the request to a proxy configured to communicate with the registry.

[0046] Suitably, the container image The registry and / or proxy are stored in local memory on the computing device and / or on at least one server.

[0047] Suitably, the method comprises the steps of: image Each predefined module that should be included in the file image Define a file, container image The method further includes receiving the manifest.

[0048] Suitably, the method comprises the steps of: image From the proxy configured to communicate with the registry, the container image The method further includes receiving the manifest.

[0049] Suitably, the method comprises the steps of: image In response to receiving the manifest, the executable is image Further comprising assembling the file.

[0050] Suitably, the method comprises the steps of: image Executable from Registry image Each predefined module required to assemble the file imageReceiving files and executables image and assembling the file.

[0051] According to a second aspect of the present invention, there is provided a computing device comprising one or more processors configured to execute executable software, the executable software, when executed, defining a plurality of predefined modular software components for execution as software container elements. image From the file, run the executable image The files are organized to assemble each predefined modular image A computing device is provided in which a file includes at least one layer that defines executable instructions.

[0052] Suitably the computing device is a point-of-sale terminal or a self-service terminal.

[0053] According to a third aspect of the present invention, there is provided an executable for execution as a software container element. image A computer-implemented method for assembling a file, the computer-implemented method comprising: image From the container engine element configured to run the file, image receiving a request for a file; image Several predefined modules available for assembling files image In response to determining that each of the files is accessible in memory, image Each predefined module that should be included in the file image A container that defines a file image Manifests can be compiled into executables. image and providing the file to a container engine component for assembly.

[0054] According to a fourth aspect of the present invention, there is provided a computing device comprising one or more processors configured to execute executable software, the executable software, when executed, providing image From the container engine element configured to run the file, image Receives a request for a file and is executable image Several predefined modules available for assembling files image In response to determining that each of the files is accessible in memory, image Each predefined module that should be included in the file image A container that defines a file image Manifests can be compiled into executables. image A computing device is provided that is configured to provide a file to a container engine element for assembling the file.

[0055] According to a fifth aspect of the present invention there is provided a computer program comprising instructions which, when executed by a computing device, cause the computing device to perform the steps of a method defined by the first or third aspect of the present invention.

[0056] Certain embodiments of the present invention may be implemented to run containers "on the fly" according to the needs of the software container to be executed on the SST or POS terminal. image It helps provide a methodology for assembling the files.

[0057] Certain embodiments of the present invention are image Several predefined modules that can be used to assemble files image Helps provide files with multiple predefined modules image Each file contains a single command that defines the executable instructions. image The layer includes:

[0058] Certain embodiments of the present invention include a plurality of software containers defining executable instructions required in accordance with the requirements of a software container to be executed on an SST or POS terminal. image Executable with layers image Helps provide files that are executable image Each of the files image The layers are each predefined modular image Corresponds to a single layer contained within the file.

[0059] In certain embodiments of the present invention, a container engine is configured to include a plurality of predefined modular containers stored in a container registry. image Executable from file image A container that allows you to assemble files image Help provide a manifesto.

[0060] Certain embodiments of the present invention provide a computing device that executes software, thereby enabling image Helps bring about file structure.

[0061] Certain embodiments of the present invention provide a computing device that executes software, thereby enabling image A container that allows the assembly of files image Help bring about the delivery of the manifesto.

[0062] Certain embodiments of the present invention may be unique to a particular terminal. image Have all the files or software you may need on any device image 2. Implementing a file executable according to the software / hardware requirements of a particular SST or POS terminal, avoiding the need to have image It helps provide a methodology for dynamically assembling files.

[0063] Embodiments of the invention will now be described, by way of example only, with reference to the accompanying drawings, in which:

[0064] In the drawings, like reference numbers refer to like parts. [Brief description of the drawings]

[0065] [Figure 1] 1 illustrates a computing system. [Diagram 2] Depicts a computing system under the control of the Kubernetes orchestration platform. [Diagram 3] 1 illustrates a hardware and software architecture for a self-service terminal running several software containers. [Figure 4] 1 shows software container elements that run on a self-service terminal. [Diagram 5] 1 illustrates software executing on a server that communicates with a plurality of self-service terminals. [Figure 6] Indicates the layer of an executable image file. [Figure 7] 1 illustrates the assembly of an executable image file from predefined modular image files. [Figure 8] 1 illustrates a computing system showing how a request for an image file is processed. [Figure 9] 1 illustrates a computing system having a third party peripheral device connected to a self-service terminal. [Figure 10] 3 illustrates another computing system with a third party peripheral device connected to a self-service terminal. [Figure 11] 1 shows a flowchart illustrating how an executable image file is assembled from predefined modular image files. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0066] 1 shows a computing system 100. The computing system 100 includes three self-service terminals (SSTs) 1101, 1102, and 1103.

[0067] An SST is one example of a computing device. In certain other embodiments of the invention, the computing device may be a point-of-sale (POS) terminal, an automated teller machine (ATM), a personal computer, a laptop, a tablet, etc. Each SST includes one or more processors 112 and at least one memory 114. The memory is a non-transitory computer-readable storage medium.

[0068] The memory 114 stores executable software that is executable by the SST's processor 112. Each SST may also include a communications interface (not shown) for communicating with a server, and one or more communications interfaces (not shown) for communicating with connected peripheral devices.

[0069] 1, a scanner peripheral device 1201 and a scale peripheral device 1202 are connected to a first SST 1101. A printer peripheral device 1203 and a scanner peripheral device 1204 are connected to a second SST 1102. A scale peripheral device 1205, a printer peripheral device 1206, and a scanner peripheral device 1207 are connected to a third SST 1103. It will be appreciated that in certain other embodiments of the invention, each SST may be connected to a different combination of peripheral devices.

[0070] Each peripheral device may communicate with the SST to which it is connected via a wired interface 122. It will be appreciated that in certain other embodiments of the invention, the interface may be wireless or a combination of wired and wireless.

[0071] Each SST communicates with a server 130 via a network 140. A server is also an example of a computing device. The network 140 may be wired, wireless, or a combination of wired and wireless.

[0072] The server 130 also includes one or more processors 132 and at least one memory 134. The memory 134 is also a non-transitory computer-readable storage medium. The memory 134 stores executable software that is executable by the server's processor. The SST and the server's executable software are described in more detail below.

[0073] 2 illustrates a computing system 200. The computing system has several components that are under the control of the Kubernetes container orchestration platform.

[0074] Therefore, the system may be referred to as a Kubernetes cluster. The Kubernetes cluster includes a server 210 running a Kubernetes master 215 and self-service terminals (SSTs) 2201, 2202 running respective Kubernetes workers 2301, 2302.

[0075] It will be appreciated that the server 210 may be a physical server or a cloud server. The server 210 and the SST communicate over a network 205, such as a local area network or the Internet. The network may be wired and / or wireless. It will be appreciated that devices other than the SST may be connected to the network to run Kubernetes workers.

[0076] A Kubernetes master 215 running on server 210 includes an API server 216 that manages the Kubernetes cluster. The API server 216 issues commands based on information it receives from other internal components of the master 215, and interfaces with external components such as kubectl 212 and kubelets (such as kubelet 231 on SST2 2202) running on Kubernetes workers 2301, 2302.

[0077] Etcd 217 is a distributed database for a Kubernetes cluster that stores information such as the cluster's configuration. Etcd 217 also stores the desired state of the Kubernetes workers 2301, 2302 and the actual state of the Kubernetes workers 2301, 2302. A state may be understood to be a measure of the pods (such as pod 3 235 on SST2 2202) and containers of the pods (such as container 236 of pod 235) running on each Kubernetes worker 2301, 2302 in the cluster.

[0078] The scheduler 218 monitors when to run a new pod on a Kubernetes worker and then decides which Kubernetes worker to deploy the pod on. The controller manager 219 runs a controller process that attempts to move the actual state of the Kubernetes workers 2301, 2302 closer to the desired state specified for etcd 217.

[0079] The master 215 also includes kubectl 212, a command line tool for communicating with the Kubernetes cluster via API server 216, and operator interface 211.

[0080] Each Kubernetes worker 2301, 2302 located in a Kubernetes cluster runs on an SST. According to a particular embodiment of the invention, the workers can run on virtual machines of the SST. The workers 230 can communicate with each other and with the master 215 via the network 205.

[0081] Each worker 230 has a kubelet that manages the operation of the worker 230. The kubelet (e.g., kubelet 231 on SST 2202) issues commands to other components of the worker 2302, monitors the pods running on the worker (e.g., pod 235) and the worker's containers (e.g., container 236), and communicates with the API server 216. The kubelet 231 receives deployment files and ensures that the containers 236 described in those deployment files are running and healthy.

[0082] A kube-proxy (e.g., kube-proxy232) is a network proxy that allows pods to communicate with each other, both on the same Kubernetes worker and across different workers. A container engine (e.g., engine233) runs and manages containers, and communicates commands from the kubelet and containers from a registry. image Receive.

[0083] The container engine prepares the container metadata to be passed to a container runtime (e.g., container runtime 234) that is responsible for running the container within the Kubernetes worker within which the runtime resides.

[0084] A pod exists in any Kubernetes worker after it is deployed to the Kubernetes worker by the API server 216 of the Kubernetes master 215. A pod typically contains a single container, but a pod may contain multiple containers with similar functionality that will share storage and network resources.

[0085] Pods can communicate with other pods through the kubelet, either by requesting access to specific resources available to workers or by using the kube-proxy.

[0086] FIG. 3 illustrates a hardware and software architecture 300 for a self-service terminal configured to execute several software container elements.

[0087] In Figure 3, the underlying hardware is an SST 310, which may be one of the SSTs described with respect to Figure 1 or Figure 2. As described above, the SST includes one or more processors and at least one memory. The memory stores executable software that is executable by the processor.

[0088] The executable software includes a Linux kernel 320, which may be part of a host operating system (such as Unix, Ubuntu, etc.). It will be appreciated that in certain other embodiments of the invention, other kernels and other host operating systems (such as Windows, Mac, etc.) may be utilized. Also included as part of the executable software is a container engine 330.

[0089] The container engine accepts user requests or requests from the API server of a container orchestrator (such as Kubernetes, Swarm, Mesos, etc.) and retrieves containers (specific image of format) image It is responsible for pulling files, preparing container mount points, preparing the metadata required to run the software container, and invoking the container runtime.

[0090] A container runtime (not shown) is part of the container engine. A container runtime (such as runc, containerd, crun, railcar, katacontainers, etc.) runs several containers. image The mount points and metadata provided by the container engine are used to communicate with the Linux kernel 320 running on the computing device to execute the files and thereby create a number of software containers.

[0091] Executables for each of the software containers shown in FIG. image The files may be assembled as described herein. Once assembled, they may be stored in memory on the SST. In Figure 3, four software container elements are shown. The first software container element 340 is referred to as the device server container.

[0092] The device server container contains application software 342 and associated binaries and libraries 344. (The binaries and libraries may be referred to as software dependencies.) Applications running within the device server container are responsible, at a low level, for controlling, configuring, or otherwise accessing one or more of the peripheral devices connected to the SST, as well as for exposing enterprise level functionality to other components of the SST across the network.

[0093] For example, a device server may communicate with a scanner (low level) and report scanned barcodes (business level) to other components via the "USB" protocol.

[0094] Software within the device server container can access the peripheral device path and thus use or interact with the peripheral device. The second software container element 350 is referred to as an INIT container. The INIT container includes application software 352 and associated binaries and libraries 354 (the binaries and libraries may be referred to as software dependencies).

[0095] An application running in an INIT container is initialized within its pod and then starts the main (non-INIT) container. It will be appreciated that while the INIT container is a concept of the Kubernetes system, containers configured to run first (i.e., before other containers) may also be utilized in other container orchestration platforms.

[0096] The third software container element 360 is referred to as an endpoint container. The endpoint container includes application software 362 and associated binaries and libraries 364 (the binaries and libraries may be referred to as software dependencies).

[0097] Applications running within the endpoint container make information about the SST, such as the motherboard's universally unique identifier (UUID), available to the rest of the Kubernetes cluster.

[0098] The fourth software container element 370 is referred to as a device plugin container. The device plugin container contains application software 372 and associated binaries and libraries 374. (The binaries and libraries may be referred to as software dependencies.) The application running within the device plugin container is responsible for informing the SST of which peripheral devices are connected.

[0099] As can be seen in Figure 3, each software container element has its own binaries and libraries (bin / lib), however, it will be appreciated that any combination of containers may share bin / lib according to certain other embodiments of the invention.

[0100] Referring now to FIG. 4, there is shown a self-service terminal 400 and software container elements (residing on one or more processors of an SST) configured to execute on the self-service terminal.

[0101] Each software container on the SST is image The container contains executable software (defined by a file) that is executed within the container in such a way that the software runs in an isolated computing environment.

[0102] The software is isolated in the sense that it does not depend on any of the other software containers also running on the SST in order to operate: the software effectively runs in its own computing environment and communicates with hardware / software outside of this environment via predefined communication paths.

[0103] Providing executable software within a software container means that the software can be executed regardless of the computing environment.

[0104] In Figure 4, the containers are managed using the Kubernetes container orchestration platform. The SST shown in Figure 4 may be the SST described with reference to any of Figures 1 to 3 above.

[0105] The SST 400 runs a Linux kernel 405 as part of the host operating system. Of course, other operating systems may be used in accordance with certain other embodiments of the invention.

[0106] Using the Kubernetes system, the self-service terminal runs software called a Kubernetes worker 410. A Kubernetes worker may also be called a node.

[0107] A first software container element 420, a second software container element 430, a third software container element 440, and a fourth software container element 450 are included within the Kubernetes worker 410.

[0108] The Kubernetes platform is responsible for managing these containers as described with reference to Figure 2. The first software container, the second software container, the third software container, and the fourth software container may be the same containers as described with reference to Figure 3.

[0109] The self-service terminal 400 also includes additional software (not shown) that runs outside the Kubernetes worker 410. In the Kubernetes worker 410, the first software container 420 and the second software container 430 run in a single pod called the device server pod 425. The first software container 420 is of the INIT type and is therefore the first container to run in the device server pod (i.e., run before the device server container).

[0110] The third software container 440 runs within a single pod called the endpoint pod 445 .

[0111] The fourth software container 450 runs in a single pod called device plugin pod 455 .

[0112] The creation of each of these pods is defined by three different pod specification files (i.e., deployment.YAML files), as will be understood by those skilled in the art. Pods are used in Kubernetes to provide containers with shared storage and network resources, as well as a specification of how to run the containers within the pod.

[0113] During operation of the SST 400, each of these pods / containers is executed by a container runtime (not shown) of a container engine (not shown). image The files may be assembled as described herein.

[0114] Alternatively, in certain embodiments of the present invention, the selected container (e.g., the device server container) image The files may be assembled as described herein, while still being stored in other containers within the SST. image Files are containers image The executable of the software container may be stored in a registry or may be received directly by the SST without the need for any assembly. image The methodology for assembling the file is described in FIG.

[0115] FIG. 5 shows a server 500 running an isolated Kubernetes master and Kubernetes workers.

[0116] The server communicates with multiple SSTs (not shown in FIG. 5). The server has one or more processors (not shown) and at least one memory (not shown). The memory stores executable software that is executed by the processor at runtime.

[0117] The executable software includes a (host OS) Linux kernel 510. It will be appreciated that in certain other embodiments of the invention, other operating systems may be used.

[0118] The executable software also includes a Kubernetes master 520. The Kubernetes master includes similar components as described above with reference to FIG.

[0119] These are API server 522, scheduler 524, controller manager 526, and etcd database 528. A Kubernetes worker 530 also runs on the server. The Kubernetes worker 530 contains three pods, which themselves contain software container elements. The first pod on the server is a dynamic container proxy pod 532.

[0120] The pod includes a corresponding dynamic proxy software container. The dynamic proxy software container is an executable image The antenna engine receives a request for a file from the container engine and image Predefined modules that you may need to assemble the file image It is responsible for creating a manifest that defines the files and providing it to the container engine.

[0121] The operation of the proxy container is described in more detail below with reference to Figures 9 and 15. The second pod on the server is the upstream container registry pod 534. This pod contains a corresponding upstream container registry software container. The registry container stores the upstream container registry software containers for each predefined modular image Stores files and retrieves them on demand image Involved in serving files to the container engine.

[0122] The operation of the registry container is described in more detail below with reference to Figures 8 and 11. The third pod on the server is the business logic pod 536. This pod contains the corresponding business logic software container.

[0123] Figure 6 shows an executable for running as a software container. image A schematic diagram of a file 600 is shown in FIG. image The file is executable to provide the device server container of FIG.

[0124] Viable image The file was assembled as described in Figure 11. As can be seen in Figure 6, the executable image The files include a base operating system layer 605 , a Java layer 610 , a driver layer 615 , a common layer 620 , a utility layer 625 , a scanner layer 630 , a scale layer 635 , a printer layer 640 , and a device server layer 645 .

[0125] Figure 6 Executable image The file consists of a series of modular files, each with a single layer. image Although assembled from files, in accordance with certain embodiments of the present invention, image Any combination of layers in a file can be combined into a single modular image It will be appreciated that files may be combined. This is the case, for example, for the BaseOS and Java layers.

[0126] This may also be true for the driver, common, and utility layers. image The file is a series of single-layer modular image Assembled from files, but modular image File (e.g. Java image File or driver image Each of the files) may have multiple layers in certain other embodiments of the invention.

[0127] Figure 7 shows a set of predefined modular image Executable from file 705 image 7 helps to show the construction of the file 700.

[0128] As shown in Figure 6 image The file is executable to provide the device server container of FIG.

[0129] FIG. 7 illustrates a first predefined modular design having two layers: one layer defining executable instructions for a base operating system and one layer defining executable instructions for interpreting the Java programming language. image There is file 710. This is the base OS image Of course, in certain other embodiments of the present invention, the base OS layer and the Java layer may be separate modular image It may be provided as a file. It will be further appreciated that in certain other embodiments of the present invention, if other programming languages ​​are used, the Java layer may not be required.

[0130] The base OS layer defines the operating system utilized within the software container (e.g., Ubuntu), however, the base OS layer may not be required in certain other embodiments of the present invention.

[0131] FIG. 7 also shows a second predefined modular image File 720 shows the software dependencies. image The first layer defines the executable instructions for the driver. The driver layer is image The USB driver is an optional layer that defines the executable instructions involved in installing a user space driver on a USB stick. An example of a user space driver may be a low-level USB helper.

[0132] Some image It will be appreciated that a layer may not require any user space drivers. The second layer is a common layer. The common layer defines executable instructions that encapsulate framework components that are shared or used by other layers.

[0133] An example of such a framework may be a logging framework used to control and capture logs from other components. The third layer is the utility layer, which is an optional layer that defines executable instructions including user-facing utilities and tools.

[0134] One example of such a tool may be a system maintenance utility that can be used to view a list of devices installed on the SST and interact with those devices through actions such as running diagnostic checks.

[0135] In certain other embodiments of the present invention, the driver, common and utility layers each have their own predefined modular image It will be appreciated that the driver layer and / or the common layer and / or the utility layer may be provided in a file. It will be further appreciated that the driver layer and / or the common layer and / or the utility layer may not be required in certain embodiments of the present invention.

[0136] FIG. 7 also illustrates a third predefined modular layer having a single layer that defines executable instructions for communicating with a scanner peripheral device. image A fourth predefined modular file 730 having a single layer defining executable instructions for communicating with a scale peripheral device. image A fifth predefined modular file 740 having a single layer defining executable instructions for communicating with a printer peripheral device. image File 750 is shown.

[0137] These image The file is a peripheral device driver. image Scanner, scale, and printer modular image The file is associated with a particular scanner, scale, or printer. imageIt will be understood that the file is a file. As an example, the scanner may be an NCR 2356 handheld scanner, the scale may be an NCR 8789 scale, and the printer may be an NCR 7169 thermal receipt printer.

[0138] In certain other embodiments of the present invention, modular devices associated with other peripheral devices (barcode readers, cameras, etc.) image It will be appreciated that files may be required.

[0139] Peripheral Devices Shown in Figure 7 image It will also be appreciated that a file may not necessarily be required. In FIG. 7, a sixth predefined module having a single device server layer that defines executable instructions for controlling, configuring, or otherwise accessing one or more of the peripheral devices connected to the SST and exposing enterprise level functionality to other components of the SST across the network. image File 760 also exists.

[0140] FIG. 7 also illustrates an optional seventh predefined modular design having a single retail device server tier. image File 770. Modular image File 770 is executed when the container is executed on the POS terminal. image Other executables may be used in place of file 760. image Other predefined modular files that can be used to assemble the file (e.g. for other containers in Figure 4) image The file contains the specific executable that needs to be assembled. image It will be appreciated that this may be defined according to the needs of the file.

[0141] The deployment file is an executable imageThis provides one way of specifying which layers to assemble for a deployment file. A deployment file can achieve this by encoding the layers in the container name. For example, each element of the name could be the name of a contained layer. Other ways of defining the layers to be assembled may also be used, such as a ConfigMap that enumerates the layers, names the list of layers, and then names the layers. image It can be referred to as a given name.

[0142] The deployment file can be consumed by a container engine running on the Kubernetes master or SST to facilitate some of the steps discussed in Figure 11. That is, the container engine creates a set of predefined modular image Executable from file image This deployment file is processed to initiate the steps required to assemble the files, which specify the number and configuration of pods to run containers in a Kubernetes cluster.

[0143] 8 shows a computing system 800 having a front end 810 and a back end 820. The front end includes an SST 830, which may be one of the SSTs as described with respect to FIGS.

[0144] The SST has three connected peripheral devices 835. The SST 830 has a processor (not shown) and a memory (not shown). The memory stores executable software that may be executable by the processor.

[0145] In Figure 8, the SST is running a first software container 840 and a second software container 850 within a Kubernetes framework. The first software container may be the device server container of Figure 4. The second software container may be the endpoint container of Figure 4.

[0146] Also included within the SST is executable software 860 associated with the SST's user interface, which is a web-based user interface, although other browsers may be used in certain other embodiments of the invention.

[0147] The UI communicates with the first software container element via the MQTT protocol. When a user interacts with the SST through the user interface, a command is sent to the first software container element, which processes the command. Once the command is processed, the first software container may communicate with a server and / or peripheral devices and / or return instructions to the user interface as appropriate.

[0148] In backend 820 there is a server pair 870. It will be appreciated that in certain other embodiments of the invention there may be a single server or more than a pair of servers. Each server of the server pair has one or more processors (not shown) and at least one memory (not shown) that stores executable instructions for execution by the processors of the server pair.

[0149] The executable software of the server pair includes a dynamic container proxy 880 and an upstream container registry 890. It will be appreciated that the proxy and registry run on different servers of the server pair, although in certain other embodiments of the invention they may run on the same server.

[0150] The proxy and registry are also each provided as software containers within the Kubernetes framework. The proxy runs containers from a container engine (not shown) running on SST. image Responsible for handling file requests. The container registry is a set of predefined modular containers that are accessible by the SST container engine. image Responsible for storing files.

[0151] modular image Files are microcontainers image A container is a file that can be called a microcontainer (μcontainer). When the SST starts up (if no container is running), a container engine runs on the SST's processor, and then the container engine creates an executable image A request for the file is sent to the proxy 980. The request is image Predefined modular files required to assemble the file image Define a list of files image Contains the name of.

[0152] In response, the proxy communicates with the registry to image Predefined modular files required image Determines whether a file is stored in it. This is done by checking the predefined modular files stored in the registry. image For each of the files image Extract the manifest, then run the executable image Predefined modular files required image For each of the files image This is done by verifying that the manifest exists.

[0153] Proxy is required modular image If the proxy determines that the files are all stored in the registry, it sends them to the container engine for execution. image Predefined modular files required to assemble the file image Each of the files defines a new image Create a manifest.

[0154] The proxy then transmits the manifest to the container engine. In response to receiving the manifest, the container engine processes the manifest and communicates with the registry to generate an executable. image Predefined modular files required to assemble imageExtract or get the file.

[0155] The container engine is created by the proxy. image Because it is defined in the manifest, which modular image Figure out what files you need. What modules you need. image Once all the files have been received, the container engine will package them into a single executable. image Assemble into a file. This is a modular image The container engine then creates an executable to provide the software container elements. image Execute the file.

[0156] Figure 9 shows a computing system 900 with third party peripheral device integration. In Figure 9, there is a front end 910 and a back end 920. In the front end, there is an SST 930.

[0157] SST is a pre-built set of related pre-defined modular image It has two connected peripheral devices 935 that have files on them. The peripheral devices 935 are provided by the same company that provides the software container element 940 that runs on the SST.

[0158] The SST also has third-party peripheral devices 945 connected to it. The devices are provided by third parties and therefore initially have associated pre-defined modular pre-built image Therefore, when using a third-party device, the third party must provide the relevant predefined modular image Create a file (eg, just a single layer that defines executable instructions for communicating with this device) and provide it to a container registry (not shown).

[0159] Next, the executables required to run the software container element 940 are imageThe files are assembled according to the methodology described in FIG. 11 and as described above with reference to FIG. 8. This is because, as shown in FIG. 9, the third party device may be able to access other modular image Modular using the same base OS as the file image The backend 920 includes a server pair 960. The server pair includes a processor that executes business logic components 970.

[0160] 10 illustrates another computing system 1000 with third-party device integration. This system is similar to that described with reference to FIG. 9 above. However, it includes predefined modular containers for third-party peripheral devices that are created and stored in a container registry. image The files are then merged into a single assembled executable. image Instead of building it into a file, there are two executables: image The file is assembled.

[0161] One viable image The file contains predefined modular peripherals that are associated with peripheral devices that are not made by third parties. image Contains files other than executables. image The file contains predefined modular peripherals that are associated with peripheral devices created by third parties. image Contains files.

[0162] This means that third-party devices can be integrated with other modular image Modular using the same base OS as the file image The assembly of each of these files is as described with reference to Figure 11 or Figure 8 above. In other words, Figure 10 represents a different way of handling third party devices, creating new containers rather than incorporating them into a single container, but allowing the same device servers and base O / S layer to be reused and assembled in the same way.

[0163] Of course, peripheral virtualization may be used to enable the integration of drivers associated with different OSes (e.g., Linux and Windows), so that a device connected to a POS running Linux may be made available on a Windows virtual machine, or vice versa.

[0164] Figure 11 shows the executable software container element to be executed on the SST. image 11 shows a flow chart 1100 of certain steps taken during the assembly of a file.

[0165] The SST may be any of the SSTs shown in Figures 1 to 13. When the SST is first installed, it is known which software to install on the SST and which peripheral devices to connect to the SST.

[0166] Using this information, a first step S1105 creates a deployment file for each software container that is to be executed on the SST at startup. The deployment file contains, among other things: image Specifies the name of the file. image The file is executable image File required image It is named to define a list of files.

[0167] As mentioned above, you can use a ConfigMap to: image A list of files can also be defined. Once the deployment file is created, it is uploaded to the API server of the Kubernetes master running on a server that communicates with the SST. The Kubernetes master may be the same master as shown with respect to Figure 2 or Figure 5. The API server receives the deployment file and stores the deployment file in the etcd database of the Kubernetes master.

[0168] The next step S1110 is to power on the SST. This occurs, for example, when the terminal is used for the first time that day, for example after a period when the store is closed. It can also happen at other times, such as when the terminal reboots. The software on the SST, including the host OS and Kubernetes worker configuration, is then loaded from the memory of the SST and executed by the processor of the SST. Then, the next step S1115 involves detecting differences between the pods that should run on the Kubernetes workers associated with the SST as specified according to the etcd database and the pods that actually run on the SST, by the controller manager of the Kubernetes master.

[0169] The resources available to the Kubernetes worker will also be checked to determine if the resources required by the pod are available on the Kubernetes worker. In response to detecting that no pods need to run on the SST and that suitable resources are available, the Kubernetes master's API server sends information to the kubelet on the SST to resolve the discrepancy.

[0170] This information includes deployment files for each pod that runs on the SST. It will be appreciated that according to certain other embodiments of the invention that do not use the Kubernetes orchestration platform, containers may be executed without having to run within a pod, which is a particular feature of the Kubernetes system.

[0171] The next step S1120 involves receiving information from the API server, by the kubelet, and passing the deployment file to the container engine element.

[0172] The next step S1125 is to read the deployment file by the container engine and to register the container engine and the container registry (a plurality of predefined modular imageThe executable is executed by sending a request to a dynamic container proxy that is communicatively located between the executable and the dynamic container (which stores the file). image and requesting the file.

[0173] The request includes a viable image File required image Defines a list of files (from the deployment file). image The name of the file is included. The proxy and registry may be stored in memory on the server and / or in a local memory of the SST. A next step S1130 includes, by the dynamic container proxy: image Parse the name of the file to find the executable image Predefined modular files required image This involves checking the file.

[0174] this is, image The names of the files are effectively predefined modular image This can be achieved because it is an encoded list of the names of the files.

[0175] The proxy then creates an executable image All the predefined modules required for the file are specified. image The proxy performs a step (not shown) of checking that the file is available in memory. The proxy retrieves each predefined modular file from the upstream container registry. image A manifest associated with the file was received and sent from the container engine to the proxy. image Each predefined module is represented by a file name. image This checking step is performed by determining whether a manifest exists for the file.

[0176] The proxy will send a image Determines that a manifest exists for a file, and therefore that all necessary predefined modular imageIf it is determined that the file exists in the registry, a next step S1135 is to execute, by the proxy, image Each predefined module included in the file image Define the file, container image It involves dynamically creating manifests. These modular image The file is executable image Specifies the extraction file required for the file.

[0177] Next, in step S1140, the proxy image For the manifest to be received by the container engine, image It will be appreciated that the steps performed by the proxy may also be performed by the SST or the container registry according to certain other embodiments of the invention.

[0178] image Once the manifest is received by the container engine, a next step S1145 is to generate an executable image Predefined modular files required to assemble image Each of the files is received by the container engine.

[0179] These modular image The files are received from a container registry. image The file is received by the container engine. image It is defined in the manifesto. Modular image Receiving files is also image You might call it a file "drawer."

[0180] modular image When the file is received by the container engine, the next step S1150 is to convert the received predefined modular imageEach of the files can be used to create an executable image It involves assembling a file. The assembled executable image The file may be implemented as a software container element. image A file is executable in the sense that it has the ability to be run as a software container.

[0181] It cannot be run as its own software container (i.e., it cannot run in other predefined modular image files and no assembly required), many predefined modular image The next step (not shown) is to create a file that can be executed by the container engine. image Run the file to make it executable image It involves providing an instance of a file as a software container element.

[0182] Thus, the software container element includes executable software that may be executed on a processor (or processors) of the SST. Of course, the above steps performed by the container engine may, in certain embodiments of the present invention, be specifically performed by a container runtime of the container engine.

[0183] Another step (not shown) is to perform image This involves storing the file in memory of the SST and / or container registry. image The files do not need to be assembled as described above every time SST is restarted. However, image If it is desired to not use memory for storing files, an executable image file may be assembled as described above each time SST is started.

[0184] Certain embodiments of the present invention described above are device servers for retail environments. image Although the assembly of files is described, certain other embodiments of the present invention may be used in non-retail specific image It will be appreciated that this may be used to assemble a file.

[0185] The present invention can be used with any software that has a "plug-in architecture" that allows plug-ins to be created in layers and dynamically assembled into runnable containers containing different combinations of plug-ins.

[0186] Throughout the description and claims of this specification, the terms "comprise" and "contain" and variations thereof mean "including, but not limited to," and are not intended to exclude (and do not exclude) other parts, additives, components, integers, or steps.

[0187] Throughout the description and claims of this specification, the singular encompasses the plural unless the context requires otherwise. In particular, where the indefinite article is used, the specification is to be understood as contemplating both the plural and the singular, unless the context requires otherwise.

[0188] While the present disclosure has been particularly shown and described with reference to preferred embodiments and various aspects thereof, it will be understood by those skilled in the art that various changes and modifications can be made therein without departing from the spirit and scope of the present disclosure. It is intended that the appended claims be construed to include the embodiments described herein, the alternatives discussed above, and all equivalents thereof.

[0189] It should be understood that any feature, integer, property, or group described in conjunction with a particular aspect, embodiment, or example of the invention is applicable to any other aspect, embodiment, or example described herein, except where incompatible therewith. All features disclosed in this specification (including any accompanying claims, abstract, and drawings), and / or all steps of any method or process so disclosed, may be combined in any combination, except combinations in which at least some of the features and / or steps are mutually exclusive.

[0190] The invention is not limited to any of the details of any of the foregoing embodiments. The invention extends to any novel one or combination of features disclosed in this specification (including any accompanying claims, abstract and drawings), or to any novel one or combination of steps of any method or process so disclosed.

[0191] This application also addresses all articles and documents filed contemporaneously herewith or prior to this application and publicly accessible in connection with this application, the contents of all such articles and documents being incorporated herein by reference.

Claims

1. 1. A computer-implemented method for assembling an executable image file for execution as a software container element, comprising: assembling an executable image file from a plurality of predefined modular image files for execution as a software container element; Each predefined modular image file includes at least one layer that defines executable instructions; Prior to assembly of the image file, requesting image files necessary for execution as the software container element via a container engine element configured to execute executable image files; The method includes receiving, at the container engine component, a container image manifest that defines each predefined modular image file to be included within the executable image file.

2. further comprising assembling the executable image file from at least one first predefined modular image file of the plurality of predefined modular image files and at least one second predefined modular image file of the plurality of predefined modular image files; 2. The method of claim 1, whereby the or each of the first predefined modular image files includes at least one layer that defines executable instructions, and the executable instructions cannot be executed as the software container element without executable instructions defined by at least one layer of at least one of the second predefined modular image files.

3. providing the at least one first predefined modular image file as at least one peripheral device driver image file; 3. The method of claim 2, further comprising: providing the at least one second predefined modular image file as at least one base operating system image file and at least one software dependency image file.

4. The method of claim 3 , further comprising providing the at least one peripheral device driver image file as a scanner driver image file, and / or a printer driver image file, and / or a scale driver image file, and / or a laser scanner driver image file.

5. The method according to claim 3 or 4, further comprising providing the software dependency image file as an image file including a driver layer, and / or a common layer, and / or a utility layer.

6. 6. The method of claim 5, further comprising, in response to execution of the executable image file, providing the software container element as an element that includes executable software defined by the executable image file and that is executable on one or more processors of a computing device.

7. The method of claim 6 , further comprising providing the executable software as software that is executable independent of a computing environment.

8. The method of claim 7 , further comprising executing the executable software in an isolated computing environment via the software container element.

9. 10. The method of claim 8, further comprising sending the request for the executable image file to a container image registry or a proxy configured to communicate with a container runtime element and the container image registry.

10. The method of claim 9 , wherein the container image registry and / or the proxy are stored in local memory on a computing device and / or at least one server.

11. 11. The method of claim 10, further comprising receiving the container image manifest from a proxy configured to communicate with the container engine component and the container image registry.

12. 12. The method of claim 11, further comprising assembling, via the container engine component, the executable image file in response to receiving the container image manifest.

13. receiving, at the container engine component, each predefined modular image file required to assemble the executable image file from a container image registry; The method of claim 12 further comprising: assembling the executable image file.

14. 1. A computing device comprising one or more processors configured to run executable software, comprising: the executable software is configured to assemble an executable image file from a plurality of predefined modular image files for execution as software container elements when executed; Each predefined modular image file includes at least one layer that defines executable instructions; prior to assembly of the executable image file, requesting image files necessary for execution as the software container component via a container engine component configured to execute the executable image file; A computing device that receives, at the container engine component, a container image manifest that defines each predefined modular image file to be included within the executable image file.

15. The computing device of claim 14 , wherein the computing device is a point-of-sale terminal or a self-service terminal.

16. 1. A computer-implemented method for assembling an executable image file for execution as a software container element, comprising: receiving a request for an executable image file from a container engine component configured to execute the executable image file; and in response to determining that each of a plurality of predefined modular image files usable to assemble the executable image file is accessible in memory, providing a container image manifest to the container engine component for assembling the executable image file that defines each predefined modular image file to be included within the executable image file.

17. 1. A computing device comprising one or more processors configured to execute executable software that, when executed, receiving a request for an executable image file from a container engine element configured to execute the executable image file; and a computing device configured to, in response to determining that each of a plurality of predefined modular image files usable to assemble the executable image file is accessible in memory, provide a container image manifest to the container engine component for assembling the executable image file, the container image manifest defining each predefined modular image file to be included within the executable image file.

Citation Information

Patent Citations

  • Reception device, reception method, transmission device, and transmission method

    CN112154664A

  • Optimizing container image encryption

    EP3971743A1

  • Method and System for Secure Container Application Framework

    US20220255966A1

  • Software container configuration

    US20220291946A1

  • Container-first architecture

    WO2020231952A1