About the course
Managing complex server infrastructure efficiently and consistently requires robust automation tools. Puppet is a leading platform for Desired State Configuration, allowing system administrators to define exactly how systems should be configured and maintained over time, ensuring reliability and consistency across your environment. This [Insert Duration, e.g., 3 or 4]-day course provides system administrators and operations professionals with the essential knowledge and practical skills to leverage the power of modern Puppet, incorporating both its core configuration management capabilities and complementary automation tools.
The course begins with the fundamental concepts of Puppet's architecture and language, enabling participants to write effective code using resources to manage packages, files, services, and more. A strong emphasis is placed on current best practices for organising Puppet code using modules and the industry-standard Roles and Profiles pattern for building scalable and maintainable configurations. Participants will gain hands-on experience using the Puppet Development Kit (PDK), the essential tool for developing, validating, and testing Puppet modules, and learn how to manage variable configuration data externally using Hiera for flexibility and reusability.
Beyond just configuration management, the workshop introduces Puppet Bolt for performing ad-hoc tasks, running scripts, and orchestrating actions across your nodes without relying on the Puppet agent, covering essential automation use cases for system administrators. The course also addresses managing code across different environments, basic code deployment workflows, an introduction to testing Puppet code, and vital operational considerations like troubleshooting, security basics, and understanding Puppet's place within the modern infrastructure ecosystem. Through extensive practical labs, attendees will apply these modern skills to configure common services, preparing them to implement, update, and manage Puppet automation effectively in their own environments.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain the principles of Desired State Configuration and Puppet's architecture.
- Install and perform basic configuration of Puppet Agent and Puppet Server.
- Write and apply Puppet code using resources and language constructs to manage system components.
- Use the Puppet Development Kit (PDK) to create and manage Puppet modules following standard structure.
- Implement the Roles and Profiles pattern to structure Puppet code for scalability and maintainability.
- Manage configuration data using Hiera and integrate it with Puppet code.
- Utilise Puppet Bolt to perform ad-hoc tasks and basic orchestration on nodes.
- Manage Puppet code across different environments and understand code deployment concepts.
- Perform basic troubleshooting of Puppet agent and server issues using logs and commands.
- Understand basic security and operational considerations for a Puppet environment and its place in the ecosystem.
-
This course is designed for System Administrators, Infrastructure Engineers, Operations professionals, and anyone responsible for managing and automating server infrastructure who wants to learn or update their skills using modern Puppet. It is ideal for:
Individuals new to Puppet or configuration management seeking a comprehensive introduction to current practices.
Existing Puppet users looking to modernise their skills with essential tools like PDK, Bolt, Hiera 5, and the Roles and Profiles pattern.
Teams planning to implement or improve their use of Puppet for managing servers at scale in dynamic environments.
Professionals who need practical experience automating system configuration, ad-hoc tasks, and code management workflows in a Puppet environment.
-
Participants should have:
Basic familiarity with Linux command-line environments.
A foundational understanding of core system administration concepts (e.g., package management, services, file systems, networking basics) on a Linux-based operating system.
No prior experience with Puppet, Puppet Enterprise, or other configuration management tools is required.
-
This Puppet course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction to Configuration Management & Puppet Fundamentals
Why Configuration Management? The problem Puppet solves.
Introduction to Desired State Configuration principles.
What is Puppet? Its purpose and place in the automation landscape.
Puppet Architecture: Understanding the Master/Agent model and its workflow.
Overview of the Puppet Ecosystem: Puppet Agent, Puppet Server, PuppetDB (overview), Forge, Bolt, PDK.
The Puppet Language (DSL) Basics: Resources, Resource Abstraction Layer (RAL).
Hands-On Lab: Discussing CM challenges, exploring the Puppet ecosystem landscape, introduction to the lab environment.
Installing & Getting Started with Puppet
System Prerequisites for Puppet Agent and Server.
Installing Puppet Agent and Puppet Server using official packages/repositories.
Initial Configuration of Puppet Agent and Server (puppet.conf).
Establishing Trust: Working with SSL certificates (certificate signing/accepting).
Starting and verifying Puppet services.
Performing a first Puppet run (puppet agent -t).
Hands-On Lab: Installing Puppet Agent and Server, configuring basic communication, signing certificates, running the first Puppet agent run.
Writing Puppet Code - Resources & Language Constructs
Defining Resources in detail: Titles, attributes, parameters.
Essential Resource Types: package, file, service, exec, user, group, cron, mount.
Understanding Resource Relationships: require, before, ~>, notify, subscribe.
Using Variables and Facts: Accessing node-specific data via Facter in manifests.
Conditional Logic: if, unless, case statements for decision making.
Loops and Iteration: Using iteration functions like each.
Using Built-in Functions.
Virtual Resources.
Hands-On Lab: Writing Puppet manifests to configure various system components (packages, files, services), using facts, conditionals, and relationships.
Organising Puppet Code - Modules & The Puppet Development Kit (PDK)
What are Modules? Encapsulating reusable Puppet code and data.
The Standard Module Structure: Understanding directories and their purpose (manifests, files, templates, data, tasks, plans).
The Puppet Forge: Discovering, evaluating, and installing community modules (puppet module install).
Introduction to the Puppet Development Kit (PDK): Why use PDK? Key features (validation, testing, templates, packaging).
Installing and configuring PDK.
Creating a New Module using pdk new module.
Adding Classes and Defined Types to a Module using PDK templates.
Understanding and editing metadata.json.
Hands-On Lab: Installing modules from the Forge, creating a new module using PDK, adding a class and a defined type using PDK templates, exploring module structure.
Structuring for Scale & Maintainability - Roles and Profiles
Challenges of unstructured Puppet code and deeply nested inheritance.
Introduction to the Roles and Profiles Pattern: A best practice for clear, modular design using composition.
Profiles: Creating modules that configure a single application or service, or a layer of technology (e.g., profile::webserver, profile::database).
Roles: Creating modules that define the configuration for an entire node by including Profiles (e.g., role::webserver, role::database_server).
Implementing Roles and Profiles in your control repository structure.
Assigning Roles to Nodes (via Hiera or Node Classifier).
Benefits of using the Roles and Profiles pattern (Readability, Testability, Reusability, Maintainability, Reduced Conflicts).
Hands-On Lab: Refactoring previous lab code (or new exercises) into a simple Roles and Profiles structure, implementing a basic role and profile, demonstrating how to assign roles to nodes.
Managing Configuration Data with Hiera
The Need for Data Separation: Why configuration data should be separate from code.
Introduction to Hiera: Puppet's data lookup system for providing node-specific data.
Hiera 5 Configuration (hiera.yaml): Defining data hierarchies based on node attributes (e.g., hostname, operating system, environment).
Data Backends: Using YAML and other common backends (overview).
Defining Data in Hiera: Creating data files (common.yaml, node-specific files, etc.).
Lookup Functions: Using lookup(), hiera(), hiera_array(), hiera_hash() in manifests and modules.
Integrating Hiera with the Roles and Profiles pattern: Making your code data-driven and reusable across different nodes and environments.
Hands-On Lab: Setting up Hiera, defining a hierarchy and data, using lookup functions within modules and roles/profiles to configure resources based on data retrieved from Hiera.
Ad-hoc Task Execution & Orchestration with Puppet Bolt
Introduction to Puppet Bolt: Agentless automation tool for executing commands, scripts, and tasks remotely.
Agent-based Configuration Management vs. Agentless Task Execution: Understanding the distinct use cases.
Installing and configuring Bolt.
Running Commands and Scripts with Bolt targets.
Using Bolt Tasks: Running pre-built tasks from the Forge.
Writing Simple Bolt Tasks (overview).
Introduction to Bolt Plans: Orchestrating sequences of tasks (basic concepts).
Common System Administration Use Cases for Bolt (e.g., restarting services, collecting information, running checks).
Hands-On Lab: Installing Bolt, defining targets, running ad-hoc commands/scripts, executing a pre-built Bolt task across multiple nodes.
Environments, Code Management, Testing Basics & Operations
Puppet Environments: Managing different versions of your Puppet code (e.g., development, testing, production).
Code Management Overview: Introduction to tools like r10k and Code Manager (Puppet Enterprise) for deploying environments from version control (e.g., Git).
Basic Code Deployment Workflow.
Introduction to Puppet Code Testing:
Why testing CM code is crucial.
Code Validation and Linting with PDK (pdk validate).
Introduction to Unit Testing concepts with PDK (testing code logic in isolation).
Introduction to Acceptance Testing concepts (testing the final state on a system - overview).
Operational Aspects: Basic performance considerations, scaling overview, backups.
Troubleshooting Puppet: Using logs, debug flags, resource inspection (puppet resource), common issues.
Security Basics: Certificate management, access control (auth.conf overview), managing sensitive data (e.g., using puppet-lookup with Hiera backends like eyaml).
Puppet in the Ecosystem: How Puppet fits with IaC tools (Terraform), CI/CD pipelines, and monitoring.
Hands-On Lab: Setting up a basic environment workflow (e.g., using r10k), running PDK validation, practicing troubleshooting scenarios.
Module 9: Practical Application Workshop
Applying the concepts and tools learned throughout the course to configure common services from a SysAdmin perspective.
Workshops will focus on using modules, Hiera, and the Roles/Profiles pattern to configure:
A DNS server (e.g., BIND or dnsmasq).
A DHCP server.
An NFS server and client setup.
Integrating the use of Puppet Bolt for a related task within a workshop scenario (e.g., verifying service status, restarting a service after configuration changes).
Hands-On Lab: Extended practical exercises to configure the specified services, applying modern Puppet practices, including the use of Hiera and the Roles/Profiles pattern, and incorporating a Bolt task.
-
Puppet Documentation: The official and comprehensive source for Puppet concepts, language reference, and core components (Agent, Server). https://puppet.com/docs/puppet/latest/
Puppet Bolt Documentation: Official documentation for installing, configuring, and using Puppet Bolt for ad-hoc task execution and orchestration. https://puppet.com/docs/bolt/latest/
Puppet Development Kit (PDK) Documentation: Official guide for installing and using the PDK for Puppet module development, validation, and testing. https://puppet.com/docs/pdk/latest/
Hiera Documentation: Detailed documentation on configuring and using Hiera for data separation in Puppet. https://puppet.com/docs/puppet/latest/hiera.html
Puppet Forge: The primary repository for finding, using, and sharing Puppet modules. https://forge.puppet.com/
Puppet Community Forum: Connect with other Puppet users, ask questions, and share knowledge. https://community.puppet.com/
Trusted by
