Books & Videos

Table of Contents

  1. Chef and Ruby 101

    1. Chapter 1 Introduction

      1. What Is Configuration Management?
      2. So Why Chef?
      3. Think Critically
      4. Meet AwesomeInc
      5. Criteria for Customization
      6. State of the Customization Nation
      7. Chef Installation Types and Limitations
      8. Prerequisites
      9. Assumptions
    2. Chapter 2 Just Enough Ruby to Customize Chef

      1. Ruby Is Object-Oriented
      2. Ruby Is Dynamically Typed
      3. Classes
      4. Variable Scoping
      5. Inheritance
      6. Modules
      7. Using Other Classes and Modules
      8. When Things Go Wrong
      9. Tying It All Together
      10. Summary
    3. Chapter 3 Chef Internals

      1. Chef Architecture
      2. Anatomy of a Chef Run
      3. Dry-Run and Why-Run
      4. Using the Source
      5. Tracing a chef-client Run
      6. Summary
  2. Customizing Chef Runs

    1. Chapter 4 Extending Ohai

      1. Introduction
      2. Ohai Example 1: Plugin Skeleton
      3. Testing and Running Ohai Plugins
      4. Ohai Example 2: Adding More to the Plugin
      5. Ohai Example 3: Multilevel Plugins
      6. Summary
    2. Chapter 5 Creating Handlers

      1. Preparing a Test Environment
      2. Introduction to Handlers
      3. The Run Status Object
      4. Handler Example 1: Start Handler
      5. Handler Example 2: Report Handler
      6. Handler Example 3: Exception Handler
      7. Handlers: Summary and Further Reading
    3. Chapter 6 Extending Chef Run Events

      1. Introduction to the Event Dispatcher
      2. Event Dispatcher Initialization
      3. Publish Overview
      4. Subscribe Overview
      5. Creating Formatters
      6. Creating Custom Subscribers
      7. Revisiting AwesomeInc—Which Customization?
      8. Summary
  3. Customizing Recipes

    1. Chapter 7 Definitions and Libraries

      1. Cookbook Structure Revisited
      2. Creating a Test Environment
      3. Definitions
      4. Libraries
    2. Chapter 8 Lightweight Resources and Providers

      1. Introduction to Resources and Providers
      2. Introduction to LWRPs
      3. LWRP Example 1: Getting Started with LWRPs
      4. The LWRP Domain-Specific Language
      5. LWRP Example 2: Extending the Provider
      6. Provider Internals
      7. LWRP Example 3: Native Provider
      8. Summary and Further Reading
    3. Chapter 9 Heavyweight Resources and Providers

      1. Introduction to HWRPs
      2. HWRP Example 1: Getting Started with HWRPs
      3. Advanced HWRP Tricks
      4. HWRP Example 2: Extending the package Resource
      5. Summary and Further Reading
  4. Other Customizations

    1. Chapter 10 Customizing Knife

      1. The Knife Source Code
      2. Introduction to Knife Plugins
      3. Anatomy of a Knife Command
      4. Creating a Test Environment
      5. Knife Example 1: Wrapping an Existing Plugin
      6. Presenting Presenters!
      7. The UI Class
      8. Knife Example 2: Search Plugin
      9. Working with Chef Objects
      10. Knife Example 3: Tying It All Together
      11. Revisiting AwesomeInc—Plugin Best Practices
      12. Summary and Further Reading
    2. Chapter 11 The Chef API

      1. Introduction to the Chef API
      2. Creating a Test Environment
      3. API Example 1: Authenticating and Making a GET Request
      4. The Chef::Rest Class
      5. API Example 2: Combining Multiple API Requests
      6. Error Handling
      7. Secrets of the Chef API
      8. Summary and Further Reading
    3. Chapter 12 Contributing Your Customizations

      1. Documentation
      2. Supporting Your Code
      3. Managing Contributions
      4. Testing Your Software
      5. Versioning Your Software
      6. Licensing and Copyright
      7. Distributing Your Customizations
      8. Summary
    4. Appendix Chef API Endpoints and Verbs