Puppet 5 Cookbook - Fourth Edition

Puppet 5 Cookbook - Fourth Edition

By : Thomas Uphill

Buy this Book

Puppet 5 Cookbook - Fourth Edition

By: Thomas Uphill

Buy this Book

Overview of this book

Puppet is a configuration management system that automates all your IT configurations, giving you control of managing each node. Puppet 5 Cookbook will take you through Puppet's latest and most advanced features, including Docker containers, Hiera, and AWS Cloud Orchestration. Updated with the latest advancements and best practices, this book delves into various aspects of writing good Puppet code, which includes using Puppet community style, checking your manifests with puppet-lint, and learning community best practices with an emphasis on real-world implementation. You will learn to set up, install, and create your first manifests with version control, and also learn about various sysadmin tasks, including managing configuration files, using Augeas, and generating files from snippets and templates. As the book progresses, you'll explore virtual resources and use Puppet's resource scheduling and auditing features. In the concluding chapters, you'll walk through managing applications and writing your own resource types, providers, and external node classifiers. By the end of this book, you will have learned to report, log, and debug your system.

Title Page

Packt Upsell

Contributors

Preface

Free Chapter

Puppet Language and Style

Introduction

Adding a resource to a node

Using facter to describe a node

Using puppet facts

Installing a package before starting a service

Installing, configuring, and starting a service

Using community Puppet style

Installing Puppet

Creating a manifest

Checking your manifests with puppet-lint

Making 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

Puppet 5 changes

Puppet 4/5 changes

Puppet Infrastructure

Introduction

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

Setting up the environment

Configuring PuppetDB

Configuring Hiera

Environment-specific Hiera

Setting node-specific data with Hiera

Writing a custom Hiera5 function

Storing secret data with hiera-eyaml

Automatic syntax-checking with Git hooks

Pushing code around with Git

Managing environments with Git

Writing Better Manifests

Introduction

Using arrays of resources

Using resource defaults

Using defined types

Using tags

Using run stages

Using roles and profiles

Using data types in Puppet

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

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 iterations in templates

Using EPP templates

Using GnuPG to encrypt secrets

Comparing package versions

Users and Virtual Resources

Introduction

Using virtual resources

Managing users with virtual resources

Managing users' SSH access

Managing users' customization files

Using exported resources

Managing Resources and Files

Introduction

Distributing cron jobs efficiently

Scheduling when resources are to be 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

Managing Applications

Introduction

Using public modules

Managing Apache servers

Creating Apache virtual hosts

Creating NGINX virtual hosts

Managing MariaDB

Creating databases and users

Servers and Cloud Infrastructure

Introduction

Managing firewalls with iptables

Building high-availability services using Keepalived

Managing NFS servers and file shares

Using HAProxy to load balance multiple web servers

Managing EC2 instances

Managing virtual machines with Vagrant

Managing Docker with Puppet

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 PDK

Using an external node classifier

Creating your own resource types

Creating your own providers

Creating custom functions

Testing your puppet manifests with rspec-puppet

Monitoring, Reporting, and Troubleshooting

Introduction

Noop—the don't-change-anything option

Logging the command output

Logging debug messages

Generating reports

Producing automatic HTML documentation

Drawing dependency graphs

Understanding Puppet errors

Inspecting configuration settings

Other Books You May Enjoy

Leave a review - let other readers know what you think

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Installing, configuring, and starting a service

There are many examples of this pattern online. In our simple example, we will create an Apache configuration file under /etc/httpd/conf.d/cookbook.conf. The /etc/httpd/conf.d directory will not exist until the httpd package is installed. After this file is created, we would want httpd to restart to notice the change; we can achieve this with a notify parameter.

How to do it...

We will need the same definitions as our last example; we need the package and service installed. We now need two more things. We need the configuration file and index page (index.html) created. For this, we follow these steps:

As in the previous example, we ensure the service is running and specify that the service requires the httpd package:

service {'httpd':
  ensure  => running,
  require => Package['httpd'],
}

We then define package as follows:

package {'httpd':
  ensure => installed,
}

Now, we create the /etc/httpd/conf.d/cookbook.conf configuration file; the /etc/httpd/conf.d directory will not exist until the httpd package is installed. We'll use @heredoc syntax here to make the code a little more readable, assigning the cookbook.conf contents to the $cookbook variable. The require metaparameter tells Puppet that this file requires the httpd package to be installed before it is created:

$cookbook = @(COOKBOOK)
  <VirtualHost *:80>
    Servername cookbook
    DocumentRoot /var/www/cookbook
  </VirtualHost>
  | COOKBOOK
file {'/etc/httpd/conf.d/cookbook.conf':
  content => $cookbook,
  require => Package['httpd'],
  notify => Service['httpd'],
}

We then go on to create an index.html file for our virtual host in /var/www/cookbook. Again, we'll use @heredoc syntax to make this more readable. This directory won't exist yet, so we need to create this as well, using the following code:

$index = @(INDEX)
  <html>
    <body>
      <h1>Hello World!</h1>
    </body>
  </html>
  | INDEX
file {'/var/www/cookbook':
  ensure  => directory,
  require => Package['httpd'],
}
file {'/var/www/cookbook/index.html':
  content => $index,
  require => File['/var/www/cookbook'],
}

How it works...

The require attribute to the file resources tells Puppet that we need the /var/www/cookbook directory created before we can create the index.html file. The important concept to remember is that we cannot assume anything about the target system (node). We need to define everything on which the target depends. Anytime you create a file in a manifest, you have to ensure that the directory containing that file exists. Anytime you specify that a service should be running, you have to ensure that the package providing that service is installed.

In this example, using metaparameters, we can be confident that no matter what state the node is in before running Puppet, after Puppet runs, the following will be true:

httpd will be running
The VirtualHost configuration file will exist
httpd will restart and be aware of the VirtualHost file
The DocumentRoot directory will exist
An index.html file will exist in the DocumentRoot directory

Puppet 5 Cookbook - Fourth Edition

By : Thomas Uphill

Puppet 5 Cookbook - Fourth Edition

By: Thomas Uphill

Overview of this book

Related Content you might be interested in

Current Title:

Puppet 5 Cookbook - Fourth Edition

Mastering Puppet 5

Puppet 5 Essentials

Puppet 4.10 Beginner's Guide

Installing, configuring, and starting a service

How to do it...

How it works...