CNCF and 5 Things You Need To Know About It

Ladies and gentlemen – start your engines!

Just like the world of car racing has everchanging requirements, and requires innovative solutions, so does software design and app development. The need to be the fastest is something common amongst the two – so Cloud Native Computing Foundation, or CNCF, could be the tune up your open-source project needs to cross the white line.

The race car analogy is perfect to describe CNCF in Layman’s terms. In the racing scene, a sponsor may come to your team and want you to build the fastest car on the track. You say no problem, and proceed to put together a top-fuel dragster that can blitz the 1,000 foot in under 4 seconds – pumping out 340mph in the first 3 seconds alone. If we think of the sponsor as the client, the car as the containerized application, and the drag race as major scaling capability – now we have a comparison. It’s all about raw power and speed.

But say the sponsor isn’t happy with the fastest car you can muster – they want it to be fast not just in a straight line, but around a race track. You now need to build a completely different beast! The engine has to be smaller, more fuel efficient, and more reliable to deal with much longer races that last just a tad more than 4 seconds. You have to re-design the entire body with the suspension, steering, aerodynamics, and shape needed to now deal with cornering. Then there is the computer telemetry system that have sensors attached to everything – monitoring the condition of the tires, brakes, engine, transmission, fluid levels, in order to send that information back to the race team. It’s an entirely different car!

In software terms, shifting from raw unbridled power to being set up to handle other functions and workloads comes from adding functionality. But just like changing from a dragster to a track car, it’s impossible to change one into the other – you have to go back to the drawing board and start from the design and blueprint phase.

The sponsor comes back a third time and wants the car to specifically tackle a hill climb race. Not only that, they want to make the switch to electric power – something outside your expertise as a motor mechanic. Software design is no different in the sense that there are spanners thrown in the works (pun intended) in the form of unplanned changes to the core fundamentals of the build, that could even incorporate a new technology that you’re just not familiar with yet.

If this sounds super disruptive to the development process – that’s because it is. Each time a major change is made to the design brief, it’s almost like you have to stop and start over again. But by using CNCF architecture in the form of dynamically assembled microservices – you don’t have to. Going back to the analogy, it’s like turning your dragster into that Formula 1 car, that can also get up the top of that hill first – with its spare electric motor on board.

Sorcery? Witchcraft? No, it’s just common sense.


What the Cloud Native Computing Foundation landscape is can be a little tricky to get your head around. Basically, it’s a collection of open-source projects supported by ongoing contributions courtesy of a huge, vibrant community of programmers. The CNCF itself is a bit like a map showing you the full extent of all the solutions under its umbrella – in the form of open-source projects like Kubernetes, Prometheus, Envoy, and over 50 others.

CNCF is a Linux Foundation project, tasked with advancing container technology – the ability to package an application so it can be run with its dependencies, while being isolated from other processes. Pretty much packaged computing power done so for ease of use and to improve quality of life.


So, keeping in mind that CNCF is container technology, it helps to understand how it works before we look at what it’s used for. If we think of the landscape as a cargo ship, it makes sense to transport items all together in the same shipping container. It would be horribly inefficient if you had to randomly stack the cargo in the hold, you’d be losing a lot of cubic feet of space. Instead, the steel shipping containers offer a way to organize all the cargo into groups, stack it using all the available space for the journey, and have an easy way for the crane to unload it once it reaches the overseas dock. By standardizing the way cargo is transported as units (containers), and keeping them together in the same shipping container that can be moved as a single unit, costs are kept way down. Plus, it’s just an easier and more logical way of doing it.

It can be the same with computers. Migrating perfectly working software from the developer’s machine and onto the test machine can end up with the software performing like a horrible, janky mess. The software has been designed for a specific environment, and the difference in operating system, libraries, storage, security, and even network connectivity can throw up all sorts of bugs.

Going back to the shipping container analogy, imagine if the software housed in that container could be moved grouped with all its dependencies? The libraries, configuration files, and anything else it needs to operate properly? This would eliminate things like operating systems differing and causing problems, hardware compatibility issues, conflicting drivers – that sort of thing. Not only that, the software container would also handle how the software is deployed in the new machine.


So CNCF is set up in this multiple container structure, with each open-source project having a container master to which all others interact with as nodes. The Cluster Master schedules the workloads for each node, as well as how long they’re active, whether they need to be upgraded, and the like.

This system is especially useful for microservices server architecture, as they enable a program to be broken up into smaller pieces, a sum of its many individually operating processes.

By having a collaborative effort updating the various container master technologies, and housing them all under one roof in CNCF, developers have a huge selection on what they actually want in their containers, and in which configurations.


Currently there are a total of 15 graduated open-source projects that have been with the CNCF platform for a long time, can be considered trusted, and are used by at least 3 companies. There are 21 in the incubation phase as early adopters of the platform and visionary technologies, and 55 projects in the sandbox phase – yet to prove their code maturity, community involvement and sustainability as collaborators to the CNCF collective.

Kubernetes is perhaps the most well-known CNCF graduate, proving its worth by automating the deployment, scaling and management of container technology-based applications. It adds a layer of abstraction, grouping containers into pods for use in modular microservices systems, and to help software engineers schedule workloads.

Prometheus is another graduate level project and the second to join CNCF in the early days after Kubernetes. It can be used as a monitoring solution for both dynamic cloud environments as well as container technology by operating as a pull-based system – deciding when and what to scrape.

Envoy is still in the incubation stage, but is already proving its worth as a modern service proxy for use in Cloud Native applications. As it’s coded in C++, it’s both high performance and lightweight, able to easily communicate with any vendor. It also provides a fault tolerance function for microservices architecture, without changing any lines of existing code.

There are many, many other projects that cover everything from orchestrations, to app development, monitoring, logging, tracing, container registering, storage, databases, runtime environments, service discovery, service meshing, proxies, security, and all the way up to streaming and messaging apps. Whatever your need, there is likely an open-source project on CNCF ready and waiting to help you out.


Containers within CNCF are able to run all sorts of software, with the configurations and requirements controlled by the master node. The downside is that older software designed for running on virtual machines may not function well when switched over to container technology.

Managing software running as containers is actually pretty easy for developers, with Kubernetes being the pick of the bunch thanks to its Red Hat Openshift distribution – which actually ties in really well with the rapid deployment strategy you experience when using a DevOps philosophy in your development and operations cycle.

A virtual machine takes a while to boot up – any computer does. With container technology like CNCF, the operating system is already up and running on the server, meaning a container of software can be initialized in just a few seconds. Better yet, containers as a server can be started and stopped to suit demand – able to be ramped up to cope with peak user inquiries, or ramped down when the traffic subsides.

In the event that a container crashes, it can just be restarted and be back to doing its thing in mere moments. Security isn’t a risk as each container is using the same operating system. Should there be a security flaw in the host kernel, then yes, it may affect multiple containers connected as nodes. But monitoring software like Docker creates a requirement, in the form of signature infrastructure, to prevent containers coming live when they’re not authorized to do so. Likewise, Twistlock is a security software that closely profiles the behaviors of containers, and instantly shuts down any container suspected of performing suspicious activity outside the parameters of the system profile.

The Cloud Native ecosystem is one that is growing at an exponential rate. More and more sandbox level projects are being adopted, improving their visibility to the greater programming community and offering others a chance to make improvements based on their newfound application for the code.

Likewise, as projects are adopted by companies, their status is elevated to a more trusted level. Learning how to use the technologies contained within the CNCF to your advantage is definitely something to learn for the future, as container technology is here to stay and will soon be the standard in how software is developed and deployed.


These are most likely the 5 best online resources relevant to CNCF and container technology in general. Whether you’re a relative novice, or someone who has been around the block a few times, it doesn’t matter – you’ll benefit greatly from learning about CNCF!


CNCF have a brilliant collection of courses on how to use Kubernetes, and is well worth a look.


Likewise, CNCF run programs presented by companies who use CNCF like Twitter, Upbound and DeployHub that run through ways to use the various open-source projects.


Linux runs an exhaustive free course with over 50 hours of material that goes through the ins and outs and cloud infrastructure and container technologies.


Another one by Linux, except this time in the form of a 24-hour total audio course explaining how to build runtime frameworks with buildpacks.


To round out the list, and complete a trio of Linux courses, why not check out how Prometheus can help with monitoring and basic querying.

Next Steps

We hope this article helped you learn more about CNCF! If you enjoyed this article you may also enjoy Why CircleCi Is Best For Continuous Integration and Delivery or What Is NOSQL: The 4 Best Databases Explained.

Kofi Group offers a multitude of resources to help you learn more, improve your career, and help startups hire the best talent. If you are interested in learning more get in touch today!