Announcing Forge: a build system for Kubernetes services

Organizations are rapidly adopting Kubernetes and microservices for their cloud applications. Yet the workflow for deploying a microservice into Kubernetes is long and tedious. The typical microservice deployment workflow includes:

  • Writing the code for the service
  • Building a binary
  • Packaging the binary with its local dependencies in a Docker container
  • Pushing the container to a Docker registry
  • Provisioning the cloud resources necessary for the service (e.g., a database)
  • Writing the deployment and service configuration in Kubernetes YAML
  • Actually running `kubectl` to deploy the container with the desired configuration into the Kubernetes cluster

The cumulative friction in all these steps slows down your ability to ship software. So today, we’re announcing Forge, a fast build system designed for cloud native applications running on Kubernetes.

Today’s build systems are designed to take source code and produce a running binary. In cloud native applications, this is insufficient. Forge takes source code and produces a runnable service. In other words, Forge produces all the artifacts necessary to run the service.

% forge setup # set up Forge configuration
% git clone repo
% forge deploy

DevOps and Microservices

Adopting a microservices architecture for a cloud application creates a strong incentive to accelerate an organization’s DevOps maturity. Without a DevOps culture, development is motivated to keep pushing features as new services, while operations struggles to operate and scale these services. This misalignment between development and operations ultimately limits the agility and velocity benefits that can come from adopting microservices.

Many organizations we encounter have recognized this misalignment, and ask developers to also own the operational aspects of deploying and running a service. Unfortunately, the tools for developers are poor. Developers are forced to learn and write CloudFormation, Terraform, or other infrastructure-as-code language, which is an expensive context switch.

Forge simplifies this process. With Forge, developers define a forge.yaml file that contains the necessary information for deployment. Forge then builds the service, its dependencies, and deployment configuration to create the runnable service. This changes the dev/ops handoff: development is handing off both a service and the information needed to run the service.

Using Forge, development is able to easily assume responsibility for both the functionality and health of a service. In this model, operations is responsible for insuring a stable operational platform (e.g., Kubernetes, monitoring, Envoy) and providing the operational tools developers need.


We’re releasing Forge 0.1 today under the Apache Software License. Give it a try, and please file an issue or join our Gitter chat if you have any questions or feedback.