Puppet - From Beginner to Advanced : Day 33 of 50 days DevOps Tools Series

Welcome to Day 33 of our "50 DevOps Tools in 50 Days" series! Today, we’re diving into Puppet, a robust configuration management tool that has been a staple in the DevOps world for many years. Puppet enables system administrators to automate the management and configuration of systems, ensuring consistency and scalability across infrastructures of all sizes.

Whether you’re new to Puppet or looking to expand your knowledge, this guide will take you from the basics to advanced features and use cases.

Introduction to Puppet

Puppet is an open-source automation tool that allows you to define the desired state of your infrastructure as code. With Puppet, you can manage everything from servers to networking devices, ensuring that they are consistently configured and compliant with your policies.

Puppet is particularly known for its declarative language, which allows you to specify what you want the system to look like, without detailing how to achieve it. Puppet takes care of the how, applying the necessary changes to achieve the desired state.

Key Concepts in Puppet

Before getting started with Puppet, it’s important to understand some fundamental concepts:

Puppet Master: The central server that stores all the configurations and policies, known as manifests, and distributes them to Puppet agents.

Puppet Agent: Installed on every node that needs to be managed. The agent periodically checks in with the Puppet Master to retrieve the latest configuration and applies it to the node.

Manifests: Files written in Puppet’s declarative language that define the desired state of the system. These are essentially the scripts or instructions that Puppet uses to manage the infrastructure.

Modules: Collections of manifests and data (such as files, templates, etc.) that are used to manage specific resources, like a web server or a database.

Resources: The basic building blocks of Puppet manifests, representing entities like files, packages, and services.

Classes: Reusable code blocks that can be included in multiple manifests. Classes allow for modular and organized configurations.

Facter: A system inventory tool that gathers information about the system, such as the operating system, IP address, and available memory. Puppet uses this information to make decisions about how to configure the system.

Getting Started with Puppet

Let’s begin with setting up Puppet and writing your first Puppet manifest.

1. Installing Puppet

To get started, you’ll need to install both the Puppet Master and Puppet Agent.

On Puppet Master (Server):

curl -O https://apt.puppet.com/puppet7-release-bullseye.deb
sudo dpkg -i puppet7-release-bullseye.deb
sudo apt-get update
sudo apt-get install puppetserver

Start the Puppet Master service:

sudo systemctl start puppetserver
sudo systemctl enable puppetserver

On Puppet Agent (Node):

sudo apt-get install puppet-agent
sudo systemctl start puppet
sudo systemctl enable puppet

2. Writing Your First Manifest

A manifest is where you define the desired state of your system. Let’s write a simple manifest to install and configure the Apache web server.

Create a manifest file:

sudo nano /etc/puppetlabs/code/environments/production/manifests/site.pp

Add the following code to install Apache and ensure it is running:

node default {
  package { 'apache2':
    ensure => installed,
  }

  service { 'apache2':
    ensure => running,
    enable => true,
  }

  file { '/var/www/html/index.html':
    ensure  => file,
    content => "Welcome to Puppet-managed Apache server!",
  }
}

3. Applying the Manifest

On the Puppet Agent node, run the following command to apply the manifest:

sudo puppet agent --test

This command forces the Puppet Agent to check in with the Puppet Master and apply the latest configuration.

4. Puppet Modules

Modules are reusable collections of manifests and data. They help you organize your configuration and make it easier to manage.

To create a module for managing Apache:

puppet module generate my_apache

This command generates a directory structure for your module. You can then write your manifests inside the module and apply them to your nodes.

Advanced Concepts in Puppet

Now that you’ve got the basics down, let’s explore some advanced Puppet features.

1. Hiera - Data Separation

Hiera is Puppet’s key/value lookup tool, which allows you to separate data from code. This makes your Puppet manifests more reusable and easier to manage.

Setting Up Hiera:

Edit the hiera.yaml configuration file:

---
version: 5
defaults:
  datadir: data
  data_hash: yaml_data

hierarchy:
  - name: "Common data"
    path: "common.yaml"

Using Hiera in Manifests:

In your manifests, you can now use data stored in Hiera:

$my_var = lookup('my_var')
notify { "The value of my_var is ${my_var}": }

2. PuppetDB - Storing and Querying Data

PuppetDB is a tool for storing data generated by Puppet. It allows you to query the state of your infrastructure, which is useful for reporting and auditing.

Setting Up PuppetDB:

Install PuppetDB on your Puppet Master:

sudo apt-get install puppetdb puppetdb-termini
sudo systemctl start puppetdb
sudo systemctl enable puppetdb

Querying Data in PuppetDB:

You can query PuppetDB directly from your manifests or from external tools to get information about the state of your nodes.

3. Custom Facts and Functions

While Facter provides a wide range of built-in facts, you can also create custom facts to gather additional information about your nodes.

Creating a Custom Fact:

Facter.add('my_custom_fact') do
  setcode do
    'custom_value'
  end
end

Save this file in the lib/facter directory of your module.

Custom Functions:

Custom functions in Puppet allow you to create reusable logic that can be used across multiple manifests.

Puppet::Functions.create_function(:my_custom_function) do
  dispatch :my_custom_function_impl do
    param 'String', :input
  end

  def my_custom_function_impl(input)
    "You entered: #{input}"
  end
end

Use this function in your manifest:

notify { my_custom_function('Hello Puppet'): }

Real-Life Use Cases

Infrastructure as Code: Puppet allows you to define your entire infrastructure as code. For example, you can create manifests to deploy a multi-tier application with a database, application server, and web server.

Compliance Enforcement: Use Puppet to enforce security policies and ensure compliance across your infrastructure. Puppet’s declarative language ensures that configurations remain consistent and compliant with policies.

Scaling: Puppet makes it easy to scale your infrastructure by automating the deployment and configuration of new nodes. As your application grows, Puppet can automatically configure new servers to handle the increased load.

Disaster Recovery: Puppet can help automate disaster recovery by ensuring that all nodes are consistently configured. If a node fails, Puppet can automatically bring up a new node with the same configuration.

Application Deployment: Puppet can manage the entire application lifecycle, from deployment to updates and patching. For example, you can write a Puppet manifest to deploy a new version of an application, ensuring that all dependencies are met and configurations are applied.

Conclusion

Puppet is a powerful tool that enables you to automate the management of your infrastructure at scale. From basic setup to advanced features like Hiera, PuppetDB, and custom functions, Puppet provides a comprehensive solution for managing complex environments. Whether you’re just starting out or looking to implement advanced automation strategies, mastering Puppet is a crucial skill for any DevOps engineer.

In tomorrow's post, we will explore A new productive automation tool. Stay tuned!

👉 Make sure to follow me on LinkedIn for the latest updates: Shiivam Agnihotri