Books & Videos

Table of Contents

  1. Controlling with Puppet Apply

    1. Chapter 1 Thinking Declarative

      1. Handling Change
      2. Using Idempotence
      3. Declaring Final State
      4. Reviewing Declarative Programming
    2. Chapter 2 Creating a Learning Environment

      1. Installing Vagrant
      2. Starting a Bash Shell
      3. Downloading a Box
      4. Cloning the Learning Repository
      5. Install the Vagrant vbguest Plugin
      6. Initializing the Vagrant Setup
      7. Verifying the /vagrant Filesystem
      8. Initializing Non-Vagrant Systems
      9. Installing Some Helpful Utilities
      10. Choosing a Text Editor
      11. Reviewing the Learning Environment
    3. Chapter 3 Installing Puppet

      1. Adding the Package Repository
      2. Installing the Puppet Agent
      3. Reviewing Dependencies
      4. Reviewing Puppet 4 Changes
      5. Making Tests Convenient
      6. Running Puppet Without sudo
      7. Running Puppet with sudo
      8. Reviewing Puppet Installation
    4. Chapter 4 Writing Manifests

      1. Implementing Resources
      2. Applying a Manifest
      3. Declaring Resources
      4. Viewing Resources
      5. Executing Programs
      6. Managing Files
      7. Avoiding Imperative Manifests
      8. Testing Yourself
      9. Reviewing Writing Manifests
    5. Chapter 5 Using the Puppet Configuration Language

      1. Defining Variables
      2. Finding Facts
      3. Calling Functions in Manifests
      4. Using Variables in Resources
      5. Defining Attributes with a Hash
      6. Declaring Multiple Resource Titles
      7. Declaring Multiple Resource Bodies
      8. Modifying with Operators
      9. Using Comparison Operators
      10. Evaluating Conditional Expressions
      11. Matching Regular Expressions
      12. Building Lambda Blocks
      13. Looping Through Iterations
      14. Reviewing Puppet Configuration Language
    6. Chapter 6 Controlling Resource Processing

      1. Adding Aliases
      2. Preventing Action
      3. Auditing Changes
      4. Defining Log Level
      5. Filtering with Tags
      6. Limiting to a Schedule
      7. Declaring Resource Defaults
      8. Reviewing Resource Processing
    7. Chapter 7 Expressing Relationships

      1. Managing Dependencies
      2. Referring to Resources
      3. Ordering Resources
      4. Assuming Implicit Dependencies
      5. Triggering Refresh Events
      6. Chaining Resources with Arrows
      7. Processing with Collectors
      8. Understanding Puppet Ordering
      9. Debugging Dependency Cycles
      10. Reviewing Resource Relationships
    8. Chapter 8 Upgrading Puppet 3 Manifests

      1. Replacing Deprecated Features
      2. Preparing for the Upgrade
      3. Testing with the Future Parser
      4. Enhancing Older Manifests
    9. Chapter 9 Wrap-Up of Puppet Basics

      1. Best Practices for Writing Manifests
      2. Learning More About Puppet Manifests
  2. Creating Puppet Modules

    1. Chapter 10 Creating a Test Environment

      1. Verifying the Production Environment
      2. Creating the Test Environment
      3. Changing the Base Module Path
      4. Skipping Ahead
    2. Chapter 11 Separating Data from Code

      1. Introducing Hiera
      2. Creating Hiera Backends
      3. Configuring Hiera
      4. Looking Up Hiera Data
      5. Providing Global Data
    3. Chapter 12 Using Modules

      1. Finding Modules
      2. Evaluating Module Quality
      3. Installing Modules
      4. Testing a Single Module
      5. Defining Config with Hiera
      6. Assigning Modules to Nodes
      7. Examining a Module
      8. Reviewing Modules
    4. Chapter 13 Designing a Custom Module

      1. Choosing a Module Name
      2. Generating a Module Skeleton
      3. Understanding Module Structure
      4. Installing the Module
      5. Creating a Class Manifest
      6. Declaring Class Resources
      7. Accepting Input
      8. Sharing Files
      9. Testing File Synchronization
      10. Synchronizing Directories
      11. Parsing Templates
      12. Testing the Module
      13. Peeking Beneath the Hood
      14. Best Practices for Module Design
      15. Reviewing Custom Modules
    5. Chapter 14 Improving the Module

      1. Validating Input with Data Types
      2. Looking Up Input from Hiera
      3. Building Subclasses
      4. Creating New Resource Types
      5. Understanding Variable Scope
      6. Calling Other Modules
      7. Ordering Dependencies
      8. Containing Classes
      9. Creating Reusable Modules
      10. Best Practices for Module Improvements
      11. Reviewing Module Improvements
    6. Chapter 15 Extending Modules with Plugins

      1. Adding Custom Facts
      2. Defining Functions
      3. Creating Puppet Types
      4. Adding New Providers
      5. Identifying New Features
      6. Binding Data Providers in Modules
      7. Requirements for Module Plugins
      8. Reviewing Module Plugins
    7. Chapter 16 Documenting Modules

      1. Learning Markdown
      2. Writing a Good README
      3. Documenting the Classes and Types
      4. Documenting Functions
      5. Generating Documentation
      6. Updating Module Metadata
      7. Maintaining the Change Log
      8. Evolving and Improving
      9. Best Practices for Documenting Modules
    8. Chapter 17 Testing Modules

      1. Installing Dependencies
      2. Preparing Your Module
      3. Defining RSpec Unit Tests
      4. Creating Acceptance Tests
      5. Using Skeletons with Testing Features
      6. Finding Documentation
      7. Reviewing Testing Modules
    9. Chapter 18 Publishing Modules

      1. Updating the Module Metadata
      2. Packaging a Module
      3. Uploading a Module to the Puppet Forge
      4. Publishing a Module on GitHub
      5. Automating Module Publishing
      6. Getting Approved Status from Puppet Labs
  3. Using a Puppet Server

    1. Chapter 19 Preparing for a Puppet Server

      1. Understanding the Catalog Builder
      2. Planning for Puppet Server
      3. Choosing Puppet Master Versus Puppet Server
      4. Ensuring a High-Performance Server
    2. Chapter 20 Creating a Puppet Master

      1. Starting the puppetmaster VM
      2. Installing the Puppet Master
      3. Configuring a Firewall for the Puppet Master
      4. Running the WEBrick Server
      5. Testing with the Puppet Master Service
      6. Scaling the Puppet Master with Passenger
      7. IPv6 Dual-Stack Puppet Master
      8. Debugging Puppet Master
    3. Chapter 21 Creating a Puppet Server

      1. Starting the puppetserver VM
      2. Installing Puppet Server
      3. Configuring a Firewall for Puppet Server
      4. Configuring Puppet Server
      5. Running Puppet Server
      6. IPv6 Dual-Stack Puppet Server
    4. Chapter 22 Connecting a Node

      1. Creating a Key Pair
      2. Authorizing the Node
      3. Downloading the First Catalog
      4. Installing Hiera Data and Modules
      5. Testing with a Client Node
      6. Learning More About Puppet Server
    5. Chapter 23 Migrating an Existing Puppet Master

      1. Migrating the Puppet Master Config
      2. Synchronizing All Environments
      3. Copying Hiera Data
      4. Moving the MCollective Config Directory
      5. Removing Node Inheritance
      6. Testing a Client Node
      7. Upgrading Clients
    6. Chapter 24 Utilizing Advantages of a Puppet Server

      1. Using Server Data in Your Manifests
      2. Backing Up Files Changed on Nodes
      3. Processing Puppet Node Reports
    7. Chapter 25 Managing TLS Certificates

      1. Reviewing Node Authentication
      2. Autosigning Agent Certificates
      3. Using an External Certificate Authority
      4. Learning More About TLS Authentication
    8. Chapter 26 Growing Your Puppet Deployment

      1. Using a Node Terminus
      2. Deploying Puppet Servers at Scale
      3. Best Practices for Puppet Servers
      4. Reviewing Puppet Servers
  4. Integrating Puppet

    1. Chapter 27 Tracking Puppet Status with Dashboards

      1. Using Puppet Dashboard
      2. Evaluating Alternative Dashboards
      3. Upgrading to the Enterprise Console
      4. Finding Plugins and Tools
    2. Chapter 28 Running the Puppet Agent on Windows

      1. Creating a Windows Virtual Machine
      2. Installing Puppet on Windows
      3. Configuring Puppet on Windows
      4. Running Puppet Interactively
      5. Starting the Puppet Service
      6. Debugging Puppet Problems
      7. Writing Manifests for Windows
      8. Finding Windows-Specific Modules
      9. Concluding Thoughts on Puppet Windows
    3. Chapter 29 Customizing Environments

      1. Understanding Environment Isolation
      2. Enabling Directory Environments
      3. Assigning Environments to Nodes
      4. Configuring an Environment
      5. Choosing a Manifest Path
      6. Utilizing Hiera Hierarchies
      7. Binding Data Providers in Environments
      8. Strategizing How to Use Environments
      9. Managing Environments with r10k
      10. Invalidating the Environment Cache
      11. Restarting JRuby When Updating Plugins
      12. Reviewing Environments
    4. Chapter 30 Controlling Puppet with MCollective

      1. Configuring MCollective
      2. Pulling the Puppet Strings
      3. Comparing to Puppet Application Orchestration
      4. Learning More About MCollective
    5. Chapter 31 Managing Network Infrastructure with Puppet

      1. Managing Network Devices with Puppet Device
      2. Using the NetDev Standard Library
      3. Puppetizing Cisco Nexus Switches
      4. Puppetizing Juniper Devices
      5. Best Practices for Network Devices
      6. Reviewing Network Devices
    6. Chapter 32 Assimilating Puppet Best Practices

      1. Managing Change
      2. Choosing Puppet Apply Versus Puppet Server
      3. Creating a Private Puppet Forge
      4. Good Practices
      5. Drinking the Magic Monkey Juice
    7. Chapter 33 Finding Support Resources

      1. Accessing Community Support
      2. Engaging Puppet Labs Support
      3. Contacting the Author
    8. Appendix Installing Puppet on Other Platforms

      1. Debian and Ubuntu
      2. Fedora
      3. Other Platforms
    9. Appendix Configuring Firewalls on Other Platforms

      1. IP Tables
      2. Uncomplicated Firewall
    10. Appendix Installing Ruby

      1. Ruby for Mac
      2. Ruby for Windows
      3. Ruby for Linux