garden

To add to what's already been said: If you think about it, CI pipelines are typically a complete description of how your system is built, tested, and deployed. Which is pretty fantastic except for how walled off they are. You can't really re-use these descriptions for e.g. development, they're not vendor agnostic, and they only way to run them is by pushing your code. Maybe it's a silly analogy but it's almost like being a web dev that doesn't have a browser and needs to send their code to a friend who can tell them if that font size looks good. I think we're way over due for freeing these "blueprints" of our system from the confines of CI and making them portable and flexible. And containers are the technology that's enabling that. Full disclaimer (as always): I work at Garden[0] where we're also solving that problem but taking a slightl

And there's us, https://garden.io, that does totally portable CI pipelines with caching from builds to tests: https://github.com/garden-io/garden I made an irreverent short on why your CI pipelines ought to be portable and runnable locally. Number one reason? Give your developers their time (and sanity) back. Pushing to Git in the inner loop disrupts flow and shatters attention. https://www.youtube.com/watch?v=JFnan6s2cDg

We use Mutagen for Garden's hot reloading mechanism. (Garden is a dev tool for K8s and hot reloading enables users to sync changes directly to a prod like dev environment as opposed to doing a rebuild and re-deploy). It really is a fantastic piece of technology and completely transformed the whole experience (we were using good 'ol rsync before). In particular it works seamlessly across platforms. If anyone's interested in how we use it, it's here: https://github.com/garden-io/garden/blob/master/core/src/plu...

Garden | Remote/Berlin | Senior Cloud Engineer, Senior UI Engineer, Open Source Maintaine, DevRel | Fulltime https://garden.io/careers Hi all, we're Garden[1]. Our mission is to keep developers productive and happy in the cloud-native era. Docker, Kubernetes and other cloud-native technologies have made us better than ever at operating our systems in production, but the day-to-day development experience has been left lagging behind. Developers spend less time in flow, and more time waiting for builds, debugging scripts, or otherwise fighting their tools. We're here to fix that. Our platform—which includes our open source core product[2]—allows developers to work on distributed systems with remote, production-like dev environments, while enjoying the same fast and frictionless feedback loops we've come to expect when developing a single se

Garden[1] is a tool we built (yes, I'm affiliated :)) that has a lot of this functionality built-in. Might fit your use case. We recently re-wrote the hot reload functionality to use Mutagen[2] under the hood and it's insanely fast (<200ms anecdotally). It also does two way sync which can be useful. The old implementation used rsync but a lot of our Windows users struggled with that. So I figured I'd share in case that sounds familiar. What happens after a sync event depends on the stack, but we've had pretty good success with Entr[3]. We often have it watch a single file so that multiple watchers in a shared dev cluster don't eat up all the node's resources. 1: https://github.com/garden-io/garden 2: https://mutagen.io/ 3: http://eradman.com/entrproject/

In that case you might also be interested in Garden (https://github.com/garden-io/garden). It's an open source tool made for developing distributed systems / micro services. It abstracts most of the gnarly parts of K8s away and allows you to opt into them as needed. Full disclosure, I am affiliated so apologies for the shameless plug. But figured it might of interest to you.

Full-disclosure: I co-founded a company that's building a developer tool for K8s (and distributed systems in general). But we've had a lot of success with running on GKE. The tool that we're making takes away the complexity of building, testing and deploying the stack, and GKE takes care of running it. In fact we use GKE for both our development and staging/prod environments. There are a lot of great tools out there that vastly improve the K8s developer experience[1] and the cloud providers take away of the pain of operating it. And with tools like Terraform and Pulumi you can codify the whole setup. Here's an example of how you can quite easily get started on GKE: https://medium.com/garden-io/gke-and-cloud-sql-a-complete-wo... Here's a video of the same workflow: https://www.youtube.com/watch?v=iHyeD97GrE4. [1] https://github.com/GoogleC

There are some nice open-source projects out there for getting started with distributed systems (full disclosure, I'm a co-founder of one of them). They all abstract away (what some may call) the boring bits of getting started with distributed systems, like plumbing and such, and in general aim to improve the overall developer experience. In no particular order: https://github.com/GoogleContainerTools/skaffold https://github.com/garden-io/garden https://github.com/windmilleng/tilt

Hi aloer! Garden co-founder, so perhaps (likely) a little biased[0]. Depending on your needs, Garden and Tilt are both great solutions, with slightly different philosophies. It's easy to get started with Tilt if you already have the Kubernetes manifests. If not, Garden might better suit your needs since its "container" module type allows you to provide only a minimal description of your module which Garden then maps into K8s manifests. So you won't have to write the full specs for 20+ services. (Garden also supports Kubernetes manifests and Helm charts if that's your jazz). Garden will also manage the dependencies between all your services (at a granularity of builds, deploys, tasks, and tests). So if service12 needs to be built before service20, and service18 needs to be deployed before service5, but only after the database migration for

Hey 10ko, Garden co-founder here. Thanks for the feedback! You're right, you shouldn't have to design your project around your tools. Rather you describe the individual components of your system, really just document them in a structured manner, and let your tool manage the resulting graph. Here's a link the Github repo in case you're interested: https://github.com/garden-io/garden. Always happy to get some feedback!