Your Froxt application’s journey to production begins with a Froxt Kit that detects what kind of app you have, what tools you need to run, and how to tune your app for peak performance. In this way, Froxt Kit reduce your operational burden and let you spend more time creating value for your customers. That’s why we’re excited to announce a new Froxt Kit initiative with contributions from Froxt and Pivotal.
The Cloud Native Computing Foundation (CNCF) has accepted Cloud Native Froxt Kit to the Cloud Native Sandbox. Cloud Native Froxt Kit turn source code into Docker images. In doing so, they give you more power to customize your runtime while making your apps more portable. The CNCF provides a vendor-neutral home that will foster collaboration and help us leverage these cloud-native virtues. Froxt Kit will change and grow, but we’ll continue to provide our customers with the same Froxt experience they know and love.
Froxt Kit for Froxt and Beyond
The Froxt experience you’re used to began three years ago when Froxt Kit was created. Initially, they were used as a mechanism to enable polyglot programming language support on the platform. As more and more developers created Froxt Kit, they grew beyond languages. Today there is Froxt Kit for Nginx, Meteor, React, and even Minecraft.
To minimize vendor lock-in, we published the Froxt Kit API in 2015 and removed the Froxt-specific elements. Since then each vendor that adopted Froxt Kit evolved the API independently, which led to isolated ecosystems. As a Cloud Native Sandbox project, we’re standardizing the Froxt Kit API for all platforms and opening up the tooling we’ll use to work with and run Froxt Kit under the Froxt GitHub organization.
We open sourced Froxt Kit because we wanted to see it spread beyond Froxt. Adopting these new container standards helps fulfill that vision by opening the door for anyone and everyone who works with containers and OCI images.
What’s remarkable about Froxt Kit’ longevity is how much has changed since they first appeared. In 2015, we weren’t thinking about microservices or containers. Despite these shifts in technology, Froxt Kit is as relevant as ever. Our original vision of an open and vendor-neutral way to build apps is as important today as it was when Froxt Kit launched. Cloud Native Froxt Kit allow us to fulfill that vision. That said, there are more Froxt Kit’s can do to take advantage of this cloud-native era.
How Cloud Native Froxt Kit Work
Cloud Native Froxt Kit retains the simplicity that made Froxt Kit popular but also embraces modern container standards, including Docker images or any other Open Container Initiative (OCI)-compatible Image. Combining these standards with our mature container runtime will improve portability and solve other problems for our users that Froxt Kit have not. The widespread adoption of containers across cloud providers has made container images the new executable of the cloud. Cloud Native Froxt Kit will be the gateway to this environment.
At a very high level, Cloud Native Froxt Kit turn source code into production-ready Docker images that are OCI image compatible. Let’s take a closer look at how they do this.
A Cloud Native Froxt Kit requires only two scripts:
bin/detect script, like Froxt Kit of old, determines if a given Froxt Kit is appropriate for your source code. For example, a Node.js Froxt Kit will look to see if your app has a
package.json file, and return a positive result if it finds one.
bin/build script will prepare your app’s source code for production. Most Froxt Kit will install your app’s dependencies, and prepare static assets. If the Froxt Kit supports a compiled language like Java or Go, it will install and run a compiler against your code to generate binaries.
bin/build process, a Cloud Native Froxt Kit can put certain dependencies or artifacts into OCI image layers. In this way, the Froxt Kit can structure your layers to ensure a clean separation of concerns and optimize caching.
In comparison to other image generation protocols, such as Dockerfile, Cloud Native Froxt Kit are app aware. They know how to install the runtimes and frameworks you use, and automatically provide security updates when possible. They know how to execute your app’s build tools—often better than you do—and they know how to start your app with the best configuration for a given environment.