# US 12,118,361 B2 · Unicontainers

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 12,118,361 B2
- Document ID: US12118361B2
- Status: Granted
- Kind: B2
- Application number: 16/689,762
- Filed: 2019-11-20
- Published: 2020-05-21
- Granted: 2024-10-15
- Earliest claimed: 2018-11-21
- Assignees: SRI International
- Applicants: SRI International
- Inventors: Hassen Saidi
- Web page: https://patentgrep.com/patent/US12118361B2

## CPC

- G06F 9/3838: {Dependency mechanisms, e.g. register scoreboarding}
- G06F 9/455: Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F 8/63: {Image based installation; Cloning; Build to order}
- G06F 8/71: Version control (security arrangements therefor G06F21/57); Configuration management
- G06F 9/3012: {Organisation of register space, e.g. banked or distributed register file}
- G06F 9/45558: {Hypervisor-specific management and integration aspects}
- G06F 2009/45562: {Creating, deleting, cloning virtual machine instances}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

In general, this disclosure describes techniques for building an application designed to run on a given infrastructure as a container. For example, a unicontainer as described herein may represent a smallest-size, statically-linked binary that is the most optimal implementation of a container for executing an application. In some examples, a computing system builds this container by identifying unused or unneeded functionalities from dependencies for the application, for instance where such functionalities are provided by a target infrastructure for the container.

## Claims

### Claim 1

A computing system for generating container images, the computing system comprising:
a build module; and
a computation engine comprising at least one processor and configured to execute the build module to:
receive a recipe file for an application build of an application to be deployed as a container image and an indication of a target infrastructure of a plurality of target infrastructures, wherein the recipe file specifies one or more dependencies of the application,
obtain, based at least on required functions of a first dependency of the one or more dependencies to support the application that are not provided by the target infrastructure, a first version of the first dependency that is configured to provide the required functions but that is not configured to provide at least one other function provided by the target infrastructure, and
build a container image comprising the application, wherein to build the container image the build module is configured to statically link the first version of the first dependency into the application to optimize the application build of the application.

### Claim 2 (depends on 1)

The computing system of claim 1, wherein the first version of the first dependency comprises a different container image.

### Claim 3 (depends on 1)

The computing system of claim 1, further comprising:
a registry file that maps lists of required functions for a dependency to respective versions of the dependency that include the required functions for the dependency,
wherein the build module is configured to identify, based on the recipe file, the required functions of the first dependency,
wherein to obtain the first version of the first dependency, the build module is configured to map, using the registry file, the required functions to the first version of the first dependency.

### Claim 4 (depends on 1)

The computing system of claim 1,
wherein the build module is configured to process the recipe file to generate a dependency structure that includes a plurality of layers, each of the layers comprising at least one of the dependencies.

### Claim 5 (depends on 4)

The computing system of claim 4, wherein each of the layers comprises an application package.

### Claim 6 (depends on 1)

The computing system of claim 1,
wherein each of the one or more dependencies are applications that each provides a produce a desired functionality,
wherein the build module is configured to identify one or more required functions in a dependency of one of the applications that is necessary for the one of the applications to provide the desired functionality,
wherein the build module is configured to remove at least one function, from at least one of the child dependencies, that are not the one or more required functionalities in order to generate modified child dependencies for the at least one of the child dependencies,
wherein to build the container image, the build module is configured to statically link the applications into the application, the applications including the modified child dependencies.

### Claim 7 (depends on 1)

The computing system of claim 1,
wherein the computation engine is configured to execute a user interface,
wherein the user interface is configured to receive a build request comprising the recipe file and the indication of the target infrastructure,
wherein the build module is configured to determine that the target infrastructure provides a second dependency of the one or more dependencies,
wherein to build the container image, the build module is configured to build the container image without statically linking the second dependency into the application.

### Claim 8 (depends on 7)

The computing system of claim 7, further comprising:
a data structure that maps a different identifier for each target infrastructure of the plurality of target infrastructures to corresponding properties of the corresponding target infrastructure,
wherein the build module is configured to determine, based on the indication of the target infrastructure, the target infrastructure provides the second dependency.

### Claim 9 (depends on 8)

The computing system of claim 8, wherein each of the plurality of target infrastructures provides a different set of dependencies available to deployed containers.

### Claim 10 (depends on 7)

The computing system of claim 7, wherein the second dependency comprises one of a library or an application package.

### Claim 11

A computing system for generating container images, the computing system comprising:
a registry;
a registry file for the registry;
a build module; and
a computation engine comprising at least one processor and configured to execute the build module to:
receive a recipe file for an application build of an application to be deployed as a container image, wherein the recipe file specifies one or more dependencies of the application,
obtain, based at least on required functions of a first dependency of the one or more dependencies to support the application, a first version of the first dependency that is configured to provide the required functions but that is not configured to provide at least one other function provided by a second version of the first dependency,
build a container image comprising the application, wherein to build the container image the build module is configured to statically link the first version of the first dependency into the application to optimize the application build of the application,
store the container image to the registry, and
modify the registry file for the registry to indicate the container image includes the first version of the first dependency, wherein the registry file is used to resolve conflicts associated with different versions of the one or more dependencies of the application.

### Claim 12

A method for generating container images, comprising:
receiving, with a computing system, a recipe file for an application build of an application to be deployed as a container image, wherein the recipe file specifies one or more dependencies of the application;
obtaining, with the computing system, based at least on required functions of a first dependency of the one or more dependencies to support the application, a first version of the first dependency that is configured to provide the required function but that is not configured to provide at least one other function provided by a second version of the first dependency;
building, with the computing system, a container image comprising the application, wherein to build the container image the computing system is configured to statically link the first version of the first dependency into the application to optimize the application build of the application;
storing the container image to a registry; and
modifying a registry file for the registry to indicate the container image includes the first version of the first dependency, wherein the registry file is used to resolve conflicts associated with different versions of the one or more dependencies of the application.

### Claim 13

A method for generating container images, comprising:
receiving, with a computing system, a recipe file for an application build of an application to be deployed as a container image and an indication of a target infrastructure of a plurality of target infrastructures, wherein the recipe file specifies one or more dependencies of the application;
obtaining, with the computing system, based at least on required functions of a first dependency of the one or more dependencies to support the application that are not provided by the target infrastructure, a first version of the first dependency that is configured to provide the required function but that is not configured to provide at least one other function provided by the target infrastructure; and
building, with the computing system, a container image comprising the application, wherein to build the container image the computing system is configured to statically link the first version of the first dependency into the application to optimize the application build of the application.

### Claim 14 (depends on 13)

The method of claim 13, wherein the first version of the first dependency comprises a different container image.

### Claim 15 (depends on 13)

The method of claim 13,
wherein a registry file maps lists of required functions for a dependency to respective versions of the dependency that include the required functions for the dependency, the method further comprising:
identifying, based on the recipe file, the required functions of the first dependency,
wherein obtaining the first version of the first dependency comprises mapping, using the dependency registry file, the required functions to the first version of the first dependency.

### Claim 16 (depends on 13)

The method of claim 13, further comprising:
processing, with the computing system, the recipe file to generate a dependency structure that includes a plurality of layers, each of the layers comprising at least one of the dependencies.

### Claim 17 (depends on 13)

The method of claim 13, wherein each of the layers comprises an application package.

### Claim 18 (depends on 13)

The method of claim 13,
wherein a data structure maps a different identifier for each target infrastructure of the plurality of target infrastructures to corresponding properties of the corresponding target infrastructure, the method further comprising:
receiving, with the computing system, a build request comprising the recipe file and the indication of the target infrastructure;
determining, with the computing system, using the data structure, that the target infrastructure provides a second dependency of the one or more dependencies,
wherein building the container image comprises building the container image without statically linking the second dependency into the application.

### Claim 19

A non-transitory computer-readable storage medium comprising instructions for causing a computing system to perform operations comprising:
receiving a recipe file for an application build of an application to be deployed as a container image and an indication of a target infrastructure of a plurality of target infrastructures, wherein the recipe file specifies one or more dependencies of the application;
obtaining, based at least on required functions of a first dependency of the one or more dependencies to support the application that are not provided by the target infrastructure, a first version of the first dependency that is configured to provide the required function but that is not configured to provide at least one other function provided by the target infrastructure; and
building a container image comprising the application, wherein to build the container image the computing system is configured to statically link the first version of the first dependency into the application to optimize the application build of the application.

### Claim 20

A non-transitory computer-readable storage medium comprising instructions for causing a computing system to perform operations comprising:
receiving a recipe file for an application build of an application to be deployed as a container image, wherein the recipe file specifies one or more dependencies of the application;
obtaining, based at least on required functions of a first dependency of the one or more dependencies to support the application, a first version of the first dependency that is configured to provide the required function but that is not configured to provide at least one other function provided by a second version of the first dependency;
building a container image comprising the application, wherein to build the container image the computing system is configured to statically link the first version of the first dependency into the application to optimize the application build of the application;
storing the container image to a registry; and
modifying a registry file for the registry to indicate the container image includes the first version of the first dependency, wherein the registry file is used to resolve conflicts associated with different versions of the one or more dependencies of the application.
