Learn Puppet - Prerequisite Skills & Environment Setup

#Introduction

Welcome to the Learn Puppet series! This series will take you from zero to mastery of Puppet — the infrastructure-as-code platform that pioneered configuration management — starting with core concepts and architecture, manifests and resource types, all the way to modules, Hiera, PuppetDB, Bolt, and Puppet Enterprise. Dozens of episodes will build your understanding layer by layer until you're ready to apply it in production.

But before writing your first manifest, there are a few basic skills and tools you need to prepare first. Why do these prerequisites matter? Because Puppet isn't just a language for writing configuration — it's a system that lives on the network, relying on SSL for agent authentication, DNS so agents can find the server, and a solid understanding of Linux so you can read the state of the servers you manage. If the foundation isn't ready, certificate and DNS errors will feel like a puzzle with no end.

Episode 0 is your roadmap: we'll prepare the basic skills, install the tools, and then make sure your first Puppet environment is up and running.

#Required Basic Skills

#Linux/Unix: Package Manager, Services, and Permissions

Puppet manages Linux servers, so you should master these three areas:

Why does this matter? Because most of the resources you'll write in Puppet — package, service, file, user — essentially automate what you currently do manually with the commands above.

#IaC & Configuration Management Concepts

Puppet follows the declarative model: you declare the desired state rather than writing a sequence of steps to reach that state. Two key concepts:

• Declarative — you say "nginx must be installed and running," and Puppet decides how to make it happen.
• Idempotent — running the same configuration repeatedly always produces the same result; repetition has no side effects.

Compare this with imperative scripting: you write step by step, and if the first step has already run, the script can break the state. This declarative paradigm is what makes Puppet a great fit for thousands of nodes.

#Ruby Basics

Puppet's manifest language uses syntax that resembles Ruby. You don't need to be a Ruby programmer, but understanding the basic syntax will help a lot:

• Variables prefixed with $ like $domain.
• Function calls like include profile::web.
• Block structures similar to Ruby — the package resource type is written as package { 'nginx':{:puppet} } with parameters inside the block.

We'll write complete manifests in episodes 4 and 5, so no need to go deeper right now.

#Networking: SSL & DNS

Puppet agents communicate with the Puppet server over the network, and trust is built on SSL certificates. Every agent generates a certificate signing request that the server must approve. You also need to understand DNS, because agents find the server through a FQDN like puppet.example.com — not a raw IP.

#Software & Tools to Prepare

#Installing Puppet OSS 8.x or Puppet Enterprise

Puppet can be installed from the official repos apt.puppetlabs.com (Debian/Ubuntu) or yum.puppetlabs.com (RHEL family). For a lab, Puppet OSS 8.x is more than enough. Puppet Enterprise (PE) 2025.1.x is also available with a free license for up to 10 nodes — you can try it later in episode 3.

wget https://apt.puppetlabs.com/puppet8-release-focal.deb
sudo dpkg -i puppet8-release-focal.deb
sudo apt update

sudo rpm -Uvh https://yum.puppetlabs.com/puppet8-release-el-9.noarch.rpm
sudo dnf update

#Container Option

Don't want to clutter your main system? Puppet provides official images on Docker Hub: puppet/puppetserver for the server and puppet/puppet-agent for agents. This is the fastest way to get a lab started.

docker run --name puppetserver --hostname puppetserver.example.com -d puppet/puppetserver
docker run --name agent --hostname agent.example.com -d puppet/puppet-agent

#Puppet Development Kit (PDK)

PDK is the tool for scaffolding Puppet modules, writing unit tests, and validating syntax. We'll use it intensively starting in episode 5, so install it now.

sudo apt install pdk -y

#Test Node

Prepare at least one test node — a VM or container — that will be the first target you manage. This node must be able to reach the server and have correct name resolution.

#Forge Account (Optional)

Puppet Forge is the community module registry at forge.puppet.com. Creating an account isn't required to read and use modules, but it will be useful if you later want to publish your own modules.

#Environment Verification

Once all tools are installed, make sure everything works:

puppet --version
pdk --version
which facter

You can also check basic facts about the test node with facter to make sure the node is recognized:

facter os.name
facter networking.ip

#Episode 0 Checklist

• Understand the difference between declarative and imperative paradigms.
• Comfortable with package managers, systemd services, and Linux permissions.
• Know the basic Ruby syntax used by Puppet manifests.
• The official Puppet repo has been added on the server and test node.
• PDK is installed and puppet --version runs normally.
• One test node is ready to manage with correct name resolution.

#Conclusion

In this episode 0 you've laid the groundwork for the entire series: understanding the basic Linux skills, IaC concepts, Ruby syntax, and networking that form Puppet's foundation, installing the tools you need (Puppet Server, Puppet Agent, PDK, test node), and verifying that your environment is ready to use.

Key takeaways:

• Puppet follows the declarative and idempotent paradigm — you declare the desired state, not the steps.
• Master Linux, basic Ruby, SSL, and DNS because the entire series is built on these four foundations.
• Set up Puppet Server + Agent + PDK + test node as your standard lab tooling.
• Choose the repo that matches your OS version — a small mistake here will haunt you through the installation episodes.

In the next episode, episode 1, we'll cover history, background, and why the world needed Puppet — from the era of manual scripting, the birth of CFEngine in 1993, the arrival of Puppet by Luke Kanies in 2005, to how Puppet compares with Chef, Ansible, and SaltStack. Make sure your lab is standing, because the Learn Puppet journey is just getting started!