Overview

Nowadays, many monolithic applications still run on on-premises infrastructure.
On-premises applications require organizations to handle both hardware and software themselves, which necessitates high initial costs and extensive internal IT resources for maintenance.
Cloud environments typically offer greater scalability, reduced management complexity, and a shift from Capital Expenditure (CapEx) to Operational Expenditure (OpEx) models. Public clouds, with various cloud-native services, are popular, and Microsoft Azure is the second most popular cloud provider in the world.
In this article, we will discuss how to migrate a monolithic application to Microsoft Azure.

Pre-migration

Analyze the Base

First thing first, the existing applications/systems/codebases need to be analyzed to get enough information before doing migration. Effective migration begins with thorough analysis:

• Discovery: Identify both technical requirements and business objectives.
• Assumptions: Make educated guesses to clarify uncertainties.
• Dependency Analysis: Understand the interdependencies within the application to determine the sequence of migration tasks.
• Proposal Adjustment: Refine the migration strategy based on discoveries and analyses.

Refactor Apps for Dockerization

Before migrating to AKS, which offers significant scalability, ensure the application architecture supports running multiple instances

State management

Consider the implications of distributed state management. Methods such as externalized state storage or adopting stateless architecture might be necessary.
For example, a local in memory cache. When it comes into AKS and runs multiple instances, each instance will not able to share the cache. Hence a distributed cache, or cloud native service such as Azure Cache Redis should be considered.

Configuration for multiple environments

Usually application may have multiple configurations for different environment like separating configurations for development, testing, and production.
For example, for Java Springboot application, usually there are multiple yaml files for different environments, and an active profile name should be specified to indicate which configuration file will be use.
When migrating to Azure, there are 3 ways to deal with it:

• Keep Spring Profiles and Configuration Files

Pros:

• Minimal changes
• Easy to understand
• Allows full use of all Spring-specific features

Cons:

• Cannot encrypt sensitive data.

• Require sourcecode update and redeploy for changes

• Azure App Configuration & Azure Key Vault

Pros:

• Can update config in runtime without redeploy
• Leverages managed services for handling configuration and secrets, reducing operational overhead and complexity.

Cons:

• Requires changes to the application’s configuration management code and practices.

• Adds a dependency on external services, which may increase complexity for local development and testing scenarios.

• Potentially higher costs depending on the usage of Azure services.

• Hybrid Approach (Recommended)

Take advantage of all configuration types: Put normal configuration into Azure Configuration. Put secrets into Azure Key Vault. Keep configuration which don’t require external management in Spring configuration files.

Inter-service Communication

Evaluate and adapt communication pathways between different application components to ensure they operate efficiently in a cloud environment.

Logging and monitoring

Implement centralized logging and monitoring using Azure Monitor and Application Insights to maintain visibility and track application health and performance.

Migrating to Azure

Dockerize applications

Develop Dockerfiles that ensure security and efficiency:

• Employ non-root users to enhance security.
• Use multi-stage builds to minimize the final image size.

Create manifest files for Kubernetes

Define the necessary Kubernetes resources such as Deployments, Services, and Ingress Controllers.

• ConfigMaps and Secrets: Manage application configuration and secrets efficiently.
• Pod Management: Design manifest files to effectively manage pods with considerations for scaling and health checks.

Setup Azure Kubenetes Service

Choose an AKS Architecture

Choose an appropriate AKS setup considering factors such as cost, security, and compliance requirements.

Create an AKS Cluster with Azure Container Registry

Integrate with Azure Container Registry for secure and efficient container image storage and management

Deploy Application Gateway with Ingress Controller

• Ingress Configuration: Utilize Application Gateway as an ingress controller to manage external access efficiently.

Create Cert-Manager for AKS

Automate TLS certificate management for Kubernetes applications to enhance security.

CI/CD with Azure DevOps

Establish Continuous Integration and Continuous Deployment pipelines using Azure DevOps. This setup facilitates automation in building, testing, and deploying applications, ensuring that the application remains in a deployable state after every change.

Post-Migration Considerations:

Disaster Recovery

Implement robust disaster recovery strategies to ensure high availability and data integrity.

Cost optimization

Regularly monitor and optimize cloud spending to ensure efficient resource use.

Performance tuning

Continuously monitor application performance and adjust resources and configurations as needed to meet performance targets.

Conclusion

Migrating to Azure AKS offers significant benefits in scalability and management for monolithic applications. However, it requires careful planning, execution, and ongoing adjustment. By embracing Azure’s native capabilities and ensuring rigorous implementation and optimization practices, organizations can maximize the benefits of cloud migration.