Migrate Legacy Apps to AWS Containers: 7 Strategies

Moving old software to AWS containers can be challenging, but it's worth the effort. Here are 7 strategies to make the transition smoother:

1. Move As-Is (Lift and Shift)
2. Small Changes for Better Fit
3. Breaking Down Big Apps
4. Moving Databases to Containers
5. Setting Up Automatic Updates
6. Keeping Containers Safe
7. Making Apps Run Better

Strategy	Key Benefit	When to Use
Move As-Is	Quick migration	For complex apps or rapid moves
Small Changes	Better container fit	When minor tweaks suffice
Breaking Down Apps	Improved manageability	For large, monolithic apps
Moving Databases	Data optimization	When upgrading database systems
Automatic Updates	Continuous improvement	For frequent app updates
Container Safety	Enhanced security	Always, especially for sensitive data
Performance Tuning	Optimal resource use	After initial migration

These strategies help overcome common challenges like outdated code, complex systems, and missing documentation. By using containers, you'll benefit from easier portability, resource efficiency, and improved isolation between applications.

Related video from YouTube

Getting Ready to Migrate

Before moving your old apps to AWS containers, you need to prepare. Here's how to get ready for a good move.

Checking Your Current Apps

First, look at what you have now:

What to Check	Why It's Important
App parts	Know what makes up each app
How parts work together	Understand what each part needs
Where apps run now	Know your current setup
Safety rules	Make sure you follow the rules

Here's an example of what to list:

App	Parts	Needs	Current Setup	Safety Rules
App 1	Website, database	Outside tool	Computer 1, Storage 1	HIPAA rules
App 2	API, message system	In-house tool	Computer 2, Storage 2	PCI-DSS rules

Choosing Apps for Containers

Not all apps work well in containers. Pick apps that:

• Are simple
• Don't need too much power
• Are important for your work

App	How Complex	Power Needs	How Important	Move Priority
App 1	Medium	Medium	Very	High
App 2	Simple	Low	Somewhat	Medium

Key Points to Remember

Keep these things in mind:

• Containers don't fix bad apps
• Pick the right AWS tool (ECS, EKS, or Fargate)
• Plan how to watch your apps in containers

Point	What It Means
Fix apps first	Make sure apps work well before moving
Choose wisely	Pick the AWS tool that fits your needs
Watch your apps	Have a plan to check on your apps

1. Move As-Is (Lift and Shift)

What It Is and When to Use It

"Move As-Is" or "Lift and Shift" means moving your old app to AWS containers without changing its code. Use this when:

• You need to move quickly
• Your app is complex
• You want to test how your app works in containers

Steps to Move As-Is

1. Check Your App

Look at your app's:

• How complex it is
• How good the code is
• What it needs to work
• Safety rules it must follow

2. Pick a Container Tool

Choose a tool that fits your app. Some options are:

• Docker
• Kubernetes
• AWS ECS

3. Make a Container Image

Put your app, what it needs, and its settings into a container image.

4. Send the Image to a Storage Place

Send your image to a place like Docker Hub or AWS ECR.

5. Set Up the Container

Use AWS ECS, EKS, or Fargate to set up and run your container.

Good and Bad Points

Good	Bad
Fast move to the cloud	App may not work its best
Less work stoppage	May have safety problems

2. Small Changes for Better Fit

What This Means

This method involves making small tweaks to your old app's code so it works well in AWS containers. It's good when you want to use containers without completely rewriting your app.

Changes You Need to Make

When moving an old app to a container, you'll need to change a few things:

Change	What to Do	Example
Settings	Use environment variables instead of fixed settings	Change DB_HOST=localhost to DB_HOST=${DB_HOST}
File locations	Update where your app looks for files	Change /var/log/app.log to /app/log/app.log
Logging	Use container-friendly ways to record what your app does	Change logger.info('Hello World') to print('Hello World')

How to Make Small Changes

Here are some tips to help you make these changes:

• Use tools like Docker or Kubernetes to help set up your container
• Make small changes one at a time
• Test your app in the container after each change

Good and Bad Points

Good	Bad
Keeps most of your old code	Takes more time than just moving the app as-is
Works better in containers than unchanged apps	Might introduce new bugs if not done carefully
Lets you use some container benefits	Doesn't fix all problems with old apps

3. Breaking Down Big Apps

Splitting Apps into Smaller Parts

Breaking big apps into smaller parts can make them easier to manage. This is called microservices. It helps:

• Make apps work better
• Make apps easier to fix
• Make changes faster
• Keep apps running if one part breaks

Here's how to split a big app:

1. Find the main parts of the app
2. See how these parts work together
3. Make each part its own service
4. Set up ways for parts to talk to each other
5. Put each part in a container using Docker

Putting Each Part in a Container

After splitting the app, put each part in a container:

1. Write a Dockerfile for each part
2. Make a Docker image
3. Send the image to a storage place
4. Set up the container to run on AWS

How Parts Talk to Each Other in AWS

In AWS, parts of your app can talk to each other using these tools:

AWS Tool	What It Does
ECS	Runs containers on AWS computers
Lambda	Runs code when something happens
API Gateway	Helps parts talk to each other
ELB	Spreads work across containers

Example: Online Store

An online store might have these parts:

Part	What It Does
Product list	Shows what's for sale
Shopping cart	Keeps track of what you want to buy
Payment	Handles money

Each part is in its own container. They use API Gateway to share information.

Good Things About This Approach

Good Thing	Why It's Good
Grows easily	Can make one part bigger without changing others
Flexible	Can use different coding languages for different parts
Keeps working	If one part breaks, others still work
Easy to fix	Can fix one part without touching others

Tips for Making It Work Well

• Give each part one job
• Use APIs for parts to talk to each other
• Use containers
• Watch how parts are working
• Use computers to set up and run parts

sbb-itb-6210c22

4. Moving Databases to Containers

Ways to Put Databases in Containers

There are three main ways to use databases with containers:

1. Put the database in a container
2. Use a managed database service
3. Use a serverless database

AWS Database Options for Containers

AWS has several database choices for containers:

Database	Type	Good for
Amazon RDS	Managed relational	MySQL, PostgreSQL, Oracle
Amazon Aurora	High-speed relational	MySQL and PostgreSQL
Amazon DynamoDB	NoSQL	Busy apps
Amazon DocumentDB	Document-based	MongoDB-like

How to Move Your Data

To move your data to a container database on AWS:

1. Look at your data: Check how big and complex it is.
2. Pick a database: Choose an AWS database that fits your needs.
3. Set up the database: Start a new database on AWS.
4. Move the data: Use AWS tools to copy your data to the new database.
5. Check everything: Make sure all the data moved correctly and works well.

AWS Tools for Moving Data

Tool	What it does
AWS Database Migration Service (DMS)	Moves data between databases
AWS Schema Conversion Tool (SCT)	Changes database structure if needed

5. Setting Up Automatic Updates

Creating Update Pipelines

To set up automatic updates for your old apps in AWS containers, you need an update pipeline. This pipeline will update your containers with new code, settings, or tools without you doing it by hand. Here's how to make one:

1. Plan your pipeline
2. Connect to your code
3. Build your container
4. Test your container
5. Put your container to work

Using AWS Tools for Updates

AWS has tools to help you update your old apps in containers:

AWS Tool	What It Does
CodePipeline	Moves your code through build, test, and use steps
CodeBuild	Makes your code ready to use
CodeDeploy	Puts your code where it needs to go
CloudFormation	Sets up your AWS tools the same way each time

Automatic Testing and Deployment

Testing and using your code without doing it by hand is important. Here's how:

• Write tests: Make tests that check if your code works right
• Use tests: Run your tests using AWS CodeBuild
• Put code to work: Use AWS CodeDeploy to put your container where it needs to go
• Update bit by bit: Change a little at a time to keep your app working while you update

Step	How to Do It
Write tests	Use tools like JUnit or PyUnit
Use tests	Set up CodeBuild to run your tests
Put code to work	Use CodeDeploy to move your container
Update bit by bit	Change only some parts at a time

6. Keeping Containers Safe

AWS Container Safety Tips

AWS offers tools to help keep your containers safe. Here's what you can do:

Safety Measure	What It Does	How to Use It
AWS IAM roles	Controls access to AWS resources	Assign roles to containers
Logging and monitoring	Tracks container activity	Use CloudWatch and CloudTrail
Encryption	Protects your data	Use S3 encryption and KMS
Network security	Controls traffic to containers	Set up VPC and Security Groups

Following Rules and Regulations

Make sure your containers follow the rules:

1. Know what rules apply to you
2. Use AWS tools to help follow rules
3. Check for rule-breaking

AWS Tool	What It Does
AWS Config	Checks if you're following rules
AWS CloudTrail	Keeps track of what happens in AWS

Watching for Security Issues

Keep an eye out for problems:

• Look for weak spots in your containers
• Have a plan ready if something goes wrong
• Learn about new ways to stay safe

Task	Why It's Important
Check for weak spots	Stops bad people from getting in
Be ready for problems	Helps you fix issues quickly
Learn new safety tricks	Keeps your containers safer

Remember: Keeping containers safe is ongoing work. Always be on the lookout for new ways to protect your stuff.

7. Making Apps Run Better

Setting Container Resources

To make your apps work well in containers, you need to set up their resources correctly. Here's how to do it with Amazon ECS:

1. Choose CPU and memory for each container
2. Set limits to stop containers from using too much
3. Watch how containers use resources with Amazon CloudWatch

Resource	What It Is
CPU	How much processing power the container can use
Memory	How much computer memory the container can use
Ports	Which doors the container can use to talk to other parts

Growing and Shrinking Automatically

Your apps need to handle different amounts of work. AWS Auto Scaling can help:

1. Make a group of containers that can grow or shrink
2. Set rules for when to add or remove containers
3. Watch things like CPU use to know when to change

What to Watch	Why It Matters
CPU Use	Shows if containers are working too hard
Number of Requests	Shows how many people are using your app

Checking How Apps Are Doing

To make sure your apps are working well, use these AWS tools:

1. Amazon CloudWatch: Looks at how your app is working
2. Amazon CloudTrail: Watches for safety problems
3. Amazon X-Ray: Finds and fixes slow parts of your app

Tool	What It Does
CloudWatch	Watches your app and warns you about problems
CloudTrail	Keeps track of who does what in AWS
X-Ray	Helps find why your app might be slow

Wrap-Up

Quick Look at the 7 Strategies

Here's a summary of the seven ways to move old apps to AWS containers:

Strategy	What It Does
1. Move As-Is	Put the app in a container without changes
2. Small Changes	Make minor tweaks to fit the app in a container
3. Break Down Big Apps	Split large apps into smaller parts
4. Move Databases	Put databases in containers or use AWS database services
5. Set Up Auto Updates	Create ways to update containers automatically
6. Keep Containers Safe	Use AWS tools to protect your containers
7. Make Apps Run Better	Adjust resources and set up auto-scaling

Pick the strategy that works best for each of your apps.

Why Containers Are Good Long-Term

Containers help your apps in many ways:

Benefit	How It Helps
Grow or shrink easily	Match the app's size to how many people use it
Better safety	Keep apps separate to stop problems from spreading
Work faster	Make building, testing, and using apps quicker
Use resources well	Get the most out of your computers

Using containers can make your old apps work better and cost less to run.

What to Do Next

Now that you know about moving old apps to AWS containers, here's what to do:

1. Look at your apps: Figure out which strategy fits each app best.
2. Pick the right tools: Choose AWS tools that work with your strategy.
3. Make a plan: Write down the steps to move your apps to containers.
4. Try it out: Test your apps in containers and fix any problems.

Related posts

• Analyze Legacy Code for AWS Migration: 5 Strategies
• AWS Serverless Migration: Legacy App Modernization Guide
• AWS Migration Readiness: Application Portfolio Analysis
• AWS Content Migration Best Practices