e-Book Test-Driven Infrastructure with Chef download

Not worth the cover price. The book is 70-something pages, and the first half is about signing up for hosted chef and how to sign up for AWS (EC2). Once you're signed up and have ruby installed, there is ONE example where the author walks through how to set up an installation with the associated tests. The rest of the book is all about why infrastructure-as-code is a good thing. I would not recommend this book to anyone, it seems more like an introductory blog post about BDD and Chef than anything else. After I finished the book, I spent an hour reading the actual chef docs and came away having learned more.

I disagree with some of the more negative reviews of this book. I feel it was a well written introduction on the topic. It is true that it would be better if cucumber-chef worked with open Chef as well as OpScode's hosted version, but that did not block the concepts or fail to get the value of the tools across. It also established a stable baseline for examples etc. The book takes you to the point of getting ready to do some serious infrastructure coding but stops there. A few chapters with example implementations for a variety of popular cookbooks, or a fictional web business in a second edition would be great to see.

Looking forward to seeing the upcoming Chef book that the author mentions he is in the process of writing.

I would definitely recommend this to anyone who is trying to figure out how to avoid having full mirrored dev, qa, and production environments. The methods taken with the cucumber integration is pretty sweet. That said, I don't have it working in production yet, so the jury is still out on the technical feasibility of the approach.

This is basically a vague high level overview of testing your chef cookbooks in ec2. If you plan on using ec2 for all your testing and have only heard of chef then this might just be of a little value. Of course you can get the same information by spending 15 minutes on google.

...this is not the book you were looking for, though I did hear that the author may publish such a book. It is, as its title indicates, not a guide to Chef (if you're trying to pick up Chef as I was), but a guide to integrating Chef use in an overall plan or infrastructure.

The book is well written but there is very little content of value. It's basically a very good installation guide for Ruby and Cucumber. Simply not worth the money when all of this information is available on blogs and other install guides.

I wanted to like this book , I really did. However, it was short and the material felt strangely outdated and disjointed. I'll stick to the online docs.

I heard about this book on IRC, and thought I'd give it a try. I was
intrigued by the mixed reviews, especially as on the O'Reilly site the
book was well-received. The author is well-known in the Chef
community as a consultant and trainer, so I was interested to see what
he had to say on the subject.

Firstly, let me put some misconceptions to rest:

- This book is not fundamentally a Chef book, it's an exploration of the idea of applying test-driven development to infrastructure as code. It uses Chef as the framework for doing this.
- This book is not expensive - I think I paid $10 for my copy, which I think is good value

The first chapter presents an introduction to the idea of
infrastructure as code - it looks the origins of the movement, its
core principles, and the talks about some of the risks. The basic
argument seems to be that if we're going to practice infrastructure as
code, we need to take it seriously as a software project and apply
some well-known best practices from the software devlopment world. I
thought this was as good an introduction to the subject as I've found
anywhere on the web, and found the argument persuasive.

The second chapter presents a very high-level introduction to
Chef. It's only a few pages long, but I felt it managed to encapsulate
the fundamentals of the tool in a way which the Opscode website, wiki
and documentation site didn't achieve. I was particularly impressed
that in a book written two years ago, this hasn't aged at all. I
would recommend this chapter as a quick introduction to Chef.

The third chapter is designed to get the user up and running with
Chef. It covers installing Ruby (using RVM), getting set up with
Opscode's Hosted Chef platform, and getting your workstation ready to
start writing infrastructure code. This chapter seems to get crucified
by the negative reviewers, but I don't understand why. At the time it
was written, there was no easy way to install Chef, and electing to
use the hosted platform makes perfect sense for an instructional book
which wants to focus on the ideology of test-driven infrastructure. I
learned some neat tips on Git, and found the discussion of the
chef-repo to be informative. Sure, it's not so useful now we have
Omnibus installers, which ship Ruby as part of the install, but I
think the chapter was fine.

The fourth chapter was an introduction to the ideas of Behavior-driven
Development. I come from a system administration background, so this
was interesting and new content for me. It provided useful historical
background, and explained clearly and succintly the ideas of TDD and
BDD, and why they mattter. Again, I think this is one of the best
introductions to the subject I've ever read. It taught me useful
concepts and prepared the groundwork for the subsequent chapters. I
really enjoyed this section.

The fifth chapter introduced a tool called cucumber-chef. As in the
previous chapters it took a patient approach to explaining the ideas
and benefits, before taking me through how to use it. Again, I found
a few real gems in here, such as a great tip on making my knife config
work with multiple organizations. It contained a walkthrough of
signing up for AWS, which perhaps isn't needed, but again, two years
ago, AWS wasn't so well-known, and the walk through only takes up two
pages. Even then, I found I learned something about knife,

The final chapter is a bit of a mixed bag, but I think this is mainly
because the version of cucumber-chef that it uses is (obviously) two
years old. Anyone expecting this to be 100% accurate is simply naive,
in my view. So, although I found the worked example hard to follow,
the actual content and the basic ideas were excellent. I loved the
way it covered requirements gathering, and then talked through the
red-green-refactor approach to converting those requirements into
working infrastructure. This chapter also contained a more detailed
introduction to Chef, covering resources, recipes, cookbooks and
roles. I thought this was very clear and again, despite being based
on version 10, wasn't at all out of date. It also did an excellent
job of explaining what actually happens when Chef runs. It gives an
example of using so-called databags to contain user information and
ssh keys, and also explains how Chef templates work. There was a
section on Chef enviroments too. Given that this is a book about
testing, the author managed to fit a lot of really valuable Chef
instruction into this chapter, all of which is accurate and helpful.

I felt the chapter finished in a bit of a hurry - I would have liked
to have seen more about using a bootstrap or a knife command to build
a machine, but this wasn't really necessary for the argument of the
book, so it didn't spoil it for me in any way.

The final chapter - next steps - was a discussion starter - it gave me
some good ideas, and made me wish for more. It talks about the
importance of continuous integration and how the tests we write could
form the basis of a monitoring solution. I thought these were good
ideas - I only wished the author had covered them in the book.

In conclusion I thought this was an excellent book, and is required
reading for anyone interested in DevOps. There are flaws, the editing
is sloppy in places, and the actual worked example simply won't work,
but I was able to make it work on the new version of Cucumber-chef by
reading the documentation. For such a small title, the author manages
to cram in a massive amount of information and wisdom - I felt I
learned a huge amount, and got way more value from it than the $10 I
spent.

Don't be swayed by the poor reviews - this book is really great. I
hear the 2nd edition will be out very soon, and I can't wait to see
what that includes.

Summary: Essential reading for DevOps.

This book is sparse to put it lightly. I was expecting a thorough guide and instead what I received was a pamphlet on how to use the author's gem. I appreciate the work done in the gem, but this book goes into so little detail that you would be better off just browsing the internet and trying to piece things together yourself. The book talks a big game but fails to deliver on it's promises laid out in the early sections.