Cloud-native is a method for building and managing applications to make the most of the elastic, distributed resources of cloud computing environments. Cloud-native development involves close cooperation between development and operations teams plus continuous user input and feedback. The approach delivers applications that are more resilient and easier to manage than traditional software systems, within much shorter timeframes.
Cloud-Native applications generally include these elements:
A collaborative DevOps approach based on Agile and lean principles of application development
Separation of application components into modular, loosely-coupled microservices, enabling faster and easier rollout and updates
Use of independent lightweight units called containers, to streamline application deployment and orchestrate workloads at scale
APIs that seamlessly connect microservices, simplify maintenance, and enhance security
An automated, policy-driven scheduling and orchestration layer such as Kubernetes
Cloud-native systems also employ ancillary resources called backing services, such as message brokers, monitoring, identity services, and data stores like MongoDB. One of the most widely-used databases for cloud-native applications, MongoDB features a flexible document-oriented data model that is ideal for many types of unstructured data. Other capabilities include high performance with low latency, elastic scale-out, and rapid development. It is also available as a managed service, MongoDB Atlas, a cloud database that runs interchangeably on AWS, Google Cloud, and Microsoft Azure.
Cloud-native allows businesses to respond quickly and effectively to competitive threats and ever-changing market trends. This requires software designed and built very differently than older systems engineered to run on traditional on-premises IT. New applications need to be tailored from the ground up to take advantage of cloud resources, which are virtualized, elastic, and distributed. Cloud-native development fills the bill with a combination of techniques and technologies for creating better, more manageable systems much more quickly.
Compared with traditional locally-hosted software, cloud-native applications provide:
A more fluid architecture
Easy portability among different environments for flexibility and freedom
Downtime-free updates and fixes
Internet accessibility for use anytime, anywhere
Policy-driven automation for faster, error-free execution
Cloud-native applications employ a well-defined set of techniques and technologies. These applications are:
Packaged as containers. Applications are designed as collections of autonomous services – code and all its dependencies -- housed in independent lightweight units called containers that can scale quickly and dynamically. Containers enable software to run reliably when moved from one computing environment to another.
Built with a variety of languages and frameworks. Each service in a cloud-native application is developed using the language and framework best suited to the particular job it has to do.
Designed as modular, loosely-coupled microservices. Services exist and are maintained independently of each other, enabling developers to focus on building the best core functionality for each.
Services collaborate and interact with one another via lightweight APIs based on protocols such as REST, gRPC, and NATS.
Engineered to separate stateful and stateless services
In cloud-native architecture, stateful and stateless services exist independently of each other.
Abstracted from operating systems and servers
Cloud-native applications are not rigidly tied to physical machines or operating systems. They function at a higher level of abstraction.
Deployed in virtual, dynamically scalable cloud environments
The infrastructure for cloud-native applications is virtual, elastic, usually shared, and can be public, private, or hybrid in nature.
Developed according to Agile and DevOps principles
Each service has its own independent cycle of development, iteration, and integration.
A significant level of automation is intrinsic to the design of cloud-native applications.
Managed by predefined policies
CPU, storage, and network resources are automatically allocated by an orchestration layer, which is governed by policies preset by the DevOps team for each application service.
Cloud-native application development differs in many respects from the way traditional systems are built, managed, and maintained. The starting point is a set of concepts and practices known collectively as DevOps. This approach centers on close and frequent collaboration between development and operations teams, in accord with open source principles and Agile development methodology. As outlined earlier, cloud-native applications make use of containers, microservices, APIs, and an orchestration layer such as Kubernetes.
The differences are manifold. To start, cloud-native applications are inherently designed to scale with demand, automatically engaging extra cloud resources as needed, and scaling them back when a spike subsides. Traditional on-premises applications can’t scale dynamically at all.
Another difference is that updates and changes to cloud-native applications are distributed automatically and without interruption to operations. Traditional software must be taken down whenever updates need to be installed. Architecturally, cloud-native applications are virtualized, function in autonomous containers, and run on shared infrastructure. Many on-premises applications can only be operated in non-virtualized spaces.
Finally, traditional on-premises software is tightly linked with network-level resources such as security, permissions, and storage, and will break if anything is moved or altered. In contrast, cloud-native applications are abstracted from physical infrastructure and networks, and can, therefore, be readily modified or moved.