SSH + shell scripts are pretty good for one off things. But they're rarely idempotent. Chef and Puppet will say "you asked for nginx version x, you have it, so I won't bother installing it". You can also handle dependencies and roles, so you end up with things like "this hosts a Rails application, so you need Ruby and bundler, nginx configured a certain way, and the upstream load balancer needs to point to the new server". So using shell scripts ends up either taking longer or as you grow it gets more complex because you have to check for different things that a specialized tool just handles natively.
On the deploy side, ssh + shell scripts might be a better solution (IMHO stuff like Capistrano and Fabric can be seen as a fancy wrapper around that). So the procedure for a deploy might be "check out source, copy to a certain folder, create these symlinks, restart these daemons". Deploys, by their very nature, aren't idempotent, as each deploy is intended to change the state, you either finish it or abort and roll back.
I interviewed community managers from Puppet and Chef over at http://linuxadminshow.com, there are some interesting comments from both about the need for it even at small scale. Nathen from Opscode had a few comments about erchef. He also runs a podcast called "Food Fight" where they very recently talked about using Chef for the deploy process (http://foodfightshow.org/2013/01/application-deployment.html)
That said, I prefer Puppet because its abstractions make more sense to me, and are pretty easily extended using Ruby.
Puppet is also trivial to bootstrap (at least on Debian). Unlike other Ruby stacks, I can install it using the package manager and be up and running in no time. With Chef you have to maintain additional services like CouchDB and RabbitMQ.
The real reason not to use ad hoc scripts or a tool you wrote yourself is that things like cfengine, Chef, and Puppet are maintained and used by communities -- your successor(s) will thank you.
And care about a lot of dependencies. Installing chef-server on a fresh ubuntu quantal:
0 upgraded, 444 newly installed, 0 to remove and 58 not upgraded.
Need to get 280 MB of archives.
After this operation, 775 MB of additional disk space will be used.
Of course a lot of that is due to how ubuntu packages java, but still... that's quite a lot of software to care about.http://www.opscode.com/chef/install - "Chef Server" tab.
If you'd like to build your own:
https://github.com/opscode/omnibus-chef https://github.com/opscode/omnibus-software https://github.com/opscode/omnibus-ruby
Cheers, Joshua Timberman, Technical Program Manager, Opscode, Inc.
The Chef 11 Server doesn't use gecode.
You can avoid those dependencies by using Chef Solo instead of Chef Server. In my opinion chef-solo is also a much easier way to learn Chef, so you can get the main concepts down before tackling chef-server.
But yes, Chef's dependencies are staggering. I once tried using an AWS micro instance for a Chef server, and it kept crashing because the system didn't have enough resources.
I can't talk about chef but puppet basically gives you a declarative language to specify the end-state in which the server config should end up as. So you say something like "the apache server must be enabled and running" and then when the client runs it makes sure the state matches that. So if for some reason apache gets disabled (say a new version of the package disables it) the next time the client runs it will right that.
I have even used Puppet but I could not get over the feeling I was placing a lot of trust in an agglomeration of system in provided recipes
You don't have to use the recipes. I had the same worry so what I did with my own puppet usage was set a rule that I won't copy recipes from anywhere and just use puppet to do the same things I would do directly on the server but describe them using puppet so I can replicate them later. This has worked great for me. I still have to learn all the details of how to configure everything on the machine but I now have a version controlled log of how I've configured everything and I can very easily apply the same recipe between two machines.
And even though I don't use copied recipes puppet itself abstracts away a bunch of stuff. So for example "make sure apache is installed" is implemented with apt in ubuntu and rpm in redhat. So if I wanted to repurpose my recipes from ubuntu to fedora I'd have to recode paths and package names but I wouldn't have to figure out how to interact with the package manager, what the command to create a new user is, etc.
With fabric it's easier to say - do this, do that. Both have their own place and you can use both for different tasks.
It may not matter at the first deployment stage (it's always install this, install that), but it does make a difference when you do continuous deployment for example. That are many dependencies that you'd have to implement in details and manually with systems like fabric.
I wrote a firewall cookbook that takes advantages of Chef's search capabilities to dramatically reduce the maintenance of our firewalls, while keeping the rules ultra specific (inbound and outbound). Check it out: https://github.com/jvehent/AFW/ & http://jve.linuxwall.info/blog/index.php?post/2012/11/14/AFW
Edit: just to clarify I am not attacking your choice here or your contribution to the state if the art in GitHub - we need more people making. But I would like to understand why a guy who is unlikely to run more than a couple dozen servers again needs to learn to debug and battle something like chef when the imperative scripting approach is simpler and more direct
I suppose I am asking, at what scale does chef et al pay off compared to expect-like scripts (assuming the development time of a simple script is roughly equal in both)
Then, yes, Chef is probably overkill. Although, the resources (template, command, etc...) are nice and helpful. But I wouldn't replace an existing working process with Chef is there's no obvious benefit.
A few reasons:
* You don't have to maintain that database manually, Chef collects and stores node information for you.
* If you've already automated building out your servers, you're all set when you need more of them.
* The recipes document your systems, so if you "get hit by a bus" someone else can figure out how the bits get around.
* When your datacenter burns down, you can rebuild quickly from bare metal, a chef repository, and backups of your application data.
Also see this article written by Jesse Robbins, one of the Opscode founders, but before Chef existed:
http://radar.oreilly.com/2007/10/operations-is-a-competitive...
The biggest difference is, as the previous replies hinted at, Chef/Puppet/CFengine will each run "constantly" checking the state of the system against their rules.
With your fabric-approach you can only cause changes to happen when you're in front of the computer are you run "fab apply", "fab apt-get-upgrade", etc.
FWIW I also use a simpler alternative, recently documented, introduced, and explored here:
http://www.steve.org.uk/Software/slaughter/guide/
My system also relies on manual re-runs of the "slaughter" tool, but I schedule that with cron.
(I've seen some cfengine repositories, for example, that assume Apache is present and just start tweaking the configuration files. If you're doing it properly you'd want to define a rule initially "install apache". That's why it is often instructive to test out your rules on a pristine/virgin installation of your preferred distribution to see that it works from start to finish.)
That's one thing, in Chef, that scares me. Access control on node attributes is inexistent. Even in private/hosted chef. So that a node can modify its own run_list, its own tags, etc...
A frontend node that gets rooted can suddenly become a backend database. If the environment is configured to allow for automated configuration of everything, this can get ugly very quickly.
Even with Chef, human approval of new nodes and roles is still mandatory.
I can do things like: "all my webservers with RAM > N should have different httpd.conf settings"
I have even used Puppet but I could not get over the feeling that it is more complex than I would imagine for small end users (I have managed upto 40 servers with my libraries - it seemed quite feasible to double that. Maybe it's me but 100 servers sounds a lot and is manageable (deployment wise) with controlled scripts.