Easy ReviewDOP-C02
Resilient Cloud Solutions11

App2Container

Understand App2Container discovery, container packaging, deployment artifacts, and access restrictions.

App2Container converts supported running server applications into container images and deployment artifacts. It closed to new customers in November 2025; these sections explain the workflow and the continued use allowed for existing projects.

Application containerization and availability

AWS App2Container packages a supported application that is already running on a server into a container imageA packaged application and its dependencies provide the files needed to start a container. without requiring source code. A container image is the packaged application and dependencies used to start a container. The App2Container guide describes discovery, packaging, and generation of AWS deployment artifactsA generated file or image is used to build or deploy the application., meaning files used to build or deploy the application.

How it works

  1. Check support and eligibility. Java on Linux and ASP.NET on Windows or Linux are supported application types. App2Container closed to new customers on November 7, 2025. Existing customers can finish ongoing projects; AWS recommends Transform for new modernization projects.
  2. Discover the running application and analyze its runtime dependencies, meaning the files and processes it relies on.
  3. Package the application into an image and generate deployment artifacts for Amazon ECS, Amazon EKS, or AWS App Runner. Amazon ECR stores the image.
  4. Configure database connectivity separately: App2Container does not package the database layer.

Exam cues

  • If the question says an existing customer must containerize a supported running application without source code, think App2Container, because it discovers the running application’s files and dependencies.
  • If the question asks where a packaged application can run, think Amazon ECS, Amazon EKS, or AWS App Runner, because App2Container generates deployment artifacts for these targets. App Runner supports Linux applications only.
  • If the question asks about the application database, think separate database access, because App2Container does not package the database layer.
  • If the question says a new customer wants to adopt App2Container after November 2025, think the availability restriction, because AWS closed new access on November 7, 2025.

Remember

Documented deployment target Output and restriction
Amazon ECS Container image in ECR and ECS deployment artifacts
Amazon EKS Container image in ECR and Kubernetes deployment artifacts
AWS App Runner Linux applications only; closed to new customers in March 2026
  • App2Container’s availability notice permits existing projects to continue with security and availability maintenance, without new features.
  • App2Container has no additional tool charge; the AWS resources used by its outputs are billed.

Trap: Packaging the application does not package its database. The application container still needs access to the database server.

App2Container packaging and an ECS deployment path
12Running appinventory and analyzeECR imageextract and containerizeECS applicationgenerated deployment
  1. Discover and analyze the application, build its image on the server or worker, and push the image during deployment-artifact generation.

  2. Review the generated artifacts and deploy the ECS application, or use --deploy for direct deployment. The database is configured separately.

From the AWS docs (13)
  • AWS App2Container is a command line tool that packages supported applications running on servers into container images without requiring their source code.
  • App2Container supports Java applications on Linux and ASP.NET applications on Windows and Linux.
  • App2Container does not containerize database-layer components; application containers must be configured to access the database server.
  • App2Container analyze identifies runtime dependencies and writes analysis.json for transformation.
  • App2Container containerize generates a Dockerfile, container image, and deployment.json from analysis results or an extracted application archive.
  • App2Container generates deployment artifacts for Amazon ECS, Amazon EKS, or App Runner, using Amazon ECR as the image registry.
  • App2Container deployment to App Runner supports Linux applications only.
  • App2Container can generate pipeline artifacts for CodePipeline, Jenkins, or Microsoft Azure DevOps.
  • AWS App2Container stopped accepting new customers on November 7, 2025.
  • Existing App2Container customers can complete ongoing modernization projects; AWS continues security updates and availability without adding new features.
  • AWS recommends AWS Transform for new modernization projects in its .NET modernization-tools availability notice.
  • AWS App Runner moved to maintenance and closed to new customers on March 31, 2026.
  • App2Container has no additional tool charge; underlying AWS resources used to store or run its outputs are billed.

Containerization workflow and deployment

AWS App2Container uses a sequence of commands to discover an application, build its container imageA packaged application and its dependencies provide the files needed to start a container., and prepare deployment artifactsA generated file or image is used to build or deploy the application.. A worker machineA separate compatible machine performs containerization and deployment for an application server. can handle the build and deployment when the application server cannot run containers.

How it works

  1. Run init to configure the workspace, then inventory to list running candidate applications and assign IDs. Run analyze to identify runtime dependencies and write analysis.json. The command reference describes each phase.
  2. If using a worker, run extract to create an application archive and transfer it to the worker. The worker must support containers and use the same Linux or Windows platform as the application server.
  3. Run containerize with the analysis results or extracted archive. It generates a DockerfileA file contains the instructions used to build a container image., an image, and deployment.json. It pre-validates the image by default; --no-validate skips that check.
  4. Run generate app-deployment using deployment.json. Review and customize the generated artifacts for manual deployment, or use --deploy to create and deploy the target stackA collection of AWS resources is managed together using a CloudFormation template. directly.
  5. Optionally run generate pipeline to produce delivery-pipeline artifacts. It uses pipeline.json, which generate app-deployment creates.

Exam cues

  • If the question says the application server cannot run Docker, think of extracting an archive for a compatible worker, because the worker can build and deploy the application.
  • If the question says a supported framework is detected, think application modeContainerization includes selected application files and dependencies for a supported framework., because it selects the required application files and dependencies. If no supported framework is found or dependent processes need broader discovery, think process modeContainerization includes all non-system files when dependency discovery needs a broader scope., because it includes all non-system files. See supported applications.
  • If the question asks which configuration feeds deployment or pipeline generation, think deployment.json for generate app-deployment and pipeline.json for generate pipeline.

Remember

  • Command order: init, inventory, analyze, containerize, generate app-deployment, then optionally generate pipeline. A worker workflow adds extract before containerize.
  • Image pre-validation is on by default; --no-validate bypasses it.

Trap: Omitting --deploy does not guarantee that no AWS resources are created. generate app-deployment can create an Amazon ECR repository and push the image even when deployment happens later.

From the AWS docs (12)
  • App2Container can build and deploy on a worker instead of the application server; the worker must use the same Linux or Windows platform and support containers.
  • App2Container extract creates an application archive that can be transferred to a worker for containerization.
  • App2Container init configures the local workspace before analysis, transformation, and deployment commands.
  • App2Container inventory lists running candidate applications and assigns application IDs.
  • App2Container analyze identifies runtime dependencies and writes analysis.json for transformation.
  • App2Container containerize generates a Dockerfile, container image, and deployment.json from analysis results or an extracted application archive.
  • App2Container generate app-deployment uses deployment.json; --deploy creates and deploys the target stack directly, while generated artifacts can be reviewed and customized for manual deployment.
  • App2Container generate app-deployment creates pipeline.json, which generate pipeline uses to produce optional delivery-pipeline artifacts.
  • App2Container application mode includes the application files and dependencies required by a supported framework.
  • App2Container process mode includes all non-system files when a supported framework is not found or dependent processes require broader discovery.
  • App2Container generate app-deployment can create an ECR repository and push the container image even when the deployment itself is performed later.
  • App2Container containerize pre-validates generated images by default; --no-validate skips that check.

Flashcards

tap to flip
Answer

·

All 11 cards as a list

Which AWS tool packages supported existing Java or ASP.NET server applications into containers without requiring source code, and what availability limit applies?

AWS App2Container. It discovers running applications and generates container and deployment artifacts. It stopped accepting new customers on November 7, 2025; existing customers can finish ongoing projects.

An existing App2Container customer has a Java application running on Linux and no source repository. Can App2Container still package it?

Yes, if the application is supported. App2Container analyzes running applications and dependencies without requiring source code.

Does App2Container migrate an application database into the generated container image?

No. It does not containerize the database layer. Configure the application container to reach the database server.

An existing App2Container customer wants to deploy a packaged application to Amazon ECS. What artifacts can the tool provide?

App2Container creates a container image and ECS deployment artifacts, using Amazon ECR as the image registry.

Which platforms can host an App2Container-generated application, subject to support and customer eligibility?

Amazon ECS, Amazon EKS, or App Runner, with images in ECR. App Runner output is limited to Linux applications; App Runner closed to new customers in March 2026.

An existing App2Container customer cannot install Docker on the application server. Where should containerization run?

Use a worker machine on the same Linux or Windows platform that supports containers. Extract and transfer the application archive for the build.

What is the App2Container command order from discovery to optional deployment automation?

Initialize, inventory, analyze, containerize, generate app-deployment, then optionally generate pipeline. A worker workflow can extract an archive before containerize.

How do App2Container application mode and process mode differ?

Application mode selects required application files and dependencies. Process mode includes all non-system files when broader dependency discovery is required.

An App2Container team runs generate app-deployment without --deploy. Can it assume no AWS resources are created?

No. Artifact generation can create an ECR repository and push an image. --deploy adds direct deployment of the target stack.

Which App2Container output file configures container deployment and which configures an optional delivery pipeline?

deployment.json configures generate app-deployment. pipeline.json is created during deployment-artifact generation and consumed by generate pipeline.

Does App2Container containerize test the generated container image by default?

Yes. It pre-validates the image. The --no-validate option bypasses that check.

You finished every topic of DOP-C02!

Your badge turned gold. Next step: book the exam on AWS. Once you pass, add yourself to Who passed.

Share

Share that you finished this certification

I finished every topic of AWS Certified DevOps Engineer - Professional (DOP-C02) on Easy Review. Come study too!