Librería Portfolio

If you're a system administrator, developer, or site reliability engineer responsible for handling hundreds or even thousands of nodes in your network, the Puppet configuration management tool will make your job a whole lot easier. This practical guide shows you what Puppet does, how it works, and how it can provide significant value to your organization.

Through hands-on tutorials, DevOps engineer Jo Rhett demonstrates how Puppet manages complex and distributed components to ensure service availability. You'll learn how to secure configuration consistency across servers, clients, your router, and even that computer in your pocket by setting up your own testing environment.

Learn exactly what Puppet is, why it was created, and what problems it solves
Tailor Puppet to your infrastructure with a design that meets your specific needs
Write declarative Puppet policies to produce consistency in your systems
Build, test, and publish your own Puppet modules
Manage network devices such as routers and switches with puppet device and integrated Puppet agents
Scale Puppet servers for high availability and performance
Explore web dashboards and orchestration tools that supplement and complement Puppet



Controlling with Puppet Apply
Chapter 1Thinking Declarative
Handling Change
Using Idempotence
Declaring Final State
Reviewing Declarative Programming
Chapter 2Creating a Learning Environment
Installing Vagrant
Starting a Bash Shell
Downloading a Box
Cloning the Learning Repository
Install the Vagrant vbguest Plugin
Initializing the Vagrant Setup
Verifying the /vagrant Filesystem
Initializing Non-Vagrant Systems
Installing Some Helpful Utilities
Choosing a Text Editor
Reviewing the Learning Environment
Chapter 3Installing Puppet
Adding the Package Repository
Installing the Puppet Agent
Reviewing Dependencies
Reviewing Puppet 4 Changes
Making Tests Convenient
Running Puppet Without sudo
Running Puppet with sudo
Reviewing Puppet Installation
Chapter 4Writing Manifests
Implementing Resources
Applying a Manifest
Declaring Resources
Viewing Resources
Executing Programs
Managing Files
Avoiding Imperative Manifests
Testing Yourself
Reviewing Writing Manifests
Chapter 5Using the Puppet Configuration Language
Defining Variables
Finding Facts
Calling Functions in Manifests
Using Variables in Resources
Defining Attributes with a Hash
Declaring Multiple Resource Titles
Declaring Multiple Resource Bodies
Modifying with Operators
Using Comparison Operators
Evaluating Conditional Expressions
Matching Regular Expressions
Building Lambda Blocks
Looping Through Iterations
Reviewing Puppet Configuration Language
Chapter 6Controlling Resource Processing
Adding Aliases
Preventing Action
Auditing Changes
Defining Log Level
Filtering with Tags
Limiting to a Schedule
Declaring Resource Defaults
Reviewing Resource Processing
Chapter 7Expressing Relationships
Managing Dependencies
Referring to Resources
Ordering Resources
Assuming Implicit Dependencies
Triggering Refresh Events
Chaining Resources with Arrows
Processing with Collectors
Understanding Puppet Ordering
Debugging Dependency Cycles
Reviewing Resource Relationships
Chapter 8Upgrading Puppet 3 Manifests
Replacing Deprecated Features
Preparing for the Upgrade
Testing with the Future Parser
Enhancing Older Manifests
Chapter 9Wrap-Up of Puppet Basics
Best Practices for Writing Manifests
Learning More About Puppet Manifests
Creating Puppet Modules
Chapter 10Creating a Test Environment
Verifying the Production Environment
Creating the Test Environment
Changing the Base Module Path
Skipping Ahead
Chapter 11Separating Data from Code
Introducing Hiera
Creating Hiera Backends
Configuring Hiera
Looking Up Hiera Data
Providing Global Data
Chapter 12Using Modules
Finding Modules
Evaluating Module Quality
Installing Modules
Testing a Single Module
Defining Config with Hiera
Assigning Modules to Nodes
Examining a Module
Reviewing Modules
Chapter 13Designing a Custom Module
Choosing a Module Name
Generating a Module Skeleton
Understanding Module Structure
Installing the Module
Creating a Class Manifest
Declaring Class Resources
Accepting Input
Sharing Files
Testing File Synchronization
Synchronizing Directories
Parsing Templates
Testing the Module
Peeking Beneath the Hood
Best Practices for Module Design
Reviewing Custom Modules
Chapter 14Improving the Module
Validating Input with Data Types
Looking Up Input from Hiera
Building Subclasses
Creating New Resource Types
Understanding Variable Scope
Calling Other Modules
Ordering Dependencies
Containing Classes
Creating Reusable Modules
Best Practices for Module Improvements
Reviewing Module Improvements
Chapter 15Extending Modules with Plugins
Adding Custom Facts
Defining Functions
Creating Puppet Types
Adding New Providers
Identifying New Features
Binding Data Providers in Modules
Requirements for Module Plugins
Reviewing Module Plugins
Chapter 16Documenting Modules
Learning Markdown
Writing a Good README
Documenting the Classes and Types
Documenting Functions
Generating Documentation
Updating Module Metadata
Maintaining the Change Log
Evolving and Improving
Best Practices for Documenting Modules
Chapter 17Testing Modules
Installing Dependencies
Preparing Your Module
Defining RSpec Unit Tests
Creating Acceptance Tests
Using Skeletons with Testing Features
Finding Documentation
Reviewing Testing Modules
Chapter 18Publishing Modules
Updating the Module Metadata
Packaging a Module
Uploading a Module to the Puppet Forge
Publishing a Module on GitHub
Automating Module Publishing
Getting Approved Status from Puppet Labs
Using a Puppet Server
Chapter 19Preparing for a Puppet Server
Understanding the Catalog Builder
Planning for Puppet Server
Choosing Puppet Master Versus Puppet Server
Ensuring a High-Performance Server
Chapter 20Creating a Puppet Master
Starting the puppetmaster VM
Installing the Puppet Master
Configuring a Firewall for the Puppet Master
Running the WEBrick Server
Testing with the Puppet Master Service
Scaling the Puppet Master with Passenger
IPv6 Dual-Stack Puppet Master
Debugging Puppet Master
Chapter 21Creating a Puppet Server
Starting the puppetserver VM
Installing Puppet Server
Configuring a Firewall for Puppet Server
Configuring Puppet Server
Running Puppet Server
IPv6 Dual-Stack Puppet Server
Chapter 22Connecting a Node
Creating a Key Pair
Authorizing the Node
Downloading the First Catalog
Installing Hiera Data and Modules
Testing with a Client Node
Learning More About Puppet Server
Chapter 23Migrating an Existing Puppet Master
Migrating the Puppet Master Config
Synchronizing All Environments
Copying Hiera Data
Moving the MCollective Config Directory
Removing Node Inheritance
Testing a Client Node
Upgrading Clients
Chapter 24Utilizing Advantages of a Puppet Server
Using Server Data in Y