Re: Droplets and Stacks

Onsi Fakhouri <ofakhouri@...>

Hey Colin,

Good stuff. I like to draw a circle around the rootfs, the buildpacks, the
generated droplet, the Task/LRP recipes, and the lifecycle binaries that
run inside containers to stage and launch droplets. You could label that
circle an application lifecycle. Diego currently supports three
application lifecycles and is loosely coupled to those lifecycles:

1. The Linux-Buildpack App lifecycle: includes the cflinuxfs2 rootfs, the
various buildpacks (including a known interface for building custom
buildpacks), the droplets (compiled artifacts guaranteed to run with
cflinuxfs2), two binaries: the builder (performs staging) and the launcher
(runs applications), and code that can convert CC requests for staging and
running instances to Diego Task/LRP recipes.

2. The Windows App lifecycle: includes the notion of a correctly configured
windows environment, a windows-compatible droplet, a builder, a launcher,
and code that can generate Tasks/LRPs. In this context we do not yet
have/need the notion of a buildpack though we are free to add one later.
The builder simply prepares the droplet from source and the launcher knows
how to invoke it.

3. The Docker App lifecycle: has no rootfs as the docker image provides the
entire rootfs, includes a builder to extract docker-metadata and send it
back to CC for safe-keeping, and a launcher to launch the requested process
*and* present it with a standard CF environment. Again, there's also code
that knows how to translate CC requests for a docker-based application into
Tasks and LRPs.

The cool thing is that Diego doesn't care about any of these details and
you are free to construct your own lifecycles and have your own contracts
within each lifecycle. You are spot on in noting that there is an implicit
contract between the buildpacks and the rootfs. I'd go further and say
that that implicit contract covers everything in the lifecycle circle (e.g.
the builder has a contract with the buildpacks, it expects `detect`,
`compile` and `release` to work a certain way, the recipes have a contract
with the builder/launcher, they expect particular command line arguments,

This is one reason why we've recently transitioned the ownership of the
rootfs from the runtime team to the buildpack team - as the buildpack team
is best suited to define and maintain the contract between the buildpacks
and the rootfs. Would love to explore ways to make all these contracts
more explicit.

One last point. I didn't use the word "stack" in this e-mail until just
now. I agree that it's an overloaded concept that is easily and often
misunderstood ;)


On Wed, Jul 29, 2015 at 9:51 AM, Colin Humphreys <colin(a)>

Hi All,

I wrote a couple of articles about droplets and stacks.

The droplet post is fairly self-explanatory, and enabling the choice of
shipping droplets or source is well on the way in Cloud Foundry development.

I feel our story around stacks is far less complete. It seems to be an
overloaded concept inherited from Heroku and the contract with the stack
seems to cause issues for both app and buildpack developers.

I'd like to open the discussion on what the future should be for stacks,
or if you think they're perfect as they are.


CloudCredo Cheerleader

cf-dev mailing list

Join { to automatically receive all group messages.