The past year we observed businesses of all sizes re-engineer applications, data pipelines and business processes for higher efficiency, manageability and performance. These business transformations are driven by a new cloud revolution, ushering high-availability, on-demand elasticity and multi-region support. The main driving factor of this cloud adoption is decreased cost thanks to the economies of scale principle. A second factor is the mitigation of emerging tech risk, since cloud providers such as Microsoft Azure are keeping up with the latest IT innovations. One of these innovations that forms the core of this cloud revolution is a rising open source community developing containerization techniques and event-driven, microservice-based architectures. The Cloud Native Computing Foundation (CNCF) sets new standards for applications and services, stimulating the adoption through the development of open-source, production-ready IT architecture tools and frameworks that meet the use cases of even the biggest enterprises.

Past successes

CNCF chartered a set of characteristics for reliable, secure, scalable and performant IT architectures and development methodologies. A cloud-native architecture is typically composed of microservices that run in lightweight containers. This is closely related to the reorganisation of complete IT departments into smaller (agile) teams conducting cross-functional development and operations. Each team works on a smaller part of an application or (micro)service and is responsible for its integration into the 'whole’. The result is an application or service that uses resources more efficiently, is better understood, recovers more gracefully from error, and cost less to develop since less overhead is involved. Kubernetes (K8s), the container orchestrator that developers are increasingly using to power infrastructure, services, and applications forms the basic building block enterprises rely on. Kubernetes is an open source system for automating deployment, scaling, and management of containerized applications. Because of this key role, enterprises utilizing Kubernetes rely on cloud-native open-source frameworks to minimize the risk of non-compatible code, failed upgrades, and eventual obsolescence. Disaster recovery, an area of security planning that aims to protect an organization from the effects of server failures and other significant events, is also more trivial to cope with when working with prescribed deployments.

Increase in container use

Beneath Kubernetes, the standard for container images is called Docker. In 2013, the open source Docker Engine leveraged existing Linux container concepts to make it easier for developers and operators to decouple application dependencies from underlying OS and infrastructure. Since then, Docker containers have seen an incredible growth, as they are the underlying building block of a modern application architecture. Since Dockerfiles are just a specification, other container runtimes such as Podman, containerd and CRI-O form newer drop-in replacements for enterprises with strong security and compliancy requirements. Adoption of containers in production rose to a stunning 84% in 2019, with an additional 6 percent (90%) for containers running in development, test and PoC stages. The projected market for application container technologies in 2022 is at $4.3 billion. Representing a 30 percent compound annual growth rate from 2017 through 2022. The full report: https://451research.com/451-research-says-application-containers-market-will-grow-to-reach-4–3bn-by-2022

Jumping to less server

According to the latest CNCF survey, at least 41% of respondents are using serverless technologies. Of those who are using serverless, 80% use a hosted platform vs. 20% who use installable software. One of the key advantages of serverless is the reduction in responsibilities for operating cloud infrastructure which provides the opportunity to reallocate time and people to problems unique to the organization. Going serverless thus means greater emphasis up the technical stack on the services that provide the most direct value in your organization. By removing infrastructure as a potential roadblock and having to manage less server, organizations can deliver with one less potential friction point.

The four key characteristics of serverless are:

1. Consumption (not capacity) based pricing

2. No servers to manage or provision

3. Automatically scales with usage

4. Availability and fault tolerance built in

However, since the runtime of serverless functions is ephemeral, adopting the classic serverless approach means transforming to stateless services/applications. Emerging actor frameworks such as Akka or ProtoActor promise to deliver stateful alternatives implementing the actor model of computation invented by Carl Hewitt. The Actor model is a mathematical theory that treats “Actors” as the universal primitives of concurrent digital computation. The model has been used both as a framework for a theoretical understanding of concurrency, and as the theoretical basis for several practical implementations of concurrent systems. Read the full text here: https://arxiv.org/vc/arxiv/papers/1008/1008.1459v8.pdf

The service mesh

A service mesh is a configurable, low‑latency infrastructure layer designed to handle a high volume of network‑based interprocess communication among application infrastructure services using application programming interfaces (APIs) … The mesh provides critical capabilities including service discovery, load balancing, encryption, observability, traceability, authentication and authorization, and support for the circuit breaker pattern.

When presented with a list of eight service mesh-related products or projects, 18% responded they are using at least one of them in production. Forty-seven percent are also evaluating one of these technologies. About 20% of the study did not respond to the question.

Moving forward

GitOps

Software engineering velocity is hard to measure. The latest CNCF survey does a good job at capturing the nuance that software releases can often be done on an ad-hoc basis. GitOps, continuous integration and continuous development through Git, is the prelude of a new decade of shorter release cycles. Automatically testing/building/deploying software components through the use of Git, containers and package registries will see an additional growth in the near future given the success of Kubernetes and the CNCF. Both FluxCD and Github Actions promise to deliver on these requirements!

Distributed Application Runtime

Another interesting development is the concept of having a Distributed Application Runtime. Microsoft is working on a framework called Dapr. Dapr is a portable, event-driven runtime that makes it easy for developers to build resilient, microservice stateless and stateful applications that run on the cloud and edge and embraces the diversity of languages and developer frameworks. It promises to provide consistency and portability through open APIs and extensible components that are community-driven. Dapr will be open source, platform agnostic and enables event-driven, resilient architectures that scale while handling state, resource bindings and pub/sub messaging.

Serverless Kubernetes

Running a large Kubernetes cluster can be costly. To quickly deploy workloads in an Azure Kubernetes Service (AKS) cluster, you can use virtual nodes. With virtual nodes, you have fast provisioning of pods, and only pay per second for their execution time. In a scaling scenario, you don’t need to wait for the Kubernetes cluster autoscaler to deploy VM compute nodes to run the additional pods. In other words, you are able to run Kubernetes and benefit from all its features, while only paying for what u use. Serverless Kubernetes is an amazing thing for small businesses and enterprises alike.

Cloud Native Programming Languages

Last but not least we will witness the arrival of new programming languages that are designed with cloud-native in mind. Programming Languages such as Ballerina or Metaparticle will probably gain in popularity the years to come. Ballerina introduces new abstractions of client objects, services, resource functions, and listeners to bring networking into the language so that programmers can directly address cloud challenges as part of their application logic. One of the languages that really had an impact on enterprises in the past years has to be Go. There is a significant adoption of Golang applications in the cloud because of its performance and small form-factor resulting in cost-savings. It is a great fit when working with event-driven architectures such as microservice or enterprise service bus patterns because of its deeply rooted support for asynchronicity.

References

[1] CNCF Survey 2019, PDF

[2] Kubernetes Docs

[3] NGINX, Service Mesh Article