HNHacker News
TopNewBestAskShowJobs

theozero

26 karma · joined January 20, 2011

submissionscomments
theozero··on Do not use secrets in environment variables
also check out https://dmno.dev/docs/plugins/encrypted-vault/
theozero··on Do not use secrets in environment variables
To be fair, 1password is designed so that they cannot actually access your secrets, and it's likely many of your sensitive secrets are already stored there for use by humans.
theozero··on DMNO: Environment Variables Evolved
This happens all the time. Pull down the latest and suddenly you've got some cryptic runtime error, and it turns out there's a new config item everyone is missing. Wasting 20 minutes of 10 people's time quickly adds up - and while it may not happen that often, it does happen regularly. Also the "fix" is often insecurely sending the new key around on slack :(

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!

theozero··on DMNO: Environment Variables Evolved
We do certainly use JavaScript/TypeScript and we are targeting more JS heavy projects as initial users. That said, DMNO is meant to be universally applicable, and we think javascript is fairly _universal_, even if you personally don't love it.

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

theozero··on DMNO: Environment Variables Evolved
Thats right :) and yes while you could do something similar on your own, you'd end up building a ton of custom tooling that has nothing to do with your actual business.

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.

theozero··on DMNO: Environment Variables Evolved
There are tons of debates online about this. Realistically I think it's all tradeoffs and there are no silver bullets, so I won't really weigh in on the _right_ way to do it.

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.

theozero··on DMNO: Environment Variables Evolved
DMNO founder here - having a proper schema for your config lets us do things like validation, coercion (because env vars are all strings), generate types with built-in docs, and reuse and compose your config together to keep things DRY. It also lets us understand which of your config items are actually sensitive and treat them accordingly - helping ensure you don't leak those items.

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 :)

theozero··on DMNO: Environment Variables Evolved
DMNO creator here - sensitive config values are able to be retrieved from a variety of backends using a flexible plugin system. We are certainly not telling you that you have to use the encrypted file method, and depending on the security requirements of your project it may not be a good choice. You can also mix and match those plugins, and segment items however you see fit - so it's not always a single key being passed around.

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.

theozero··on Ask HN: What tools should I use to manage secrets from env files?
Another new (open source!) tool to check out in this space is https://dmno.dev

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

theozero··on Ask HN: Best Tools for Monorepo?
I've recently released a comprehensive tool for managing config / env vars - https://dmno.dev. It is the only tool I've seen that natively understands monorepos. This means you can reuse config from the root or other services (See https://dmno.dev/docs/guides/schema/#sharing-config-between-...)

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.

theozero··on Show HN: From dotenv to dotenvx – better config management
Super early days but we're building something very similar to what you are describing over at https://dmno.dev

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!

← PreviousPage 3 of 3