26 karma · joined January 20, 2011
Also don't forget having to log into CI and multiple infra providers to update those config values as well, where it can easily cause an outage (or at least block CI) if someone makes a mistake.
Of course you can do it a better way, but setting these tools up is often complex and costs money. We want to provide a tool that fixes all of the annoying papercuts of dealing with config, and is useful for everyone from solo devs all the way up to huge teams.
Please give it a whirl and let us know what you think!
Why?
- Your stack probably already includes some javascript, at the very least for a public facing website, and probably a lot more
- Most folks on your team probably know a bit of javascript, regardless of how they feel about it
- IDE tooling is usually pretty good, without installing additional plugins, and it can be run in the browser, which opens up some interesting possibilities
- npm modules exist to interact with most platforms/tools (many of which are official and maintained by the platform itself), helping to simplify the authoring of integrations
While DMNO does use vite under the hood, it's not at all tied to your own usage of vite, or even of JS/TS. Our bet on using JS/TS is that it's fairly universal - most projects at least have a web frontend of some kind, so it's likely part of your stack, and most team members can write a little javascript, even if they don't love doing so. The tooling is also quite good in most IDEs without installing plugins, and can even be run in the browser, which opens up some interesting possibilities. For most end-users it should feel like writing some glorified json, but by using typescript, we get nice IDE support, can define inline functions without some DSL, and can build with the full power of a real programming language in cases where it's necessary.
But I think we can all agree that MANY people are using env vars for secrets because of their simplicity, so our hope is to help make those folks more secure and solve some of the related papercuts.
Ultimately DMNO is designed in a way that we should be able to swap out how the config actually gets passed around, so we can hopefully help users use whatever is the most secure way to do things without having to think too much about it.
It's not that these problems are so hard, but I've seen them bite people and waste tons of time, over and over again. Every time you onboard a new team member, every time you add a new external service to the stack, every time you rotate a key that folks had in their local .env, every time you try deploying something to a new environment and have to manually set up 20 env vars.
I've personally seen many production outages and hours of wasted time due to forgetting to update some new env var in every environment, or even a simple typo while updating it. With DMNO, your deployment would fail before it reaches prod and you'd get a clear error message about what went wrong - in return for writing out a very simple schema. No more pulling down the latest code to discover nothing boots anymore, and having to track down whoever has the new XYZ_KEY to add to your local env.
Of course there are ways to mitigate these problems, but many of them costly and complex to set up - meaning it only makes sense for larger projects.
There's definitely a lot going on under the hood - but for most end users, writing out your schema should feel like a glorified json file and you'll get a ton of value in return. Would love for you to give it a shot and let me know what you think after trying it out :)
That said, it is a valid way that some folks use (see https://dotenvx.com/, https://github.com/AGWA/git-crypt, https://github.com/getsops/sops) which can make sense for simpler projects with less stringent security needs. The bonus here is it does not require setting up, paying for, or integrating any external service, and helps save you from "secret sprawl".
We have a plugin for 1password (which many teams are already using anyway) and have plugins planned for many other popular tools, including Infisical.
Many other tools only really make sense for bigger enterprises, either due to cost, complexity, or both. Our goal here (or one of them anyway) is to make a tool that provides enough value to use in all cases, from very small and simple to very large and complex.
It's a bit different than most of the other tools listed here, in that it is designed to generally solve the papercuts of dealing with config (both sensitive and not), and is not coupled to storing your sensitive config in a specific platform (paid or otherwise).
You define a simple schema for all of your config, and you get validations, built-in documentation, full type safety, and the ability to compose config together in any way you choose. You can also easily share config across a monorepo (if you are using one).
Additionally, our drop-in integrations (node, vite, nextjs, astro, remix, more on the way) go a bit deeper and do things like help you detect and stop leaked secrets, redact secrets in logs, and deal with the footguns of boot vs build time config in hybrid rendering environments.
As for storing/syncing sensitive data, we currently have 2 plugins but more are in the works and will be guided by user demand. The first lets you store your secrets encrypted within your repo (like dotenvx, git-crypt, etc), and the second lets you sync with 1password. Personally we think the 1password plugin makes sense for a lot of teams, since they are probably already using it. You can wire up individual items to your schema, or pull from dotenv style text blobs. You can (and should!) segment items into multiple vaults, and use multiple service accounts to access them. You can even mix and match plugins to pull secrets from multiple services.
(see https://dmno.dev/docs/plugins/encrypted-vault/ + https://dmno.dev/docs/plugins/1password/)
In the future, we'll have deeper support for things like key rotation and single-use keys, k8s, way more backends, etc. It's all open source, so come and tell us what you need (or even help us build it) and we'll make it happen!
If it's not obvious already, I am the creator :)
PS - Feel free to hit me up for more info or a demo - theo at dmno dot dev
It is admittedly geared towards JS/TS stacks, but supports other languages by running commands via `dmno run -- yourcommand` which will inject the resolved config into your command as env vars. Generating types and adding helpers for other languages should not be too tough. We'll follow user demand as to which to implement first.
We are currently working on a tool that will help you run and manage your local dev services as well, but it is not ready yet. In the meantime, you can check out https://tilt.dev which is oriented around docker and k8s but does have some ability to just run arbitrary scripts. As for running scripts in general, I've had some success hacking together pnpm and turborepo, even to run scripts in non js/ts services. Lastly, I'll mention https://moonrepo.dev/ as it has more native support for polyglot repos, and its notion of task inheritance keep things fairly clean, especially in a larger repo with many services.
Granted our solution is more javascript/typescript focused - and the config schema will be defined using TypeScript and piggyback on npm for sharing plugins/extensions. But the config will be usable in any language (and generate types for multiple languages) with deeper integrations coming soon.
The pluggable nature of our architecture also means you can encrypt secrets in your repo if you want to, or sync with other backends. Shouldn't be too hard to keep everything away from env vars either if that's what some folks want.
Would love your input, and to hear what you think!