Annotation based automated containerization

Patent metadata

Field	Value
Publication number	US-11650810-B1
Application number	US-202016884865-A
Country	US
Kind code	B1
Filing date	May 27, 2020
Priority date	May 27, 2020
Publication date	May 16, 2023
Grant date	May 16, 2023

Abstract

This disclosure describes techniques implemented partly by a service provider network for containerizing applications. In an example, the techniques may include receiving annotated source code of an application to be containerized, analyzing one or more application component annotations included in the annotated source code to determine an application component that is to be included in a container associated with a containerized version of the application, and analyzing one or more method annotations included in the annotated source code to determine one or more methods of the application component to be included in an application programming interface (API) for the container. The container including the application component may then be built and the API for the container may be generated based at least in part on the one or more methods of the application component.

First claim

What is claimed is:

1. A system comprising:
one or more processors; and
one or more computer-readable media storing computer-executable instructions that, when executed by the one or more processors, cause the one or more processors to:
receive annotated JAVA source code, of a monolithic legacy application, including one or more annotations designated to be retained after compiling of the annotated JAVA source code;
compile the annotated JAVA source code of the monolithic legacy application to generate annotated byte code;
parse the annotated byte code to:
identify one or more class annotations included in the annotated byte code; and
identify one or more method annotations included in the annotated byte code;

analyze the one or more class annotations to identify a class, associated with the monolithic legacy application, to be included in a container associated with a containerized version of the monolithic legacy application;
analyze the one or more method annotations to identify one or more methods, of the class identified based on the one or more class annotations, to be exposed in an application programming interface (API) for the container;
determine one or more dependencies of the class identified based on the one or more class annotations;
generate one or more container definitions based on at least one of the one or more class annotations or the one or more method annotations, the one or more container definitions designating a purpose for the container, components to be included in the container, and methods exposed by the API;
build the container based on the class, the one or more dependencies, and the one or more container definitions;
generate the API for the container based on the one or more methods identified based on the one or more method annotations; and
cause, based on the API, the container to be deployed to one or more computing resources hosted by a service provider network that is separate from, and different than, the monolithic legacy application.

2. The system of claim 1 , wherein the determining of the one or more dependencies of the class is performed based on additional annotations included in the annotated byte code.

3. The system of claim 1 , wherein:
one or more first class annotations of the one or more class annotations include a first designation associated with the container;
one or more second class annotations of the one or more class annotations include a second designation associated with a second container associated with the containerized version of the monolithic legacy application; and
the API exposes the one or more methods to the second container.

4. The system of claim 1 , wherein:
the analyzing of the one or more class annotations determines a second class associated with the monolithic legacy application, the second class to be included in the container;
the analyzing of the one or more method annotations identifies one or more second methods of the second class, the one or more second methods to be exposed in the API;
the determining of the one or more dependencies further determines one or more second dependencies of the second class;
the building of the container is further based on the second class and the one or more second dependencies; and
the generating of the API is further based on the one or more second methods.

5. A computer-implemented method comprising:
receiving annotated source code of an application to be containerized;
analyzing one or more application component annotations included in the annotated source code to identify an application component, of the application, to be included in a container associated with a containerized version of the application;
analyzing one or more method annotations included in the annotated source code to identify one or more methods, of the application component, to be exposed in an application programming interface (API) for the container;
building the container including the application component;
generating the API for the container, based at least in part on the one or more methods; and
causing, based at least in part on the API, the container to be deployed to one or more computing resources hosted by a service provider network that is separate from, and different than, a source of the application.

6. The computer-implemented method of claim 5 , wherein:
one or more first application component annotations associated with the application component include a first designation associated with the container;
one or more second application component annotations of the one or more application component annotations include a second designation associated with a second container associated with the containerized version of the application; and
the API exposes the one or more methods to the second container.

7. The computer-implemented method of claim 5 , further comprising:
analyzing one or more additional annotations included in the annotated source code to determine one or more dependencies of the application component,
wherein the building of the container includes building the container to further include the one or more dependencies.

8. The computer-implemented method of claim 5 , wherein:
one or more first application component annotations, of the one or more application component annotations included in the annotated source code, are associated with the application component;
the one or more first application component annotations designate the application component as including functionality to be exposed by the API; and
the analyzing of the one or more method annotations to identify the one or more methods is performed at least partly in response to identifying that the application component is to be included in the container.

9. The computer-implemented method of claim 5 , wherein the one or more application component annotations and the one or more method annotations are designated to be retained after compiling of the annotated source code, the method further comprising:
compiling the annotated source code to generate annotated byte code,
wherein the analyzing the one or more application component annotations and the analyzing the one or more method annotations are performed based at least in part by parsing the annotated byte code to:
identify the one or more application component annotations within the annotated byte code; and
identify the one or more method annotations within the annotated byte code.

10. The computer-implemented method of claim 5 , wherein the one or more method annotations are designated to be retained after compiling of the annotated source code and during runtime of the containerized version of the application, the method further comprising:
compiling the annotated source code to generate annotated byte code, wherein the building of the container is based at least in part on the annotated byte code; and
launching the container,
wherein the generating of the API is performed dynamically at least partly in response to the launching of the container.

11. The computer-implemented method of claim 5 , wherein the analyzing the one or more application component annotations and the analyzing the one or more method annotations are performed at least in part by:
analyzing the annotated source code to build an abstract syntax tree; and
parsing the abstract syntax tree to:
identify the one or more application component annotations within the annotated source code; and
identify the one or more method annotations within the annotated source code.

12. The computer-implemented method of claim 5 , wherein:
the analyzing of the one or more application component annotations identifies a se

Assignees

• Amazon Tech Inc

Inventors

• Wang Boyu
• Zhang Jiangtao

Classifications

• G06F9/44

  Arrangements for executing specific programs · CPC title

• G06F8/73

  Program documentation · CPC title

• G06F8/30

  Creation or generation of source code · CPC title

• G06F8/41 Primary

  Compilation · CPC title

• G06F8/71 Primary

  Version control (security arrangements therefor G06F21/57); Configuration management · CPC title