Sign In Start Free Trial

Puppet Cookbook - Third Edition

By : Thomas Uphill, John Arundel

5 (2)

Puppet Cookbook - Third Edition

5 (2)

By: Thomas Uphill, John Arundel

Overview of this book

This book is for anyone who builds and administers servers, especially in a web operations context. It requires some experience of Linux systems administration, including familiarity with the command line, file system, and text editing. No programming experience is required.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Puppet Language and Style

1. Puppet Language and Style

Introduction

Adding a resource to a node

Using Facter to describe a node

Installing a package before starting a service

Installing, configuring, and starting a service

Using community Puppet style

Creating a manifest

Checking your manifests with Puppet-lint

Using modules

Using standard naming conventions

Using inline templates

Iterating over multiple items

Writing powerful conditional statements

Using regular expressions in if statements

Using selectors and case statements

Using the in operator

Using regular expression substitutions

Using the future parser

2. Puppet Infrastructure

2. Puppet Infrastructure

Introduction

Installing Puppet

Managing your manifests with Git

Creating a decentralized Puppet architecture

Writing a papply script

Running Puppet from cron

Bootstrapping Puppet with bash

Creating a centralized Puppet infrastructure

Creating certificates with multiple DNS names

Running Puppet from passenger

Setting up the environment

Configuring PuppetDB

Configuring Hiera

Setting node-specific data with Hiera

Storing secret data with hiera-gpg

Using MessagePack serialization

Automatic syntax checking with Git hooks

Pushing code around with Git

Managing Environments with Git

3. Writing Better Manifests

3. Writing Better Manifests

Introduction

Using arrays of resources

Using resource defaults

Using defined types

Using tags

Using run stages

Using roles and profiles

Passing parameters to classes

Passing parameters from Hiera

Writing reusable, cross-platform manifests

Getting information about the environment

Importing dynamic information

Passing arguments to shell commands

4. Working with Files and Packages

4. Working with Files and Packages

Introduction

Making quick edits to config files

Editing INI style files with puppetlabs-inifile

Using Augeas to reliably edit config files

Building config files using snippets

Using ERB templates

Using array iteration in templates

Using EPP templates

Using GnuPG to encrypt secrets

Installing packages from a third-party repository

Comparing package versions

5. Users and Virtual Resources

5. Users and Virtual Resources

Introduction

Using virtual resources

Managing users with virtual resources

Managing users' SSH access

Managing users' customization files

Using exported resources

6. Managing Resources and Files

6. Managing Resources and Files

Introduction

Distributing cron jobs efficiently

Scheduling when resources are applied

Using host resources

Using exported host resources

Using multiple file sources

Distributing and merging directory trees

Cleaning up old files

Auditing resources

Temporarily disabling resources

7. Managing Applications

7. Managing Applications

Introduction

Using public modules

Managing Apache servers

Creating Apache virtual hosts

Creating nginx virtual hosts

Managing MySQL

Creating databases and users

8. Internode Coordination

8. Internode Coordination

Introduction

Managing firewalls with iptables

Building high-availability services using Heartbeat

Managing NFS servers and file shares

Using HAProxy to load-balance multiple web servers

Managing Docker with Puppet

9. External Tools and the Puppet Ecosystem

9. External Tools and the Puppet Ecosystem

Introduction

Creating custom facts

Adding external facts

Setting facts as environment variables

Generating manifests with the Puppet resource command

Generating manifests with other tools

Using an external node classifier

Creating your own resource types

Creating your own providers

Creating custom functions

Testing your puppet manifests with rspec-puppet

Using librarian-puppet

Using r10k

10. Monitoring, Reporting, and Troubleshooting

10. Monitoring, Reporting, and Troubleshooting

Introduction

Noop – the don't change anything option

Logging command output

Logging debug messages

Generating reports

Producing automatic HTML documentation

Drawing dependency graphs

Understanding Puppet errors

Inspecting configuration settings

Index

Index

Customer Reviews

5 (2)

5 star

100%

4 star

0

3 star

0

2 star

0

1 star

0

Using inline templates

Templates are a powerful way of using Embedded Ruby (ERB) to help build config files dynamically. You can also use ERB syntax directly without having to use a separate file by calling the inline_template function. ERB allows you to use conditional logic, iterate over arrays, and include variables.

How to do it…

Here's an example of how to use inline_template:

Pass your Ruby code to inline_template within Puppet manifest, as follows:

cron { 'chkrootkit':
  command => '/usr/sbin/chkrootkit >
    /var/log/chkrootkit.log 2>&1',
  hour    => inline_template('<%= @hostname.sum % 24 %>'),
  minute  => '00',
}

How it works…

Anything inside the string passed to inline_template is executed as if it were an ERB template. That is, anything inside the <%= and %> delimiters will be executed as Ruby code, and the rest will be treated as a string.

In this example, we use inline_template to compute a different hour for this cron resource (a scheduled job) for each machine, so that the same job does not run at the same time on all machines. For more on this technique, see the Distributing cron jobs efficiently recipe in Chapter 6, Managing Resources and Files.

There's more...

In ERB code, whether inside a template file or an inline_template string, you can access your Puppet variables directly by name using an @ prefix, if they are in the current scope or the top scope (facts):

<%= @fqdn %>

To reference variables in another scope, use scope.lookupvar, as follows:

<%= "The value of something from otherclass is " + scope.lookupvar('otherclass::something') %>

You should use inline templates sparingly. If you really need to use some complicated logic in your manifest, consider using a custom function instead (see the Creating custom functions recipe in Chapter 9, External Tools and the Puppet Ecosystem).

See also

The Using ERB templates recipe in Chapter 4, Working with Files and Packages
The Using array iteration in templates recipe in Chapter 4, Working with Files and Packages

Search

Your notes and bookmarks