I do prefer to have lots of dumb files than having to deal with the cognitive load of a tool that in the end will generate lots of files anyways.
183 karma · joined November 9, 2019
I do prefer to have lots of dumb files than having to deal with the cognitive load of a tool that in the end will generate lots of files anyways.
Do this instead:
1. Use flat yaml files. No loops nor conditionals, no complexity.
2. One (single) yaml file templated by ansible just for secret/sensitive stuff.
3. Done.
Boring is better and is easy to diff.
The great thing is that it is a mature tool and you don't need to bring another beast to the zoo.
Thanks for your comment, I appreciate that! Both tools you mentioned are great and kinda relate to this experiment too.
The existence of docker and how it was developed and absorved by people brought nice things too. The kernel had to workout some areas.
The tool itseft is ok. I use something like this:
.
|-- Dockerfile
|-- README.md
`-- rootfs
|-- etc
| `-- sample
| `-- sample.conf
`-- usr
`-- bin
`-- sample
5 directories, 4 filesBut I'm not talking about that.
For me is just interesting, you know, the tool itself doesn't matter, one can do that with any tool.
This experiment was to measure how humans entering an existing field will react... just like language has been shaped.
It was a bit sad that nobody was curious enough to talk about ${FOO_PORT:-1234} and why we should deprecate (links) or about "defaults". It was a success, though.
I hope that one day we will stop echoing that or framing it as a bad thing.
It's always good to involve people. Writing, build and running software is a shared responsibility.
I truly believe that if you be nice with your ops, explain what you want to achieve, they will help you. It is a two-way street.
It is not a tool that will "fix" how humans interact.
Also, put yourself in their shoes, it could be that:
"With Docker everything new becomes a snowflake on its own where you need to call in "dev" for the smallest of things." -- or uncompress the image and look around how/what a specific image does things when it start, place app/config/data files, etc...
Infect is a too strong word, because normally the cross compiler will coexist well with your system. But you are right about the chroot, throw it away and start again, repeat. That is great!
I normally install gcc-arm-linux-gnueabihf + qemu-user-static and enable binfmt. It works well for building armhf, but I can imagine for things like ESP32 where you don't have the toolchain sources and etc.
Building software on top of frankenstein build environments is how you end with broken software, and should not be encouraged :)
Let alone development environment.
Software has to be read or at least installed in a safe place (before installing on a live server) so then one can be sure it does nothing silly.
Packaging is not hard, but there are some rules, including placing binaries in /usr/bin, configuration files in /etc and /etc/default (deb) or /etc/sysconfig (rpm), general package files in /usr/share. If you place files in the standard locations probably the package manager will detect changes in config files.
".. in 2009: nobody could remake our centos4 build machine for our C++ code ... so absolutely fucking cursed"
What lead a computer running a supported operating system[1] in a state like this? Distill that and you have docker :)
1. https://en.wikipedia.org/wiki/CentOS#End-of-support_schedule
It's just a rootfs compressed tarball. Running on top of Linux technology.
Docker was always a brittle tool with lots of limitations and huge compromisses.
Want to ${FOO_PORT:-1234}? Forget about it. Running random stuff as root? Why not?
It also made very easy to consume and produce junk/snowflakes.
Every docker image place its files/configuration/data in a special place. FHS? Who need that?
People have been running, packaging and distributing software more efficiently and more secure way before docker even existed.
Another tool that made existing technology more popular is Kubernetes.
But it did a better job in this "container" space.
Now you are making way to many assumptions with this phrase.
Do you really think that make sense to have critical security updates for stable having to pass through the normal release cycle? :)
Creating a Debian package is actually pretty straight forward:
1. download upstream tarball.
2. execute dh_make -f <path-to-tarball>
3. debuild -us -uc -b
That is it! There is no secret.
dh_make does the heavy lift of generating everything you need.
Your only job is to declare the dependencies (build and runtime ones) inside the "control" file, maybe change the "rules" file (it is a Makefile).
There are also several helpers that goes even further and automate 99% of the process.
How does it works? 1. Upstream release a new version, it goes to unstable. 2. Package is tested for some days in unstable and get promoted to testing.
So telling that testing doesn't get security updates is somewhat incorrect, since you are grabing recent software. But by the other hand having too recent software also has its downside ;)
Compare https://distrowatch.com/table.php?distribution=debian and https://distrowatch.com/table.php?distribution=ubuntu and you will realize that all the freshness of Ubuntu is build on top of what is available in Debian unstable.
I don't think this idea of "Debian packages are often very outdated" still applies nowadays. One can add "testing" or "backports" channels in your /etc/apt/sources.lists.d and get "upstream version" software. Even "stable" ships fresh enough software these days.
In the last case you can always get the source, update it and send a nmu back to Debian. Lets not forget that that is how open source works :)
I believe people should be doing that more often, you know, just moving stuff around.