Most friends that I watch doing their deployment would be way more productive by simply using rsync for file changes and raw database queries when the DB needs a change.
The raw DB queries will invariably exist on someone's hard drive/in their head and be lost forever when they leave the team.
The rsync for file changes will result in developers stopping to ask each other "did this get rolled out yet?" multiple times a day.
Usually the version control happens in git. And the person who can push to production is also the person in charge of the master branch.
I always structure teams that way. So I cannot speak for other structures.
Tooling is literally just tools. You can have good ones and bad ones and either use them well or use them poorly. A deployment tool like Capistrano or deploybot is a tool, but so is a shell script that runs rsync the the same way each time it's invoked.
An automated deployment process that involves either zero or minimal human work, (e.g. 'click a button' or 'push to branch X in dvcs') means you get repeatability, and with that comes reliability. How many deploys will be messed up if someone is manually running rsync, because they forgot to exclude some files/dirs, or because they had a trailing slash in a path and things got put 1 directory level too deep?
For DB migrations in particular, I think you're alluding to not using a language/framework/model based migration (e.g. `rails db:migrate`) but instead to use just plain SQL. The difference for me here is whether you're suggesting they literally run the SQL required by hand (e.g. remembering/deducing which migration is required themselves, and either running an SQL file or typing the SQL into an interactive SQL session) or just that plain SQL should be used.
I have positive and negative thoughts about framework/model generated schemas. I think having the model system automatically generate/update schemas based on the model's properties, works fine for a dev environment, but for anything like testing/staging/prod environments, I believe the "best" solution is stored SQL files (preferably in the VCS itself) that are applied automatically by a tool. Those SQL files could be generated as an SQL 'diff' after running the Model generator if you wish, or they could just as easily be hand-written queries. Either way they should be reviewed as with the rest of the code anyway, so their origin is less important than their content.
And yes, I am somewhat "biased" in this: I've written a PHP framework that (amongst other things) will perform model-generated schema changes, and I've written a shell tool (written in shell) that will automatically apply DB migrations and rollbacks from a series of `{up,down}.sql` files.
As explained above, I see the former as a development tool, and the latter as a deployment tool.
It’s a bit flaky so we’ve been looking to replace it but don’t want to spend the company’s money building it. We’ve been looking but have not really found anything OSS.
We’re looking for:
- store text/binary documents
- full audit history of document versions
- get/put like api to retrieve/replace documents
- GUI to explore history/documents
- easily deplorable on Windows (ideally without an app server)
Anyone got any (more) suggestions?
Having said that, if your organisation chooses to use YAML, personally a better choice would be to just burn the place to the ground.
We built this tool because we had a need (everything is explained in the blog post)
We usually have a slew of different environments that are mostly the same except for one or two parameters. I would like to find a solution that has the ability to control common parameters in one place without having to code the inheritance into every language / setting where the config is accessed.
In general it seems like simply storing your config in JSON or YAML and putting it in git provides most of the features of many config solutions and the overhead of deploying something separate to handle it rarely justifies the marginal benefit from that.
That said, you can easily copy a config from one env to another and update that new config in no time.
comfy get env1 > tmp.json; comfy setall env2 tmp.json; comfy set env2 <key> <value>
