Continuous architecture optimization

Many businesses lift-and-shift applications to the cloud without adopting cloud-native architecture, missing benefits like elasticity, resilience, and observability. As business needs evolve and cloud providers release new products, continuous architecture optimization helps you adapt workloads, improve resource utilization, and reduce costs.

Modernize your application architecture to be cloud-native

Cloud-native architecture separates non-business code from applications, letting the cloud infrastructure handle elasticity, resilience, security, observability, and grayscale releases. This makes applications lightweight, agile, and highly automated with on-demand resource consumption.

Cloud-native technologies — especially containers — accelerate cloud adoption and drive business agility. A cloud-native architecture delivers higher availability, better scalability, faster releases, and more efficient operations and maintenance (O&M).

Comparison between cloud-native and traditional architectures

Containerize applications

Software delivery is complicated by environment differences and skill gaps between teams. Containers solve this by packaging applications with all dependencies into a standard unit that runs reliably across any computing environment, free from environmental constraints.

Container Service for Kubernetes (ACK) improves IT agility, speeds up iterations, and provides a foundation for innovation. Containers can increase delivery efficiency severalfold and let you test new ideas at lower cost. By leveraging cloud elasticity, containers increase deployment density and can reduce computing costs by nearly half.

Adopt microservices

Traditional monolithic applications integrate all services into one codebase. As business requirements grow, monolithic architectures become increasingly complex. Microservices address this by decentralizing iteration and deployment.

Microservices use distributed architecture to horizontally scale and redundantly deploy services, overcoming the scalability and stability limitations of monolithic applications.

Splitting an application into microservices lets modules with different lifecycles iterate independently, preventing slow modules from blocking faster ones. Split logically by problem domain — not just to make services small. Each service scales independently, making resource deployment more economical. Cloud automation further improves iteration efficiency compared to manual software delivery.

Enterprise Distributed Application Service (EDAS) provides a complete microservice solution covering development, deployment, and governance. This PaaS platform supports runtimes such as Apache Dubbo and Spring Cloud.

Microservices Engine (MSE) provides high-performance and high-availability enterprise-level cloud services including service registration and discovery, configuration management, gateway access, and service governance. Its registry and configuration centers are fully managed and compatible with Nacos, ZooKeeper, and Eureka. The gateway is built on Istio and compatible with the Kubernetes Ingress standard. MSE enhances open-source frameworks such as Spring Cloud and Apache Dubbo without intrusive code changes.

MSE connects container clusters with the service registry for automatic service discovery and route forwarding, supporting timeout retries, circuit breaking, and canary releases.

Microservices typically use two gateway layers: a traffic gateway for north-south traffic and security, and a microservice gateway for east-west traffic and governance. The cloud-native microservice gateway provided by MSE merges both layers — combining Kubernetes Ingress/Nginx with Spring Cloud Gateway/Zuul. This halves resource costs and reduces O&M complexity. Built on Envoy and Istio, it outperforms traditional gateways and uses load balancing and throttling to handle traffic spikes.

Explore hybrid deployment

Hybrid deployment (co-location) schedules online and offline workloads onto the same resources, using scheduling and resource isolation to guarantee service quality. This improves resource utilization, reduces fragmentation, and lowers the cost of offline jobs.

From a cluster perspective, hybrid deployment places multiple application types in a single cluster and uses predictive analysis to maximize resource utilization.

From a node perspective, hybrid deployment runs multiple containers on the same node for both online and offline applications. Online applications are latency-sensitive with strict performance requirements. Offline applications are compute-intensive with flexible resource quality requirements and good fault tolerance.

Resource administrators manage capacity, allocation, and usage holistically across all application types. Offline tasks consume idle computing resources from online services, improving cluster utilization and reducing costs.

Time-sharing multiplexing in hybrid deployment

Hybrid deployment maximizes resource utilization but requires continuous governance to balance stability, O&M simplicity, and cost optimization.

Decouple compute and storage

As data volumes grow, storage scale and costs multiply for both online and offline systems. Traditional decentralized storage management leads to high overhead and rising costs.

Distributed and shared storage architecture enables compute and storage to scale independently on demand. It provides the foundation for features such as write-once-read-many, multi-write-multi-read, global active-active disaster recovery, and data consistency.

Storage-compute decoupled architecture

Traditional storage binds compute and storage on a single server with a fixed CPU-memory-storage ratio. As data grows, this forces frequent hardware changes and increases costs.

A storage-compute decoupled architecture breaks this coupling, letting compute and storage scale independently. Storage from multiple nodes forms a single pool, reducing fragmentation and load imbalance. Capacity and throughput scale horizontally, and each layer uses different maintenance policies to reduce costs.

In a cloud environment, store transient, structured, and unstructured data using the cloud's inherent storage-compute decoupled architecture.

Embrace serverless

Serverless represents the next generation of application architecture. It is service-oriented and modular, maximizing compute, storage, and network utilization while shortening release cycles and increasing development efficiency.

Function Compute is an event-driven serverless service. You write and upload code or images — Function Compute handles resource provisioning, elastic execution, log queries, monitoring, and alerts. You pay only for the resources your tasks consume, with no infrastructure to manage.

When traffic arrives or a business event occurs, the cloud starts a process to handle it, then automatically releases resources after completion. The entire application runtime is delegated to the cloud.

Efficiency and cost reduction with serverless

Serverless works well for event-driven computing, short-lived request-response applications, and independent long-running tasks. However, it is not yet suited for every workload. For stateful applications, consider how to synchronize context and state during scheduling. For compute-intensive background tasks, evaluate whether serverless fits your requirements.