Puppet 5 Essentials - Third Edition电子书

Title Page

Puppet 5 Essentials

Third Edition

Copyright

Puppet 5 Essentials

Third Edition

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Writing Your First Manifests

Getting started

Introducing resources, parameters, and properties

Interpreting output of the puppet apply command

Dry testing your manifest

Using variables

Variable types

Data types

Adding control structures in manifests

Controlling the order of execution

Declaring dependencies

Error propagation

Avoiding circular dependencies

Implementing resource interaction

Examining Puppet core resource types

The user and group types

The exec resource type

The cron resource type

The mount resource type

Summary

Puppet Server and Agents

The Puppet server

Setting up the server machine

Creating the master manifest

Inspecting the configuration settings

Setting up the Puppet agent

The agent's life cycle

Renewing an agent's certificate

Running the agent from cron

Performance optimizations

Tuning puppetserver

Completing the stack with PuppetDB

The Puppet CA

Summary

A Peek into the Ruby Part of Puppet - Facts, Types, and Providers

Putting it all together - collecting system information with Facter

Accessing and using fact values

Extending Facter with custom facts

Simplifying things using external facts

Goals of Facter

Understanding the type system

The resource type's life cycle on the agent side

Command execution control with providers

Resource types with generic providers

Summarizing types and providers

Putting it all together

Summary

Combining Resources in Classes and Defined Types

Introducing classes and defined types

Defining and declaring classes

Creating and using defined types

Understanding and leveraging the differences

Design patterns

Writing comprehensive classes

Writing component classes

Using defined types as resource wrappers

Using defined types as resource multiplexers

Using defined types as macros

Exploiting array values using defined types

Using iterator functions

Including classes from defined types

Ordering and events among classes

Passing events between classes and defined types

Ordering containers

Limitations

The performance implications of container relationships

Mitigating the limitations

The anchor pattern

The contain function

Making classes more flexible through parameters

The caveats of parameterized classes

Preferring the include keyword

Summary

Combining Classes, Configuration Files, and Extensions into Modules

The contents of Puppet's modules

Parts of a module

Module structure

Documentation in modules

Managing environments

Configuring environment locations

Obtaining and installing modules

Module best practices

Putting everything in modules

Avoiding generalization

Testing your modules

Safe testing with environments

Building a component module

Naming your module

Making your module available to Puppet

Implementing basic module functionality

Creating utilities for derived manifests

Adding configuration items

Allowing customization

Removing unwanted configuration items

Dealing with complexity

Enhancing the agent through plugins

Replacing a defined type with a native type

Naming your type

Creating the resource type's interface

Designing sensible parameter hooks

Using resource names

Adding a provider

Declaring management commands

Implementing the basic functionality

Allowing the provider to prefetch existing resources

Making the type robust during provisioning

Enhancing Puppet's system knowledge through facts

Refining the interface of your module through custom functions

Making your module portable across platforms

Finding helpful Forge modules

Identifying module characteristics

Summary

The Puppet Beginners Advanced Parts

Building dynamic configuration files

Learning the template syntax

Using templates in practice

Avoiding performance bottlenecks from templates

Managing file snippets

Single entry in a section

Building from multiple snippets

Using virtual resources

Realizing resources more flexibly using collectors

Cross-node configuration with exported resources

Exporting and collecting resources

Configuring the master to store exported resources

Exporting SSH host keys

Managing hosts files locally

Automating custom configuration items

Simplifying the configuration of Nagios

Maintaining your central firewall

Removing obsolete exports

Setting defaults for resource parameters

Saving redundancy using resource defaults

Avoiding antipatterns

Summary

New Features from Puppet 4 and 5

Upgrading to Puppet 4

Using Puppet 3.8 and environment directories

The Puppet 4 and 5 master

Updating the Puppet agent

Testing Puppet DSL code

Using the type system

Learning lambdas and functions

Creating Puppet 4 functions

Leveraging the new template engine

Handling multiline with HEREDOC

Using Puppet 5 server metrics

Breaking old practices

Converting node inheritance

Dealing with bool algebra on Strings

Using strict variable naming

Learning the new reference syntax

Cleaning hyphens in names

No Ruby DSL anymore

Relative class name resolution

Dealing with different data types

Summary

Separation of Code and Data with Hiera

Understanding the need for separate data storage

Consequences of defining data in the manifest

Building hierarchical data structures

Configuring Hiera

Storing Hiera data

Choosing your backends

Fetching data from classes

Working with simple values

Binding class parameter values automatically

Handling hashes and arrays

Choosing between manifest and Hiera designs

Debugging data lookups

Managing resources from data

Hiera version 5

Summary

Puppet Roles and Profiles

Technical component modules

Implementing components in profiles

The business use case and node classification

Building roles from profiles

Placing code on the Puppet server

The Puppet control repository

Synchronizing upstream modules

R10K code deployment

Summary