Puppet 5 Essentials · 3rd Edition by Alfke, Martin -- Read -- Imperial Library of Trantor

Index

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

← Prev
Back
Next →

← Prev
Back
Next →