There is no doubt that cloud native applications were revolutionary for the IT world. To provide the growth of cloud native and its projects, in 2015 Cloud Native Computing Foundation was established. The organization gathers projects and tools dedicated to cloud native in the so-called CNCF landscape, about which you can read more in this article.**
How did CNCF start?
In 2014 Google started an open-sourced project to orchestrate containers. Its name was Borg.But Google couldn’t land it, so one year later they started a cooperation with Linux Foundation (established in 2011), creating Cloud Native Computing Foundation. Borg was developed and renamed to Kubernetes and the main aim of CNCF was to encourage and develop the cooperation between Kubernetes and other tools.
The foundation has a very strict process of accepting a project to be a part of the landscape. Firstly it has to be elected with a supermajority by the Technical Oversight Committee (TOC). TOC consists of representatives from CNCF community companies. The aim of voting is to keep the community healthy and high-quality.
There are 3 stages defining the candidate project’s code maturity:
- Sandbox - very early stage in which the project needs the help of the community to be deployed. It’s chosen because of its huge potential.
- Incubating - after meeting all of the Sandbox criteria and being in usage of at least 3 companies, the project enters the next stage, in which a dedicated team helps to develop new features. Incubating is a long, complex process, because only the best ones can be graduated.
- Graduation - in this phase the project must show prospering rates and have committers from at least 2 organizations, ordered processes and finally meet the Linux Foundation Core Infrastructure expectations to get Best Practices Badge. Examples of graduated projects are Kubernetes and Prometheus.
Nowadays there are over 120 projects which followed Kubernetes and were adopted by CNCF.
Cloud native landscape structure
All projects adopted by CNCF are grouped in 6 categories. Every category has its own layers dedicated for different areas of creating a cloud native ecosystem.
Includes basic tools required for proper functioning of cloud native applications and supportive technologies. They create, secure, configure and manage containers. Layers in this category are:
- Automation and Configuration - supporting fast deployment of CN resources.
- Container Registry—storing container images, helping other tools to use these images in running containers.
- Security & Compliance— responsible for security in a cloud native ecosystem.
- Key Management—managing passwords, credentials, and secrets.
Includes tools designed for running containers and other necessary resources. Layers in this category are:
- Container Runtime - running containerized applications, controlling their lifecycle.
- Cloud Native Storage - responsible for container storage and creating unified interfaces for devices.
- Cloud Native Network - allowing containers to communicate via virtual network
Orchestration & Management
Includes tools for cloud native application management on the scale. Layers in this category are:
- Scheduling & Orchestration - supporting management, making resource schedules, and automation of workloads.
- Coordination & Service Discovery - providing communication of containers and tools with other elements of cloud native application.
- Remote Procedure Call - providing message transfers in cloud native clusters.
- Service Proxy—intercepting and forwarding traffic between services.
- API Gateway—providing API communication between end-users, cloud native apps and microservices.
- Service Mesh—managing initial traffic and communication between services, providing service-aware reliability and observability.
App Definition & Development
Includes tools for planning, developing and deploying cloud native applications. Layers in this category are:
- Database - data stores which are cloud native or can be integrated with cloud native infrastructure.
- Streaming & Messaging - middleware providing service-service communication.
- Application Definition & Image Build - supporting the container developer experience.
- Continuous Integration & Delivery (CI/CD)—tools which manage the development pipeline and provide automated deployment.
Observability & Analysis
Includes tools for giving insights about what’s going on in the cloud native infrastructure and pointing out areas that need improvement and/or special attention. Layers in this category are:
- Monitoring - providing instrumentation of applications, collecting vital metrics, and visualizing them for creating alerts and reports.
- Logging—gathering operational data and errors from cloud native elements.
- Tracing—following the path of a request in a dispersed system to help solving problems.
- Chaos Engineering—intentionally creating errors to see what the dispersed system will do and check its resilience.
Includes tools which modify cloud native applications into ready solutions that can be used by companies instead of an open-source project. Layers in this category are:
- Certified Kubernetes—Distribution
- Certified Kubernetes—Hosted
- Certified Kubernetes—Installer
- PaaS/Container Service
Basing on the CNCF landscape, the foundation created also the Cloud Native Trail Map, which is a recommended way in cloud native adoption consisting of 10 steps, most of them with a proper tool:
- Orchestration and application definition (use Kubernetes)
- Observability and analysis (use Prometheus)
- Service proxy, discovery, and mesh (use CoreDNS, Linkerd and Envoy)
- Networking and policy (use Calico or Weave Net)
- Distributed database and storage (use Vitess)
- Streaming and messaging (use gRPC or NATS)
- Container registry and runtime (use rkt or Harbor)
- Software distribution (use Sigstore or Notary)