DevOps - Puppet

Quiz

Puppet helps us manage our infrastructure as code. This means we can automate things like configuration management and deployment.

In this chapter, we will look at Puppet's architecture. We will go through the steps for installing it. We will also learn how to write good manifests. We will talk about managing modules, classifying nodes, and how to connect Puppet with CI/CD pipelines.

Understanding Puppet Architecture

We can think of Puppet architecture as a way to manage configuration and automate tasks across many systems. It has some key parts −

Puppet Master − This is the main server. It controls the configuration data and sends it to the nodes we manage. It puts together manifests and makes catalogs for each node.
Puppet Agent − We install these agents on the nodes we manage. They ask the Puppet Master for updates, apply the configurations, and then tell back their status.
PuppetDB − This is an optional database. It keeps data that Puppet creates, like facts and reports. It helps us find data faster and improves performance.
Facts − These are pieces of information about the system. Puppet agents collect these from their nodes. Facts include things like the OS version, IP address, and installed packages. We use facts to make decisions about configurations.
Manifests − We write these in Puppet’s special language called DSL. Manifests show how we want the nodes to be set up. We keep them in modules.
Modules − These are groups of manifests, files, and templates. They hold specific configurations or applications.

Puppet Architecture Flow

The Puppet agent talks to the Puppet Master using HTTPS. The Puppet Master makes a catalog from the manifests and facts that the agent gives. The agent uses the catalog to make sure the node’s setup is how we want it.

This architecture helps us manage our infrastructure in a flexible and scalable way. It makes Puppet a strong tool in DevOps practices.

Installing Puppet

To install Puppet, we need to follow the steps for our operating system. Puppet works on many platforms like Linux, macOS, and Windows. Here are the simple steps for installing it on a Linux system −

Prerequisites − We need root or sudo access. Let's update our package manager.

Installation Steps

For Debian/Ubuntu

sudo apt-get update
sudo apt-get install -y puppet

For Red Hat/CentOS

sudo yum install -y epel-release
sudo yum install -y puppet

For Windows

We need to download the Puppet installer from the Puppet downloads page. Then, we run the installer and follow the steps shown.

Verifying the Installation

After we install, we should check if Puppet is installed right. We can do this by checking the version −

puppet --version

Puppet Configuration

Puppet's main configuration file is at /etc/puppet/puppet.conf. We can edit this file to change settings like environment and logging.

By following these steps, we can install Puppet and get it ready for our configuration and management tasks.

Writing Puppet Manifests

We use Puppet manifests as the main part of Puppet configuration management. These manifests are written in Puppet's special language. They show us how we want our infrastructure and resources to be.

Basic Structure of a Manifest

A manifest usually has −

Classes − These hold the configurations.
Resources − These show the state we want for system parts like packages, services, and files.

Example of a Simple Manifest

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

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

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

Defining Resources

Resource Types − Some common types are package, service, file, and user.
Attributes − These tell us about properties like ensure, content, owner, and mode.

Including Classes

To use a class for a node, we can write the include statement −

include apache

Puppet manifests help us make modular and reusable configurations. This makes managing infrastructure easier for us.

Managing Puppet Modules

We can think of Puppet modules as groups of files that help us manage parts of a system. They include manifests, templates, files, and other things. Using Puppet modules helps us reuse our code and keep it organized. Here is how we can manage Puppet modules well −

Module Structure

A Puppet module usually looks like this −

my_module/
 manifests/
    init.pp
 templates/
 files/
 metadata.json

Creating a Module

We can create a new module using the Puppet module tool like this −

puppet module generate my_module

Managing Dependencies

We need to list our dependencies in the metadata.json file. Here is an example −

{
   "name": "my_module",
   "version": "0.1.0",
   "dependencies": [
      {
         "name": "puppetlabs-apt",
         "version_requirement": ">= 7.0.0"
      }
   ]
}

Installing Modules

To get modules from the Puppet Forge, we can use this command −

puppet module install <module_name>

Updating Modules

When we want to update our modules, we just run −

puppet module update <module_name>

Module Versioning

We should always use version control like Git for our modules. This helps us keep track of changes and work together better.

By managing Puppet modules in a good way, we can make sure our infrastructure as code is modular, easy to maintain, and can grow when we need it to.

Puppet Environment and Classifying Nodes

We use Puppet environments to manage different setups for each stage of our deployment pipeline. This includes development, testing, and production. Each environment can have its own manifests and modules. This helps us test and develop in isolation.

Setting up Puppet Environments

Directory Structure:

We need to create separate folders for each environment under −

/etc/puppetlabs/code/environments/:
 	/etc/puppetlabs/code/environments/
   production/
   development/

Puppet Configuration: We should change puppet.conf to specify which environment we are using −

 	[main]
environment = production

Classifying Nodes

Node classification is very important. It helps us apply the right configurations to the right nodes. Puppet Enterprise gives us a GUI for classification. Puppet can also use a node definition in manifests.

Example Node Definition

node 'webserver' {
   include apache
}

node 'dbserver' {
   include mysql
}

Using External Node Classifiers (ENC)

For complex setups, we can use an ENC like Foreman or Hiera. These tools can dynamically assign classes based on node facts or data from outside. This makes our work more flexible and easier to manage.

Integrating Puppet with CI / CD Pipelines

We can make software delivery better by integrating Puppet with CI/CD pipelines. Puppet helps us automate and keep things consistent. We can use Puppet in different stages of the CI/CD process to manage and set up environments easily.

Let's see the key steps for this integration −

Version Control − We should store Puppet manifests and modules in a version control system like Git. This helps us track changes and work together better.
CI/CD Tools − We can use tools like Jenkins, GitLab CI, or CircleCI to start Puppet runs. We need to set up build jobs to apply Puppet manifests when we deploy.
Puppet Agent and Server − The Agent automatically gets configurations from the Puppet Master. The Server: It sends updates when we commit code.
Environment Management − Let's use Puppet environments to keep configurations separate for development, testing, and production.

Example Jenkins Pipeline Snippet

pipeline {
    agent any
    stages {
        stage('Deploy') {
            steps {
                script {
                    sh 'puppet apply /path/to/manifests'
                }
            }
        }
    }
}

Conclusion

In this chapter, we looked at the basics of DevOps. We focused on Puppet. We talked about Puppets architecture and how to install it. We also shared how to create manifests and modules.

We discussed how to manage environments and classify nodes. We looked at how to connect Puppet with CI/CD pipelines.

Print Page