The Cloud Native Computing Foundation ( CNCF ) is a Linux Foundation project that was started in 2015 to help advance container technology and align the tech industry around its evolution.
78-475: It was announced alongside Kubernetes 1.0, an open source container cluster manager, which was contributed to the Linux Foundation by Google as a seed technology. Founding members include Google , CoreOS , Mesosphere, Red Hat , Twitter , Huawei , Intel , RX-M, Cisco , IBM , Docker , Univa , and VMware . Today, CNCF is supported by over 450 members. In order to establish qualified representatives of
156-462: A service mesh is a dedicated infrastructure layer for facilitating service-to-service communications between services or microservices using a proxy . A dedicated communication layer can provide numerous benefits, such as providing observability into communications, providing secure connections , and automating retries and backoff for failed requests. A service mesh consists of network proxies paired with each service in an application and
234-689: A CNCF incubating project in April 2019. OPA graduated from CNCF in February 2021. A Cloud Native Computing Foundation member project, Prometheus is a cloud monitoring tool sponsored by SoundCloud in early iterations. In August 2018, the tool was designated a graduated project by the Cloud Native Computing Foundation. Rook is CNCF's first cloud native storage project. It became an incubation level project in 2018 and graduated in October 2020. SPIFFE
312-539: A CNCF project in 2017. OpenTelemetry is an open source observability framework created when CNCF merged the OpenTracing and OpenCensus projects. OpenTracing offers "consistent, expressive, vendor-neutral APIs for popular platforms" while the Google-created OpenCensus project acts as a "collection of language-specific libraries for instrumenting an application, collecting stats (metrics), and exporting data to
390-457: A Kubernetes-certified IT professional is the vendor-agnostic Certified Kubernetes Administrator (CKA) accreditation, which is relevant to admins who work across a range of cloud platforms. There are tens of thousands of Certified Kubernetes Administrators (CKA) and Certified Kubernetes Application Developers (CKAD) worldwide. CNCF's Certified Kubernetes Conformance Program (KCSP) enables vendors to prove that their product and service conformant with
468-415: A ReplicaSet, serves the same purpose and behaves similarly to a ReplicaSet, which is to ensure that there will always be a specified number of pod replicas as desired. The ReplicationController workload was the predecessor of a ReplicaSet, but was eventually deprecated in favor of ReplicaSet to make use of set-based label selectors. Deployments are a higher-level management mechanism for ReplicaSets. While
546-500: A loose coupling within the infrastructure. For example, if an application's pods have labels for a system tier (with values such as frontend , backend , for example) and a release_track (with values such as canary , production , for example), then an operation on all of backend and canary nodes can use a label selector, such as: tier=backend AND release_track=canary Just like labels, field selectors also let one select Kubernetes resources. Unlike labels,
624-472: A minion, is a machine where containers (workloads) are deployed. Every node in the cluster must run a container runtime , as well as the below-mentioned components, for communication with the primary network configuration of these containers. kubelet is responsible for the running state of each node, ensuring that all containers on the node are healthy. It takes care of starting, stopping, and maintaining application containers organized into pods as directed by
702-470: A service can also be exposed outside a cluster (e.g., for clients to reach front-end pods). Filesystems in the Kubernetes container provide ephemeral storage , by default. This means that a restart of the pod will wipe out any data on such containers, and therefore, this form of storage is quite limiting in anything but trivial applications. A Kubernetes volume provides persistent storage that exists for
780-582: A set of building blocks ("primitives") that collectively provide mechanisms that deploy, maintain, and scale applications based on CPU , memory or custom metrics. Kubernetes is loosely coupled and extensible to meet the needs of different workloads. The internal components as well as extensions and containers that run on Kubernetes rely on the Kubernetes API. The platform exerts its control over compute and storage resources by defining resources as objects, which can then be managed as such. Kubernetes follows
858-542: A set of core Kubernetes APIs and are interoperable with other Kubernetes implementations. At the end of 2018, there were 76 firms that had validated their offerings with the Certified Kubernetes Conformance Program. In 2017, CNCF also helped the Linux Foundation launch a free Kubernetes course on the EdX platform — which has more than 88,000 enrollments. The self-paced course covers the system architecture,
SECTION 10
#1732852194622936-435: A set of task-management processes. The proxies are called the data plane and the management processes are called the control plane. The data plane intercepts calls between different services and processes them; the control plane is the brain of the mesh that coordinates the behavior of proxies and provides APIs for operations and maintenance personnel to manipulate and observe the entire network. The service mesh architecture
1014-423: A single cluster. As such, scheduler plug-ins may be developed and installed as in-process extensions to the native vanilla scheduler by running it as a separate scheduler, as long as they conform to the Kubernetes scheduling framework. This allows cluster administrators to extend or modify the behavior of the default Kubernetes scheduler according to their needs. A controller is a reconciliation loop that drives
1092-675: A single identity, ensuring that the highly varied needs of production environments are consistently met without compromise. SPIFFE joined the CNCF as a sandbox project in 2018, was accepted to incubation in 2020, and graduated in 2022. SPIRE is an open source identity provider for workloads based on the SPIFFE framework. It is highly pluggable, and fills the attestation and issuance needs required by any workload identity solution. The plugin interfaces it exposes allows users to write integrations with in-house systems, build internal self-service portals, and more. It
1170-412: A small group of people but [within] a very large ecosystem" and believes that CNCF is entering into a "second wave" due to increased industry awareness and adoption. In August 2018 Google announced that it was handing over operational control of Kubernetes to the community. Since its creation, CNCF has launched a number of hosted sub-projects. In January 2020, the CNCF annual report for the previous year
1248-423: A stable IP address and DNS name to the service, and load balances traffic in a round-robin manner to network connections of that IP address among the pods matching the selector (even as failures cause the pods to move from machine to machine). By default a service is exposed inside a cluster (e.g., back end pods might be grouped into a service, with requests from the front-end pods load-balanced among them), but
1326-423: A strong authentication method, network separation, each its own process, that can run both on a single master node or on multiple masters supporting high-availability clusters . The various components of the Kubernetes control plane are as follows. Etcd is a persistent, lightweight, distributed, key-value data store (originally developed for Container Linux ). It reliably stores the configuration data of
1404-459: A supported backend." Under OpenTelemetry, the projects create a "complete telemetry system [that is] suitable for monitoring microservices and other types of modern, distributed systems — and [is] compatible with most major OSS and commercial backends." It is the "second most active" CNCF project. In October 2020, AWS announced the public preview of its distro for OpenTelemetry. Thanos enables global query views and unlimited retention of metrics. It
1482-524: Is CNCF's fifth member project, and the project that coined the term “ service mesh ". Linkerd adds observability, security, and reliability features to applications by adding them to the platform rather than the application layer, and features a "micro-proxy" to maximize speed and security of its data plane. Linkerd graduated from CNCF in July 2021. Open Policy Agent (OPA) is "an open source general-purpose policy engine and language for cloud infrastructure." It became
1560-411: Is a pod , which consists of one or more containers that are guaranteed to be co-located on the same node. Each pod in Kubernetes is assigned a unique IP address within the cluster, allowing applications to use ports without the risk of conflict. Within the pod, all containers can reference each other. A container resides inside a pod. The container is the lowest level of a micro-service, which holds
1638-523: Is a distributed key value store, providing a method of storing data across a cluster of machines. It became a CNCF incubating project in 2018 at KubeCon+CloudNativeCon North America in Seattle that year. Falco is an open source and cloud native runtime security initiative. It is the "de facto Kubernetes threat detection engine". It became an incubating project in January 2020 and graduated in February 2024. Harbor
SECTION 20
#17328521946221716-468: Is a place for early-stage projects, and it was first announced in March 2019. The Sandbox replaces what had originally been called the "inception project level". In July 2020, Priyanka Sharma stated that CNCF is looking to increase the number of open source projects in the cloud native ecosystem. Cilium provides networking, security, and observability for Kubernetes deployments using eBPF technology. It joined
1794-475: Is a very powerful building block for issuing short-lived identity credentials to dynamic cloud workloads. SPIRE became a CNCF Graduated project in 2022. The Update Framework (TUF) helps developers to secure new or existing software update systems, which are often found to be vulnerable to many known attacks. TUF addresses this widespread problem by providing a comprehensive, flexible security framework that developers can integrate with any software update system. TUF
1872-548: Is an open-source container orchestration system for automating software deployment , scaling, and management. Originally designed by Google , the project is now maintained by a worldwide community of contributors, and the trademark is held by the Cloud Native Computing Foundation . The name Kubernetes originates from the Greek κυβερνήτης (kubernḗtēs), meaning governor, ' helmsman ' or 'pilot'. Kubernetes
1950-508: Is an "open source trusted cloud native registry project that stores, signs, and scans content." It became an incubating project in September 2019 and graduated in June 2020. Helm is a package manager that helps developers "easily manage and deploy applications onto the Kubernetes cluster." It joined the incubating level in June 2018 and graduated in April 2020. Istio is a service mesh technology. It
2028-614: Is an implementation of a network proxy and a load balancer , and it supports the service abstraction along with the other networking operations. It is responsible for routing traffic to the appropriate container based on IP and port number of the incoming request. In Kubernetes, namespaces are utilized to segregate the resources it handles into distinct and non-intersecting collections. They are intended for use in environments with many users spread across multiple teams, or projects, or even separating environments like development, test, and production. The basic scheduling unit in Kubernetes
2106-500: Is an official CNCF project. Its general availability and intention to donate the project to CNCF was announced by Docker in 2017. CoreDNS is a DNS server that chains plugins. Its graduation was announced in 2019. Originally built at Lyft to move their architecture away from a monolith , Envoy is a high-performance open source edge and service proxy that makes the network transparent to applications. Lyft contributed Envoy to Cloud Native Computing Foundation in September 2017. etcd
2184-505: Is an open standard and framework for workload identity, much the same way that OAuth is an open standard and framework for human identity. It is built from the ground up to accommodate modern computing environments, which operate with systems scale and velocity (as opposed to human scale and velocity), while still maintaining interoperability with existing technologies like OAuth and X.509 Public key infrastructure . Unlike other identity standards, SPIFFE supports multiple credential types for
2262-583: Is deciding where to store and manage configuration information, some of which may contain sensitive data. Configuration data can be anything as fine-grained as individual properties, or coarse-grained information like entire configuration files such as JSON or XML documents. Kubernetes provides two closely related mechanisms to deal with this need, known as ConfigMaps and Secrets , both of which allow for configuration changes to be made without requiring an application rebuild. The data from ConfigMaps and Secrets will be made available to every single instance of
2340-412: Is not scheduled in excess of available resources. For this purpose, the scheduler must know the resource requirements, resource availability, and other user-provided constraints or policy directives such as quality-of-service, affinity/anti-affinity requirements, and data locality. The scheduler's role is to match resource "supply" to workload "demand". Kubernetes allows running multiple schedulers within
2418-604: Is often abbreviated as K8s , counting the eight letters between the K and the s (a numeronym ). Kubernetes assembles one or more computers, either virtual machines or bare metal , into a cluster which can run workloads in containers. It works with various container runtimes, such as containerd and CRI-O . Its suitability for running and managing workloads of all sizes and styles has led to its widespread adoption in clouds and data centers. There are multiple distributions of this platform – from independent software vendors (ISVs) as well as hosted-on-cloud offerings from all
Cloud Native Computing Foundation - Misplaced Pages Continue
2496-492: Is to maintain a stable set of replica pods running at any given time. As such, it is often used to guarantee the availability of a specified number of identical Pods. The ReplicaSet can also be said to be a grouping mechanism that lets Kubernetes maintain the number of instances that have been declared for a given pod. The definition of a ReplicaSet uses a selector, whose evaluation will result in identifying all pods that are associated with it. A ReplicationController , similar to
2574-541: The Black Lives Matter movement. Sharma also stated that she was "personally involved in a project to eradicate racially problematic terminology from code" and that the foundation is "actively working to improve the gender and racial balance inside the cloud native ecosystem" while remaining committed to creating spaces and opportunities for LGBTQIA+ , women, Black and Brown people, and differently-abled people, specifically in regards to KubeCon. One path toward becoming
2652-420: The primary/replica architecture . The components of Kubernetes can be divided into those that manage an individual node and those that are part of the control plane. The Kubernetes master node handles the Kubernetes control plane of the cluster, managing its workload and directing communication across the system. The Kubernetes control plane consists of various components such as TLS encryption , RBAC , and
2730-545: The shim in favor of directly interfacing with the container through containerd, or replacing Docker with a runtime that is compliant with the Container Runtime Interface (CRI). With the release of v1.24 in May 2022, the "dockershim" has been removed entirely. Examples of popular container runtimes that are compatible with kubelet include containerd (initially supported via Docker), rkt and CRI-O . kube-proxy
2808-415: The 12th hosted project in September 2017 and became a graduated project in 2019. In 2020 it became an approved and fully integrated part of the CNCF ecosystem. Kubernetes is an open source framework for automating deployment and managing applications in a containerized and clustered environment. "It aims to provide better ways of managing related, distributed components across the varied infrastructure." It
2886-494: The CNCF at incubation level in October 2021 and the CNCF announced its graduation in October 2023. containerd is an industry-standard core container runtime. It is currently available as a daemon for Linux and Windows, which can manage the complete container lifecycle of its host system. In 2015, Docker donated the OCI Specification to The Linux Foundation with a reference implementation called runc. Since February 28, 2019 it
2964-503: The Deployment controller finds that only two instances are running (conflicting with the etcd declaration), it schedules the creation of an additional instance of that pod. The scheduler is an extensible component that selects the node that an unscheduled pod (the basic unit of workloads to be scheduled) runs, based on resource availability and other constraints. The scheduler tracks resource allocation on each node to ensure that workload
3042-469: The ReplicaSet controller manages the scale of the ReplicaSet, the Deployment controller manages what happens to the ReplicaSet – whether an update has to be rolled out, or rolled back, etc. When Deployments are scaled up or down, this results in the declaration of the ReplicaSet changing, and this change in the declared state is managed by the ReplicaSet controller. StatefulSets are controllers that enforce
3120-502: The actual cluster state toward the desired state, communicating with the API server to create, update, and delete the resources it manages (e.g., pods or service endpoints). An example controller is a ReplicaSet controller, which handles replication and scaling by running a specified number of copies of a pod across the cluster. The controller also handles creating replacement pods if the underlying node fails. Other controllers that are part of
3198-456: The application to which these objects have been bound via the Deployment. A Secret and/or a ConfigMap is sent to a node only if a pod on that node requires it, which will only be stored in memory on the node. Once the pod that depends on the Secret or ConfigMap is deleted, the in-memory copy of all bound Secrets and ConfigMaps are deleted as well. The data from a ConfigMap or Secret is accessible to
Cloud Native Computing Foundation - Misplaced Pages Continue
3276-423: The cloud". In June 2020, API management platform Kong announced that it would donate its open-source service mesh control plane technology, called Kuma, to CNCF as a sandbox project. In July 2020, MayaData donated Litmus, an open source chaos engineering tool that runs natively on Kubernetes, to CNCF as a sandbox-level project. NATS consists of a collection of open source messaging technologies that "implements
3354-529: The cluster, representing the overall state of the cluster at any given point of time. etcd favors consistency over availability in the event of a network partition (see CAP theorem ). The consistency is crucial for correctly scheduling and operating services. The API server serves the Kubernetes API using JSON over HTTP , which provides both the internal and external interface to Kubernetes. The API server processes, validates REST requests, and updates
3432-430: The cluster. Generally, most workloads scale in response to a desired replica count, depending on the availability and performance requirements as needed by the application. However, in other scenarios it may be necessary to deploy a pod to every single node in the cluster, scaling up the number of total pods as nodes are added and garbage collecting them as they are removed. This is particularly helpful for use cases where
3510-409: The control plane. kubelet monitors the state of a pod, and if not in the desired state, the pod re-deploys to the same node. Node status is relayed every few seconds via heartbeat messages to the API server. Once the control plane detects a node failure, a higher-level controller is expected to observe this state change and launch pods on another healthy node. A container runtime is responsible for
3588-453: The core Kubernetes system include a DaemonSet controller for running exactly one pod on every machine (or some subset of machines), and a Job controller for running pods that run to completion (e.g. as part of a batch job). Labels selectors often form part of the controller's definition that specify the set of pods that a controller manages. The controller manager is a single process that manages several core Kubernetes controllers (including
3666-483: The ecosystem incubator alongside Thanos in August 2020. CRI-O is an Open Container Initiative (OCI) based "implementation of Kubernetes Container Runtime Interface". CRI-O allows Kubernetes to be container runtime-agnostic. It became an incubating project in 2019. gRPC is a "modern open source high performance RPC framework that can run in any environment." The project was formed in 2015 when Google decided to open source
3744-399: The examples described above), is distributed as part of the standard Kubernetes installation and responding to the loss of nodes. Custom controllers may also be installed in the cluster, further allowing the behavior and API of Kubernetes to be extended when used in conjunction with custom resources (see custom resources, controllers and operators below). A node, also known as a worker or
3822-482: The lifecycle of containers, including launching, reconciling and killing of containers. kubelet interacts with container runtimes via the Container Runtime Interface (CRI), which decouples the maintenance of core Kubernetes from the actual CRI implementation. Originally, kubelet interfaced exclusively with the Docker runtime through a "dockershim". However, from November 2020 up to April 2022, Kubernetes has deprecated
3900-419: The lifetime of the pod itself. This storage can also be used as shared disk space for containers within the pod. Volumes are mounted at specific mount points within the container, which are defined by the pod configuration, and cannot mount onto other volumes or link to other volumes. The same volume can be mounted at different points in the file system tree by different containers. A common application challenge
3978-414: The major public cloud vendors. Kubernetes is one of the most widely deployed software systems in the world being used across companies including Google , Microsoft , Amazon , Apple , Meta , Nvidia , Reddit and Pinterest . Kubernetes ( Ancient Greek : κυβερνήτης , romanized : kubernḗtēs , ' steersman, navigator ' or ' guide ' , and the etymological root of cybernetics )
SECTION 50
#17328521946224056-412: The management of Kubernetes' traffic. Contour also provides routing features that are more advanced than Kubernetes' out-of-the-box Ingress specification. VMWare contributed the project to CNCF in July 2020. Cortex offers horizontally scalable, multi-tenant, long-term storage for Prometheus and works alongside Amazon DynamoDB, Google Bigtable, Cassandra, S3, GCS, and Microsoft Azure. It was introduced into
4134-403: The more important are: Containers emerged as a way to make software portable. The container contains all the packages needed to run a service. The provided file system makes containers extremely portable and easy to use in development. A container can be moved from development to test or production with no or relatively few configuration changes. Service mesh In software architecture ,
4212-401: The next version of its RPC infrastructure ("Stubby"). The project has a number of early large industry adopters such as Square, Inc. , Netflix , and Cisco . In September 2020, CNCF's Technical Oversight Committee (TOC) announced that KubeEdge was accepted as an incubating project. The project was created at Futurewei (a Huawei partner). KubeEdge's goal is to "make edge devices an extension of
4290-401: The notion of a primary instance and secondary instances. In this case, the notion of ordering of instances is important. Other applications like Apache Kafka distribute the data amongst their brokers; hence, one broker is not the same as another. In this case, the notion of instance uniqueness is important. DaemonSets are responsible for ensuring that a pod is created on every single node in
4368-432: The open source project can be relied upon to build a production-grade product. CNCF's process brings projects in as incubated projects and then aims to move them through to graduation, which implies a level of process and technology maturity. A graduated project reflects overall maturity; these projects have reached a tipping point in terms of diversity of contribution, community scale/growth, and adoption. The CNCF Sandbox
4446-602: The pod through one of the following ways: The biggest difference between a Secret and a ConfigMap is that Secrets are specifically designed for containing secure and confidential data, although they are not encrypted at rest by default, and requires additional setup in order to fully secure the use of Secrets within the cluster. Secrets are often used to store confidential or sensitive data like certificates, credentials to work with image registries, passwords, and ssh keys. Kubernetes enables clients (users or internal components) to attach keys called labels to any API object in
4524-577: The principal competitors rallied around Kubernetes and announced adding native support for it: On March 6, 2018, Kubernetes Project reached ninth place in the list of GitHub projects by the number of commits , and second place in authors and issues, after the Linux kernel . Until version 1.18, Kubernetes followed an N-2 support policy, meaning that the three most recent minor versions receive security updates and bug fixes. Starting with version 1.19, Kubernetes follows an N-3 support policy. Kubernetes defines
4602-482: The problems Kubernetes solves, and the model it uses to handle containerized deployments and scaling. The course also includes technical instructions on how to deploy a standalone and multi-tier application. CNCF developed a landscape map that shows the full extent of cloud native solutions, many of which fall under their umbrella. The interactive catalog gives an idea of the problems facing engineers and developers in deciding which products to use. This interactive catalog
4680-500: The properties of uniqueness and ordering amongst instances of a pod, and can be used to run stateful applications. While scaling stateless applications is only a matter of adding more running pods, doing so for stateful workloads is harder, because the state needs to be preserved if a pod is restarted. If the application is scaled up or down, the state may need to be redistributed. Databases are an example of stateful workloads. When run in high-availability mode, many databases come with
4758-410: The publish/subscribe, request/reply and distributed queue patterns to help create a performant and secure method of InterProcess Communication (IPC)." It existed independently for a number of years but gained wider reach since becoming a CNCF incubating project. Notary is an open source project that enables widespread trust over arbitrary data collections. Notary was released by Docker in 2015 and became
SECTION 60
#17328521946224836-434: The running application, libraries, and their dependencies. Kubernetes supports several abstractions of workloads that are at a higher level over simple pods. This allows users to declaratively define and manage these high-level abstractions, instead of having to manage individual pods by themselves. Several of these abstractions, supported by a standard installation of Kubernetes, are described below. A ReplicaSet 's purpose
4914-524: The selection is based on the attribute values inherent to the resource being selected, rather than user-defined categorization. metadata.name and metadata.namespace are field selectors that will be present on all Kubernetes objects. Other selectors that can be used depend on the object/resource type. Add-ons are additional features of the Kubernetes cluster implemented as applications running within it. The pods may be managed by Deployments, ReplicationControllers, and so on. There are many add-ons. Some of
4992-478: The state of the API objects in etcd, thereby allowing clients to configure workloads and containers across worker nodes. The API server uses etcd's watch API to monitor the cluster, roll out critical configuration changes, or restore any divergences of the state of the cluster back to the desired state as declared in etcd. As an example, a human operator may specify that three instances of a particular "pod" (see below) need to be running, and etcd stores this fact. If
5070-640: The subject of various jokes on Twitter due to the CNCF ecosystem's expansiveness and visual complexity. CNCF's Cloud Native Trail Map outlines the open source cloud native technologies hosted by the Foundation and outlines the recommended path for building a cloud native operation using the projects under its wing. The Cloud Native Trail Map also acts as an interactive and comprehensive guide to cloud technologies. Kubernetes Kubernetes ( / ˌ k ( j ) uː b ər ˈ n ɛ t ɪ s , - ˈ n eɪ t ɪ s , - ˈ n eɪ t iː z , - ˈ n ɛ t iː z / , K8s )
5148-666: The system, such as pods and nodes . Correspondingly, label selectors are queries against labels that resolve to matching objects. When a service is defined, one can define the label selectors that will be used by the service router/load balancer to select the pod instances that the traffic will be routed to. Thus, simply changing the labels of the pods or changing the label selectors on the service can be used to control which pods get traffic and which don't, which can be used to support various deployment patterns like blue–green deployments or A/B testing . This capability to dynamically control how services utilize implementing resources provides
5226-573: The technologies governed by the CNCF, a program was announced at the inaugural CloudNativeDay in Toronto in August, 2016. Dan Kohn (who also helped launch the Core Infrastructure Initiative) led CNCF as executive director until May 2020. The foundation announced Priyanka Sharma, director of Cloud Native Alliances at GitLab, would step into a general manager role in his place. Sharma describes CNCF as "a very impactful organization built by
5304-455: The workload has some dependency on the actual node or host machine, such as log collection, ingress controllers, and storage services. A Kubernetes service is a set of pods that work together, such as one tier of a multi-tier application. The set of pods that constitute a service are defined by a label selector. Kubernetes provides two modes of service discovery , using environment variables or using Kubernetes DNS. Service discovery assigns
5382-468: Was CNCF's first security-focused project and the ninth project overall to graduate from the foundation's hosting program. TikV provides a distributed key–value database. Vitess is a database clustering system for horizontal scaling of MySQL , first created for internal use by YouTube. It became a CNCF project in 2018 and graduated in November 2019. Contour is a management server for Envoy that can direct
5460-537: Was accepted by CNCF in September 2022 and graduated on July 12, 2023. Created by Uber Engineering, Jaeger is an open source distributed tracing system inspired by Google Dapper paper and OpenZipkin community. It can be used for tracing microservice -based architectures, including distributed context propagation, distributed transaction monitoring, root cause analysis, service dependency analysis, and performance/latency optimization. The Cloud Native Computing Foundation Technical Oversight Committee voted to accept Jaeger as
5538-473: Was announced by Google on June 6, 2014. The project was conceived and created by Google employees Joe Beda, Brendan Burns, and Craig McLuckie. Others at Google soon joined to help build the project including Ville Aikas, Dawn Chen, Brian Grant, Tim Hockin, and Daniel Smith. Other companies such as Red Hat and CoreOS joined the effort soon after, with notable contributors such as Clayton Coleman and Kelsey Hightower . The design and development of Kubernetes
5616-474: Was announced in June, 2014 and version 1.0 was released on July 21, 2015. Google worked with the Linux Foundation to form the Cloud Native Computing Foundation (CNCF) and offered Kubernetes as the seed technology. Google was already offering a managed Kubernetes service, GKE , and Red Hat was supporting Kubernetes as part of OpenShift since the inception of the Kubernetes project in 2014. In 2017,
5694-408: Was created in response to the proliferation of third-party technologies and the resulting decision-fatigue engineers and developers often experience when selecting software tools. In addition to mapping out the relevant and existing cloud native solutions, CNCF's landscape map provides details on the solutions themselves including open source status, contributors, and more. The landscape map has been
5772-472: Was designed to be easily addable to Prometheus deployments. CNCF hosts a number of efforts and initiatives to serve the cloud native community, including: CNCF hosts the co-located KubeCon and CloudNativeCon conferences, which have become a keystone events for technical users and business professionals seeking to increase Kubernetes and cloud-native knowledge. The events seek to enable collaboration with industry peers and thought leaders. The North America event
5850-550: Was inspired by Google's Borg cluster manager and based on Promise Theory . Many of its top contributors had previously worked on Borg; they codenamed Kubernetes " Project 7 " after the Star Trek ex- Borg character Seven of Nine and gave its logo a seven-spoked ship's wheel (designed by Tim Hockin). Unlike Borg, which was written in C++ , Kubernetes is written in the Go language. Kubernetes
5928-507: Was issued and reflected significant growth to the foundation across membership, event attendance, training, and industry investment. In 2019, CNCF grew by 50% since the previous year with 173 new members and nearly 90% growth in end-users. The report revealed a 78% increase in the usage of Kubernetes in production. CNCF technology projects are cataloged with a maturity level of Sandbox, Incubated, and Graduated, in ascending order. The defined criteria include rate of adoption, longevity and whether
6006-556: Was moved to an entirely remote model for its 2020 season due to the COVID-19 pandemic . CNCF's Diversity Scholarship program covers the ticket and travel to the KubeCon + CloudNativeCon conference. In 2018, $ 300,000 in diversity scholarships was raised to enable attendees from diverse and minority backgrounds to make the journey to Seattle for KubeCon and CloudNativeCon. In August 2020, Priyanka Sharma stated that CNCF stands "in solidarity" with
6084-453: Was originally designed by Google and donated to The Linux Foundation to form the Cloud Native Computing Foundation with Kubernetes as the seed technology. The "large and diverse" community supporting the project has made its staying power more robust than other, older technologies of the same ilk. In January 2020, the CNCF annual report showed significant growth in interest, training, event attendance and investment related to Kubernetes. Linkerd
#621378