Share via

Lay the foundation for application modernization

When you begin laying the foundation for platform as a service (PaaS), it’s common to replatform and refactor enterprise applications and workloads. These high-impact strategies improve business efficiency by making the most of cloud cost structures, scalability, and performance. You can also use AI for more impact, as modern applications support intelligent AI features that improve user experiences and automate tasks.

This guide helps you make the appropriate choice as you modernize key solutions based on VMware, Oracle, SAP, .NET, and Java. Three popular PaaS targets for hosting modern applications are covered—Azure App Service, Azure Container Apps, and Azure Kubernetes Service.

Foundation objectives

When you lay the foundation for PaaS, the objective is to:

  • Start optimizing business-critical applications and workloads through a process of refactoring, replatforming, and quick wins.
  • Build organizational muscle—the added strength and flexibility that comes from using PaaS for end-to-end production rollouts.

To get there, this guide explains when to use Azure App Service, Azure Container Apps, and Azure Kubernetes Service and provides best practices for the following types of applications on Azure:

Expected outcomes

In the application modernization maturity model, emerging pioneers have the agility to scale their cloud operations and practices. If your organization is ready to lay a solid cloud foundation, you can expect the following results:

  • Optimized applications as you refactor and replatform applications and begin adopting cloud-native features.
  • Scalable architectures that support future scalability and performance improvements.
  • Production rollouts. Your modernized applications go into production, and you start seeing improvements in performance, security, and other PaaS benefits.

Impact and ROI as you lay a cloud-native foundation

If your organization runs traditional on-premises infrastructures, you know the high capital expenditures (CapEx) needed for hardware and maintenance. By moving to PaaS, you begin to shift to an operational expenditure (OpEx) model, paying only for the resources you use. This pay-as-you-go approach reduces upfront costs and provides better budget management. As you streamline processes and optimize resource use, you can continue to lower operational expenses.

The impact of replatforming and refactoring applications lies in the benefit you get from future-proofing your organization. A cloud-native foundation leads to greater cost savings and operational flexibility, improved customer experiences, faster time-to-market, and ultimately increased revenue.

As you implement cloud-based security measures, more cost savings accrue over the long term. Initially, you incur costs, but over time you see indirect savings—from the reduced risk of data breaches to enhanced compliance measures. The overall impact makes a positive contribution to your organization’s reputation.

Azure App Service, Azure Container Apps, and Azure Kubernetes Service

If your modernization strategy includes replatforming or refactoring, which Azure service should you use? This section provides general decision-making guidance for three popular targets—Azure App Service, Azure Container Apps, and Azure Kubernetes Service.

The choice depends on the complexity of your application, scalability requirements, and the level of control you need among other factors. Special consideration is given to stateful versus stateless applications.

For example, if you have a straightforward web application built with Spring Boot, Azure App Service or Azure Container Apps are great choices for their ease of use and managed environments. For a complex microservices application that uses Spring Boot, Azure Kubernetes Service is a better choice for its orchestration capabilities and control over the environment.

About Azure App Service

Azure App Service is an HTTP-based service for hosting web applications, REST APIs, and mobile back ends. It’s a great choice when you need to deploy applications quickly without managing infrastructure. Its fully managed platform handles updates, scaling, and load balancing. In addition, Azure App Service is designed for easy integration with other Azure services, including Azure SQL Database, Azure Functions, and more.

Key features:

  • PaaS simplifies deployment and management.
  • Autoscaling based on demand.
  • Built-in security, including support for SSL certificates, authentication, and authorization.
  • Support for continuous integration and continuous deployment (CI/CD) pipelines based on GitHub, Azure DevOps, and other tools.

In general, choose Azure App Service when:

  • You need a fully managed platform with minimal configuration.
  • Your application is a web app, API, or mobile backend.
  • You want to focus on code rather than infrastructure management.
  • You need quick deployment and scaling and prefer not to manage underlying resources.

Use cases:

  • Hosting web applications based on .NET, Java, Node.js, Python, PHP, Ruby, and other frameworks.
  • Deploying APIs that require minimal configuration and management.
  • Applications that need to scale quickly and handle variable traffic loads.

About Azure Container Apps

Azure Container Apps is a serverless, fully managed Kubernetes platform for containerized applications. As a managed application environment, Azure Container Apps handles updates to the operating system and provides operating guardrails for your applications. Its simplified configuration gives you some control, making it a good choice for a single workload with a shared security boundary. You can use it for simple, isolated microservices applications that need coarse-grained control over deployment and scaling. You also have access to the key functionalities of the container orchestration API via Azure APIs.

Key features:

  • PaaS to simplify deployment and management.
  • A rich application platform that supports infrastructure as code (IaC) deployment and Layer 7 ingress, traffic splitting, A/B testing, and application lifecycle management.
  • Support for CI/CD pipelines, Azure DevOps, and other DevOps tools.

In general, choose Azure Container Apps when:

  • Your application can be containerized and you want to deploy it using a managed platform.
  • You need coarse-grained control over deployment, scaling, and configurations.
  • Your application architecture is based on microservices.

Use cases:

  • Hosting web applications built using.NET, Java, Node.js, Python, PHP, Ruby, and other frameworks.
  • Deploying simple microservices applications that do not require orchestration—that is, single components with a shared security boundary.
  • Cost-effective, real-time model inferencing at scale for your AI-powered solutions using serverless GPUs with automatic scaling.

About Azure Kubernetes Service

Azure Kubernetes Service is a managed service that simplifies the deployment, management, and operations of Kubernetes clusters. You can use it to host and orchestrate containerized applications on Azure and to support hybrid and cross-cloud Kubernetes deployments.

When your microservices-based applications are complex and you want fine-grained control over deployment and scaling, Azure Kubernetes Service is the preferred choice. You have full control over the environment, including custom configurations and third-party integrations. In addition, it’s the best choice for applications that need to scale massively and handle high traffic loads.

Key features:

  • Container orchestration. Uses Kubernetes to manage containerized applications.
  • Support for custom configurations of networking, storage, and security.
  • Scalability. Supports horizontal scaling of pods and nodes.
  • Integration with DevOps, including support for CI/CD pipelines and DevOps tools.

In general, choose Azure Kubernetes Service when:

  • You need the same deployment platform across different cloud services or on-premises environments.
  • Specific virtual machine hardware is required.
  • You require a commercial software license or software from Azure Marketplace.
  • Your application depends on Kubernetes APIs.

Use cases:

  • Deploying complex microservices applications that require orchestration and scaling.
  • Applications that need custom configurations and third-party integrations.
  • Workloads that require high availability and disaster recovery setups.

For more information, refer to Choose an Azure container service.

Stateful vs. stateless applications

Additional considerations apply when you use Azure App Service or Azure Kubernetes Service to replatform stateless and stateful applications, defined as follows:

  • Stateless applications don’t persist data and in general are simpler to design and implement. Examples include web servers, REST APIs, and microservices that don’t store session data. Stateless applications are easier to scale because you don’t need to synchronize state across instances. Each request is completely independent, making applications more resilient toward failures.
  • Stateful applications persist data, meaning they retain information across requests and sessions, often because they require access to databases or other storage systems. Examples include databases, session-based applications, and applications with in-memory caches. Stateful applications tend to be more complex in general because of the need to manage sessions and synchronize state—factors that also make them more challenging to scale. They can be less resilient to failure if the session data is lost.

The following table summarizes key differences, and the sections that follow go into more detail.

Service Stateless Stateful
Azure App Service Best for quick deployments Requires care to manage state
Azure Kubernetes Service Offers more control Best for complex applications

Stateless applications

When using Azure App Service for stateless applications, consider disabling the application request routing (ARR) affinity feature, which creates sticky sessions that redirect users to the node that handled their previous requests. To ensure that your App Service instance remains stateless, avoid session affinity.

When working with containerized applications, we recommend using Azure Kubernetes Service. Its robust orchestration and scaling capabilities make it ideal for microservices architectures. In addition, the environment and configuration controls give you more flexibility—particularly needed for complex stateless applications. You can also simplify deployments using Helm, introduce version control, and set up templates to customize reuse.

Stateful applications

When using Azure App Service for stateful applications, you may need additional configurations to manage state effectively. You may need to use an external storage solution such as Azure SQL Database or Azure Cosmos DB. We recommend using ARR to help manage user sessions by directing requests to the same instance but be aware that this feature can limit scalability in a distributed environment.

When using Azure Kubernetes Service for stateful applications, you get more flexibility and control over the environment. You can use StatefulSets to manage the deployment and scaling of stateful pods and Helm to define persistent volume claims, define and manage stateful sets, and manage configuration. To manage state more easily, use a persistent storage solution such as Azure Disks or Azure Files.

Modernize monolithic applications using the Factory Design pattern

In the move to modern application architectures, the Factory Design pattern provides a useful approach to monolithic applications. You can follow this standard process to incrementally migrate different types of workloads to PaaS, breaking down a complex project into manageable, repeatable processes.

The Factory Design pattern is particularly suited for decomposing monolithic .NET and Java apps into smaller, loosely coupled services. This pattern helps in decoupling the client code from the concrete classes it needs to instantiate, making the code more flexible and easier to maintain.

How the Factory Design pattern works

In general, to modernize .NET and Java apps using the Factory Design pattern, do the following:

  1. Define the factory interface. Create an abstract factory interface that declares methods for creating modernized components. This interface serves as a blueprint for the modernization process.
  2. Implement concrete factories. Develop concrete factory classes that implement the factory interface. Each concrete factory handles the creation of specific types of modernized components, such as migrating a database or refactoring a service.
  3. Automate repetitive tasks. To reduce manual effort and ensure consistency, use scripts or tools to automate common migration tasks, such as data migration, code refactoring, and configuration updates.
  4. Standardize configurations. Speed up the process by creating templates for common configurations. Make sure your templates are flexible enough to accommodate different types of workloads.
  5. Migrate incrementally. To build confidence, start with less complex workloads and gradually move to more complex workloads as you streamline the process.

Microservices use case

You can use the Factory Design pattern to transition a monolithic application to a microservices-based architecture. In general, you would do the following:

  1. Create a ServiceFactory interface that defines methods for creating different microservices.
  2. To handle the creation and migration of specific services, implement concrete factories such as UserServiceFactory and OrderServiceFactory.
  3. Automate the migration of each service using scripts and tools.
  4. Standardize the configuration of each microservice using templates.
  5. Incrementally migrate services, starting with the simpler ones.
  6. Test and validate each service in the new environment.

Next steps

Continue the journey by modernizing more application types, such as: