Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Chef Infrastructure Automation Cookbook Second Edition
  • Toc
  • feedback
Chef Infrastructure Automation Cookbook Second Edition

Chef Infrastructure Automation Cookbook Second Edition

By : Marschall
3.7 (6)
close
Chef Infrastructure Automation Cookbook Second Edition

Chef Infrastructure Automation Cookbook Second Edition

3.7 (6)
By: Marschall

Overview of this book

This book is for system engineers and administrators who have a fundamental understanding of information management systems and infrastructure. It helps if you've already played around with Chef; however, this book covers all the important topics you will need to know. If you don't want to dig through a whole book before you can get started, this book is for you, as it features a set of independent recipes you can try out immediately.
Table of Contents (9 chapters)
close
close
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Sections
Conventions
Reader feedback
Customer support
Free Chapter
1
1. Chef Infrastructure
chevron up
1. Chef Infrastructure
Introduction
Using version control
Installing the Chef development kit on your workstation
Using the hosted Chef platform
Managing virtual machines with Vagrant
Creating and using cookbooks
Inspecting files on your Chef server with knife
Defining cookbook dependencies
Managing cookbook dependencies with Berkshelf
Downloading and integrating cookbooks as vendor branches into your Git repository
Using custom knife plugins
Deleting a node from the Chef server
Developing recipes with local mode
Using roles
Using environments
Freezing cookbooks
Running Chef client as a daemon
Using chef-shell
2
2. Evaluating and Troubleshooting Cookbooks and Chef Runs
2. Evaluating and Troubleshooting Cookbooks and Chef Runs
Introduction
Testing your Chef cookbooks
Flagging problems in your Chef cookbooks
Test-driven development for cookbooks using ChefSpec
Integration testing your Chef cookbooks with Test Kitchen
Showing affected nodes before uploading cookbooks
Overriding a node's run list to execute a single recipe
Using why-run mode to find out what a recipe might do
Debugging Chef client runs
Inspecting the results of your last Chef run
Raising and logging exceptions in recipes
Diff-ing cookbooks with knife
Using community exception and report handlers
Creating custom handlers
3
3. Chef Language and Style
3. Chef Language and Style
Introduction
Using community Chef style
Using attributes to dynamically configure recipes
Using templates
Mixing plain Ruby with Chef DSL
Installing Ruby gems and using them in recipes
Using libraries
Using definitions
Creating your own Lightweight Resource Providers (LWRP)
Extending community cookbooks by using application wrapper cookbooks
Creating custom Ohai plugins
Creating custom knife plugins
4
4. Writing Better Cookbooks
4. Writing Better Cookbooks
Introduction
Setting the environment variables
Passing arguments to shell commands
Overriding attributes
Using search to find nodes
Using data bags
Using search to find data bag items
Using encrypted data bag items
Accessing data bag values from external scripts
Getting information about the environment
Writing cross-platform cookbooks
Finding the complete list of operating systems you can use in cookbooks
Making recipes idempotent by using conditional execution
5
5. Working with Files and Packages
5. Working with Files and Packages
Introduction
Creating configuration files using templates
Using pure Ruby in templates for conditionals and iterations
Installing packages from a third-party repository
Installing software from source
Running a command when a file is updated
Distributing directory trees
Cleaning up old files
Distributing different files based on the target platform
6
6. Users and Applications
6. Users and Applications
Introduction
Creating users from data bags
Securing the Secure Shell Daemon (SSHD)
Enabling passwordless sudo
Managing NTP
Managing nginx
Creating nginx virtual hosts
Creating MySQL databases and users
Managing WordPress sites
Managing Ruby on Rails applications
Managing Varnish
Managing your local workstation
7
7. Servers and Cloud Infrastructure
7. Servers and Cloud Infrastructure
Introduction
Creating your infrastructure using Chef Provisioning
Creating cookbooks from a running system with Blueprint
Running the same command on many machines at once
Setting up SNMP for external monitoring services
Deploying a Nagios monitoring server
Building high-availability services using heartbeat
Using HAProxy to load-balance multiple web servers
Using custom bootstrap scripts
Managing firewalls with iptables
Managing fail2ban to ban malicious IP addresses
Managing Amazon EC2 instances
Loading your Chef infrastructure from a file with spiceweasel and knife
8
Index
Index

Using chef-shell

Writing cookbooks is hard. Being able to try out parts of a recipe interactively and using breakpoints really helps to understand how your recipes work.

Chef comes with chef-shell, which is essentially an interactive Ruby session with Chef. In chef-shell, you can create attributes, write recipes, and initialize Chef runs, among other things. Chef-shell allows you to evaluate parts of your recipes on the fly before uploading them to your Chef server and executeing complete cookbooks on your nodes.

How to do it...

Running chef-shell is straightforward.

  1. Start chef-shell in standalone mode:
    mma@laptop:~/chef-repo $ chef-shell
loading configuration: none (standalone chef-shell session)
Session type: standalone
Loading......done.


This is the chef-shell.
 Chef Version: 11.18.0
 http://www.chef.io/chef
 http://docs.chef.io/

run `help' for help, `exit' or ^D to quit.

Ohai2u mma@laptop!
chef >
  2. Switch to the attributes mode in chef-shell:
    chef > attributes_mode
  3. Set an attribute value to be used inside the recipe later:
    chef:attributes > set[:title] = "Chef Cookbook"
 => "Chef Cookbook"
    chef:attributes > quit
 => :attributes
chef >
  4. Switch to the recipe mode:
    chef > recipe_mode
  5. Create a file resource inside a recipe, using the title attribute as content:
    chef:recipe > file "/tmp/book.txt" do
chef:recipe >     content node.title
chef:recipe ?> end
 => <file[/tmp/book.txt] @name: "/tmp/book.txt" @noop: nil @before: nil @params: {} @provider: Chef::Provider::File @allowed_actions: [:nothing, :create, :delete, :touch, :create_if_missing] @action: "create" @updated: false @updated_by_last_action: false @supports: {} @ignore_failure: false @retries: 0 @retry_delay: 2 @source_line: "(irb#1):1:in `irb_binding'" @elapsed_time: 0 @resource_name: :file @path: "/tmp/book.txt" @backup: 5 @diff: nil @cookbook_name: nil @recipe_name: nil @content: "Chef Cookbook">
chef:recipe >
  6. Initiate a Chef run to create the file with the given content:
    chef:recipe > run_chef

    [2014-12-12T22:26:42+01:00] INFO: Processing file[/tmp/book.txt] action create ((irb#1) line 1)
...TRUNCATED OUTPUT...
=> true

How it works...

Chef-shell starts an interactive Ruby Shell (IRB) session, which is enhanced with some Chef-specific features. It offers certain modes, such as attributes_mode or recipe_mode, which enable you to write commands like you would put them into attributes file or recipes.

Entering a resource command into the recipe context will create the given resource, but not run it yet. It's like Chef reading your recipe files and creating the resources but not yet running them. You can run all the resources you created within the recipe context using the run_chef command. This will execute all the resources on your local box and physically change your system. To play around with temporary files, your local box might do, but if you're going to do more invasive stuff, such as installing or removing packages, installing services, and so on, you might want to use chef-shell from within a Vagrant VM.

There's more...

Not only can you run chef-shell in standalone mode but you can also in Chef client mode. If you run it in Chef client mode, it will load the complete run list of your node and you'll be able to tweak it inside the chef-shell. You start the Chef client mode by using the run it --client parameter:

mma@laptop:~/chef-repo $ chef-shell --client

You can configure which Chef server to connect it to in a file called chef-shell.rb, in the same way as you do in the client.rb file on your local workstation.

You can use chef-shell to manage your Chef server, for example, listing all nodes:

chef > nodes.list
[node[my_server]]

You can put breakpoints into your recipes. If it hits a breakpoint resource, chef-shell will stop the execution of the recipe and you'll be able to inspect the current state of your Chef run:

breakpoint "name" do
  action :break
end

See also

End of Chapter 1
Next Chapter
bookmark search playlist font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete