Cloud-Native Computing

- Overview

Cloud-native computing is an approach in software development that utilizes cloud computing to "build and run scalable applications in modern, dynamic environments such as public, private, and hybrid clouds". Technologies such as containers, microservices, serverless functions and immutable infrastructure, deployed via declarative code are common elements of this architectural style. 

These techniques enable loosely coupled systems that are resilient, manageable, and observable. Combined with robust automation, they allow engineers to make high-impact changes frequently and predictably with minimal toil. 

Cloud-native architectures take full advantage of on-demand delivery, global deployment, elasticity, and higher-level services. They enable huge improvements in developer productivity, business agility, scalability, availability, utilization, and cost savings.

Frequently, cloud-native applications are built as a set of microservices that run in Docker containers, and may be orchestrated in Kubernetes and managed and deployed using DevOps and Git CI workflows (although there is a large amount of competing open source that supports cloud-native development). 

Docker and Kubernetes are both important tools in the containerization ecosystem. Docker is used for creating and running containers, while Kubernetes is used for managing and automating the deployment, scaling, and operation of containers across clusters of hosts.

The advantage of using Docker containers is the ability to package all software needed to execute into one executable package. The container runs in a virtualized environment, which isolates the contained application from its environment.

Please refer to the following for more information:

• Wikipedia: Cloud-Native Computing
• Cloud Native Computing Foundation (CNCF)

- Cloud-Native Architectures

A cloud-native architecture is a design approach that leverages cloud services such as AWS's EC2, S3, Lambda, etc. to enable dynamic and agile application development techniques that take a modular approach to building, running, and Update software microservices and monolithic application infrastructure. 

Microservices and containerization enable the agility and dynamism of cloud-native applications, making it easier to transfer between cloud providers, or to deploy services independently in different languages or frameworks without conflict or downtime. 

Integrating a microservices architecture into application development supports collaboration, efficiency, and productivity, as DevOps teams are able to simultaneously and independently work on different components of an application, or implement new functionality without sacrificing stability.

- Cloud-native Applications

Cloud-native applications are self-contained services, packaged as self-contained lightweight containers, that are portable and rapidly scale up (shrink) based on demand. By encapsulating everything into a container, such as a Docker container, you can isolate your application and its dependencies from the underlying infrastructure. 

This allows you to deploy that containerized application in any environment that has a container runtime engine. The important thing about Kubernetes container orchestrations is that they manage the lifecycle of containers. 

Cloud-native applications are typically delivered through DevOps pipelines, which include continuous integration and continuous delivery (CI/CD) toolchains. CI/CD pipelines are important for automating the building, testing, and deployment of cloud-native applications.

- Docker and Docker Containers

Docker is an open source containerization platform that helps build, deploy, and manage containers. With Docker, developers can package and run applications and their dependencies in loosely isolated environments called containers. 

Docker simplifies application delivery by isolating applications from infrastructure. Docker's approach to quickly delivering, testing, and deploying code helps reduce the delay between writing code and running it in production.

Docker containers are a lightweight, portable environment that allows developers to package and execute applications with all necessary dependencies. Each container runs a process, providing a way to isolate and manage multiple applications on a single host.

Docker benefits:

• Support for Linux and Windows Server containers.
• Flexibility to support microservices and traditional app workloads.
• Integrated graphical user interface-based management and operation.
• Granular role-based access control (RBAC) and support for lightweight directory access protocol (LDAP) and Microsoft Entra ID (formerly Azure Active Directory) integration.
• End-to-end security model for a more secure supply chain.

[University of Chicago]

- Benefits of Cloud-Native Applications

Cloud-native applications (NCAs) are software programs that consist of multiple small, interdependent services called microservices. Traditionally, developers built monolithic applications with a single block structure containing all the required functionalities. 

By using the cloud-native approach, software developers break the functionalities into smaller microservices. This makes NCAs more agile as these microservices work independently and take minimal computing resources to run. 

NCAs have many benefits. 

• Independence: Their architecture makes it possible to build cloud-native applications independent of each other. This means you can also manage and deploy them individually.
• Resilience: A well-designed cloud-native application can survive and stay online even in the event of an infrastructure outage.
• Standards-based: To enable interoperability and workload portability, cloud-native services are often based on open source and standards-based technologies. This helps reduce vendor lock-in and improves portability.
• Business agility: Cloud-native applications support flexible deployment options across networks and are smaller than traditional applications, which makes them easier to develop, deploy, and iterate on.
• Automation: Cloud-native applications use DevOps automation capabilities and support continuous delivery and deployment of regularly released software changes. In addition, developers can use methods such as blue-green deployment and canary deployment to improve the application without affecting the user experience.
• No Downtime: With container orchestrators like Kubernetes, you can deploy software updates with essentially zero downtime. 

- Cloud-Native Computing Foundation (CNCF) and Kubernetes

Cloud Native Computing Foundation (CNCF) is created in the Linux foundation for building and managing platforms and solutions for modern application development. It really is a home for amazing projects that enable modern application development. 

CNCF defines cloud-native as “scalable applications” running in “modern dynamic environments” that use technologies such as containers, microservices, and declarative APIs. Kubernetes is the world’s most popular container-orchestration platform and the first CNCF project.

Kubernetes is an open-source container-orchestration system for automating application deployment, scaling, and management. It was originally designed by Google, and is now maintained by the CNCF. 

Kubernetes aims to provide a "platform for automating deployment, scaling, and operations of application containers across clusters of hosts". It works with a range of container tools, including Docker. 

Kubernetes, also known as K8s, is an open-source container orchestration platform that automates containerized applications' deployment, scaling, and management. With Kubernetes, users can easily manage complex containerized applications and services, regardless of their underlying infrastructure.

Many cloud services offer a Kubernetes-based platform or infrastructure as a service (PaaS or IaaS) on which Kubernetes can be deployed as a platform-providing service. Many vendors also provide their own branded Kubernetes distributions.

[More to come ...]