What is AWS App2Container?

AWS App2Container (A2C) is a new command line tool that helps transform existing applications running in virtual machines into containers, without needing any code changes. A2C discovers applications running on a server, identifies dependencies, and generates relevant artifacts for seamless deployment to Amazon ECS and EKS. A2C also provides integration with AWS CodeBuild and CodeDeploy to enable a repeatable way to build and deploy containerized application.

What application types are supported by App2Container?

App2Container (A2C) currently supports the following application types: ASP.NET (.NET 3.5+) web applications running in IIS 7.5+ on Windows. A2C packages these applications with Windows containers. Java applications running on Linux standalone JBoss, Apache Tomcat, and generic Java applications (Spring Boot, IBM WebSphere, Oracle WebLogic, etc.). A2C packages Java applications with Linux containers.

What are the benefits of containerizing my existing applications?

Some of the benefits that are driving organizations of all sizes to containerize their existing applications are: • Portability: Containers enable you to run applications in on-premise, cloud, and hybrid cloud models. This portability of the application allows customers to be flexible with their infrastructure environments and achieve business benefits, like no vendor lock-in. • Developer Productivity: Containers help with getting started and shipping new code faster and easier. They remove the requirement for complex application and dependency set up. Developers are quickly able to set up their development environments with containers. This empowers them to be productive and agile with application development. • IT Infrastructure Reduction: You can optimize compute costs by increasing container workload density and better utilization of server compute density. This can also help reduce software licensing costs. • Standardization of CI/CD: Customers can easily build modern CI/CD workflows once legacy applications are containerized. This enables customers to standardize their CI/CD process across their organization and that reduces IT operations cost, and improves business agility for their applications.

How does App2Container make it easier to containerize applications?

App2Container enables you to quickly transform your existing applications running on-premises, in Amazon EC2, or in any other cloud. You get the following benefits by using A2C for containerization: • Application Inventory: A2C identifies the supported ASP.NET and Java applications running in a server which enables a quick and accurate inventory of applications in your environment without extensive manual effort. • Detailed Dependency Analysis: A2C analyzes the running application and identifies dependencies including cooperating processes and network port dependencies. This detailed information reduces the manual effort required to understand and document application anatomy and required dependencies. • Seamless Deployment: A2C generates ECS task definitions and Kubernetes deployment YAML for the containerized application following the AWS best practices for security and scalability by integrating with various AWS services such as ECR, ECS, and EKS. A2C generates CloudFormation template to configure required compute, network, and security infrastructure to seamlessly deploy containerized application in AWS. A2C creates CI/CD pipelines for Amazon DevOps services such as CodeBuild and CodeDeploy to build and deploy containers. If you have existing CI/CD tooling (for example, Azure DevOps, and Jenkins), then you can integrate A2C provided deployment artifacts into your existing CI/CD workflows.

What are the prerequisites for using App2Container?

App2Container requires the following prerequisites installed on the server(s) hosting your application: AWS CLI Docker Tools Powershell 5.0+ for applications running on Windows Additionally, you need to provide appropriate IAM permissions to A2C to interact with AWS services. See A2C documentation for more details. Additionally, it is recommended that you use your dev/test environment for containerizing applications.

How do I get started?

Once the prerequisites are met and the App2Container tool is installed on the application server, use the following sequence of commands to containerize the application. • Init: Configures the tool with your AWS profile and other related parameters. • Inventory: Identifies all running applications that are supported by A2C. Choose an application to proceed. • Analyze: Performs detailed analysis to identify application artifacts, third-party dependencies, network ports and configuration files, and generates a configuration file to represent the gathered information. You can make additional changes to the configuration file (for example, exclude or include any additional files or directories). • Containerize: Generates a dockerfile and container image for the analyzed application. If needed, you can modify the A2C-generated dockerfile and rebuild the container. You can also perform local testing of the containerized application using docker run command before deploying to AWS container services. • Generate Deployment: Registers the container image with Amazon ECR, creates ECS task definitions, and Kubernetes deployment YAML file to deploy the containerized application to Amazon ECS or Amazon EKS. A2C generates CloudFormation template to create required infrastructure to deploy the containerized application. Optionally, it also generates AWS CodeBuild and CodeDeploy artifacts to enable repeatable way to build and deploy the containerized app.

Can I containerize my applications outside the product environment?

It is recommended that you use your dev/test environment for containerizing applications. App2Container allows you to run inventory, analyzer, and extract commands on the application server without direct internet access and then you manually copy the application artifact tar file generated by A2C to a separate A2C worker machine where the rest of the A2C workflow needs to be completed. The internet access/aws account will be required on the worker machine to complete the rest of the A2C workflows – (the containerize and generate deployment steps).

What artifacts are generated by App2Container?

App2Container generates the following artifacts for each application component: Application artifacts such as DLLs configuration Dockerfile Container image in ECR ECS Task definitions Kubernetes deployment YAML CloudFormation Template AWS CodeBuild and CodeDeploy resources

How can I set up CI/CD processes for the containerized application?

A2C generates AWS CodeBuild and CodeDeploy artifacts for you to set up your CI/CD workflow. If you have existing CI/CD tooling (for example, Azure DevOps and Jenkins), then you can integrate A2C provided artifacts – dockerfile, ECS task definition, EKS deployment YAML – into your existing CI/CD workflows. See A2C documentation for more details.

How do I update my application after it is containerized?

App2Container generated dockerfile contains commented examples indicating how updates to specific files and dependencies can be captured as part of the build process. You can follow the examples to learn how to deploy updates such as config changes, third-party package updates, deploying a vendor provided WAR/EAR update etc. You can modify the commented parts with the actual application artifacts, and integrate this modified dockerfile into your enterprise CI/CD tools like AWS DevOps services, Jenkins, Spinnaker, and Azure DevOps.

How do I containerize multi-tier applications using A2C?

For applications with multiple tiers, you can use A2C to containerize each application tier separately. A2C creates separate containers and corresponding AWS deployment artifacts for each individual tier. You may have to perform additional configuration before deploying these applications. See A2C documentation for more details.

Does App2Container support migrating the database used by the application?

Dependencies that are external to the application server such as databases are not supported by A2C. You can use tools such as AWS Database Migration Service (DMS) to migrate your application database to AWS.

Can I containerize commercial-off-the-self (COTS) applications using App2Container?

With A2C, you can containerize COTS applications as long as they are based on an application stack supported by A2C. Before starting, check with the application vendor regarding the licensing and support terms and conditions.

How does App2Container flag applications that are not supported for containerization?

App2Container provides mechanisms through which you can identify if the application can be containerized using the tool. First, A2C only generates the inventory of supported applications types – ASP.NET 3.5+ on Windows and Java applications on Linux. Within ASP.NET and Java applications, A2C then flags applications that are using specific feature(s) not supported by A2C e.g. ASP.NET application using. .NET 1.0.

What are the limitations of App2Container?

A2C doesn't support ASP.NET applications with the following characteristics: Application has an OS related dependency on Windows 2008 and 2012 It is using files and registries outside of IIS web application directories, 3) it has dependency on other Windows services or processes outside of IIS. Except for Tomcat and JBoss 7+ application, A2C’s containerization of generic Java applications (for example, ones using WebSphere or WebLogic) involves packaging entire file system without system and kernel files. This can result in a larger container image. You may have to manually exclude files to reduce the size of the images, if desired. For Tomcat and JBoss v7+ applications, A2C container image only includes files directly utilized by the application. The container image doesn’t include files related to package management and versioning. If you use A2C generated container image as base image and try to update the applications or its dependencies through a package manager, then such updates may fail. A2C doesn't currently support Cluster/HA mode for Java applications.