Puppet 4 Essentials · 2nd Edition by Frank, Felix -- Read -- Imperial Library of Trantor

Index

Puppet 4 Essentials Second Edition

Table of Contents Puppet 4 Essentials Second Edition Credits About the Authors About the Reviewer www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe? Free access for Packt account holders

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 Errata Piracy Questions

1. Writing Your First Manifests

Getting started Introducing resources and properties Interpreting the output of the puppet apply command

Dry-testing your manifest

Adding control structures in manifests Using variables

Variable types

Controlling the order of evaluation

Declaring dependencies Error propagation Avoiding circular dependencies

Implementing resource interaction Examining the most notable resource types

The user and group types The exec resource type The cron resource type The mount resource type

Summary

2. The Master and Its Agents

The Puppet Master

Puppet Master and Puppet Server Setting up the master 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 considerations

Tuning puppetserver

Using Phusion Passenger with Nginx

Comparing Passenger with puppetserver

Completing the stack with PuppetDB Troubleshooting SSL issues Summary

3. A Peek under the Hood – Facts, Types, and Providers

Summarizing systems 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

Substantiating the model with providers

Resource types with generic providers Summarizing types and providers

Putting it all together Summary

4. Modularizing Manifests with Classes and Defined Types

Introducing classes and defined types

Defining and declaring classes Creating and using defined types Understanding and leveraging the differences

Structured 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 Establishing relationships among containers

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

5. Extending Your Puppet Infrastructure with Modules

An overview of Puppet's modules

Parts of a module Module structure Documentation in modules

Maintaining environments

Configuring environment locations Obtaining and installing modules Modules' best practices Putting everything in modules Avoiding generalization Testing your modules

Safe testing with environments

Building a specific 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 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 modules' characteristics

Summary

6. Leveraging the Full Toolset of the Language

Templating dynamic configuration files

Learning the template syntax Using templates in practice Avoiding performance bottlenecks from templates

Creating virtual resources

Realizing resources more flexibly using collectors

Exporting resources to other agents

Exporting and importing 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

Overriding resource parameters

Saving redundancy using resource defaults

Avoiding antipatterns Summary

7. New Features from Puppet 4

Upgrading to Puppet 4

Using Puppet 3.8 and environment directories The new Puppet 4 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 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

8. Separating Data from Code Using Hiera

Understanding the need for separate data storage

Consequences of defining data in the manifest

Structuring configuration data in a hierarchy

Configuring Hiera Storing Hiera data Choosing your backends

Retrieving and using Hiera values in manifests

Working with simple values Binding class parameter values automatically Handling hashes and arrays

Converting resources to data

Choosing between manifest and Hiera designs A practical example

Debugging Hiera lookups Implementing the Roles and Profiles pattern Summary

Index

← Prev
Back
Next →

← Prev
Back
Next →