100+ Free Puppet 206 Practice Questions

Pass your Puppet Professional 206 (Puppet Certified Professional) exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately

Not publicly disclosed Pass Rate

100+ Questions

100% Free

1 / 10

Question 1

Score: 0/0

Which Puppet resource type would you use to ensure the package `nginx` is installed on a node?

service

package

exec

file

to track

2026 Statistics

Key Facts: Puppet 206 Exam

Exam Questions

Puppet

60%

Passing Score

Approximate; Puppet does not publish exact cut score

90 min

Exam Duration

Puppet

$200

Exam Fee

Puppet (varies by region)

Questionmark

Delivery

Online proctored

2 years

Validity

Recertification required

The Puppet 206 exam has 60 multiple-choice scenario questions in 90 minutes, delivered online via Questionmark. Topic areas: Puppet language (resources, classes, defined types, conditionals, iteration, data types), modules and Roles/Profiles, Hiera 5 hierarchies and lookups including eyaml, Puppet agent run cycle and certificate signing, environments and code deployment with r10k/Code Manager, PuppetDB and exported resources, and Bolt tasks/plans. Exam fee is $200 USD. The certification is valid for two years.

Sample Puppet 206 Practice Questions

Try these sample questions to test your Puppet 206 exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1Which Puppet resource type would you use to ensure the package `nginx` is installed on a node?

A.service

B.package

C.exec

D.file

Explanation: The `package` resource manages software packages via the node's package manager (apt, yum, dnf, etc.). The canonical declaration is `package { 'nginx': ensure => installed }`. `service` manages running services, `exec` runs arbitrary commands (use as a last resort), and `file` manages files. Exam tip: always use a typed resource (`package`/`service`/`file`) instead of `exec` when one exists.

2In Puppet DSL, what is the correct syntax to declare a `file` resource that ensures `/etc/motd` exists with specific content?

A.file { '/etc/motd': ensure => file, content => 'Welcome' }

B.file '/etc/motd' { ensure: file, content: 'Welcome' }

C.file('/etc/motd', { ensure => file, content => 'Welcome' })

D.resource file '/etc/motd' ensure file content 'Welcome'

Explanation: Puppet resource declarations use the form `type { 'title': attribute => value, ... }`. Hash rocket (`=>`) separates attributes and values, commas separate attributes, and the trailing comma is conventional. The other forms are not valid Puppet DSL. Exam tip: `ensure => present` and `ensure => file` are both common; `present` allows directories or files, while `file` requires a regular file.

3Which Puppet metaparameter creates an explicit ordering dependency so resource A is applied before resource B?

A.needs

B.before

C.after

D.depends_on

Explanation: The `before` metaparameter on resource A creates a dependency that A must apply before B. The opposite is `require` on B. Other ordering metaparameters are `notify` (apply A before B and refresh B) and `subscribe` (refresh B if A changes). `needs`, `after`, and `depends_on` are not valid Puppet metaparameters. Exam tip: chaining arrows (`->`, `~>`) provide the same semantics as `before`/`notify`.

4Which chaining arrow declares that resource A must be applied first AND that any changes to A trigger a refresh of B?

A.A -> B

B.A ~> B

C.A => B

D.A << B

Explanation: The `~>` arrow combines ordering and notification: A is applied first, and if A makes changes, B receives a refresh event. The plain `->` only enforces order. `=>` is the attribute-value separator (not chaining), and `<<` is for collecting exported resources. Exam tip: services typically receive `~>` from their config files so a config change triggers a service restart.

5What is the difference between Puppet's `class` and `define` (defined type)?

A.There is no difference

B.A class is declared once per node; a defined type can be declared multiple times with different titles

C.Classes accept parameters but defined types do not

D.Defined types must live in a separate module

Explanation: A `class` is a singleton — declaring it twice on the same node causes a duplicate-declaration error. A `define` (defined type) is a reusable resource template that can be instantiated many times with different titles, like declaring multiple `apache::vhost` instances. Both can accept parameters. Exam tip: use defined types when you need multiple instances of related resources (vhosts, mounts, users).

6Which conditional statement is most idiomatic for selecting a value based on multiple discrete options for a fact like `$facts['os']['family']`?

A.if/elsif/else

B.case

C.selector ($var ? {})

D.All three are valid; case and selector are most common for multi-way matching

Explanation: All three conditional forms are valid Puppet, but `case` and selector are idiomatic for multi-way matches against a value. `case` runs a block of statements per match; selector returns a value (assignable). `if/elsif/else` is fine but verbose for many branches. Exam tip: use selector for assignments (`$pkg = $facts['os']['family'] ? { 'RedHat' => 'httpd', default => 'apache2' }`).

7Which Puppet variable scope rule applies to a top-scope variable like `$::environment`?

A.Available only inside the manifest where defined

B.Available globally across all classes via the leading `::`

C.Available only to subclasses

D.Reset on every catalog compile

Explanation: Top-scope variables (declared in `site.pp` outside any class, or built-ins like `$::environment`) are accessible from any class using the fully qualified `$::` prefix. This was the legacy way to access globals; modern Puppet prefers explicit class parameters and Hiera. Exam tip: `$facts['x']` is the modern way to access node facts; `$::x` style still works for built-ins.

8Which symbol in Puppet DSL declares a resource reference (capitalized type and title used as a value)?

A.Type['title'] — capitalized type name with brackets

B.type{'title'} — lowercase, used as resource declaration

C.@type{'title'}

D.$Type['title']

Explanation: A reference to an existing resource uses the capitalized type and the title in square brackets, e.g., `Service['nginx']`. References are used as values in `before`, `require`, `notify`, `subscribe`, or in chaining arrows. Lowercase forms declare resources; the `@` prefix marks virtual resources, and `$` is for variables. Exam tip: `Service <| title == 'nginx' |>` is collector syntax, used to realize virtual or exported resources.

9Which directive declares that a node should include the `webserver` class?

A.use webserver

B.include webserver

C.import webserver

D.contain webserver

Explanation: `include webserver` declares the class on the node, making its resources part of the catalog. `contain` is similar but also adds the class as a dependency-containing relationship for ordering. `import` is deprecated, and `use` is not a Puppet directive. Exam tip: prefer `include` for simple inclusion and `contain` when ordering edges should propagate from your class to the contained class.

10What does the `ensure => latest` value on a `package` resource do?

A.Installs the most recent version available from the configured repository, and upgrades on subsequent runs if a newer version exists

B.Installs only the version specified in Hiera

C.Removes any existing version and installs from source

D.Pins the package to never be upgraded

Explanation: `ensure => latest` instructs the package provider to install the package and upgrade it if a newer version is available in the repo on subsequent agent runs. This is risky in production because it can introduce unplanned changes. `ensure => 'X.Y.Z'` pins to a specific version, and `ensure => held` (apt) prevents upgrades. Exam tip: in regulated environments, pin versions via Hiera rather than using `latest`.

About the Puppet 206 Exam

The Puppet Professional 206 (Puppet Certified Professional) exam validates the practical skills needed to manage infrastructure as code with Puppet. It tests Puppet language fluency, module design with the Roles and Profiles pattern, Hiera-driven data, agent/server architecture, code deployment workflows, and Bolt orchestration.

Questions

60 scored questions

Time Limit

90 minutes

Passing Score

60% (approximate)

Exam Fee

$200 (Perforce / Puppet (online proctored via Questionmark))

Puppet 206 Exam Content Outline

25%

Puppet Language Fundamentals

Resource declaration syntax, metaparameters, chaining arrows, conditionals (if/case/selector), iteration (each/map/filter), data types, variable scope, interpolation, sensitive data, and built-in functions

20%

Modules and Roles & Profiles

Module structure, autoloader rules, metadata.json, defined types, parameterized classes, the Roles and Profiles pattern, Forge modules, PDK, splat operator and create_resources, params pattern vs Hiera-in-modules

20%

Hiera Data Hierarchy

hiera.yaml configuration, hierarchy ordering, automatic parameter lookup, lookup() function, merge strategies (first/unique/deep), lookup_options, interpolation tokens, eyaml encryption with PKCS7, datadir conventions

15%

Agent/Server Architecture

Puppet agent run cycle (facts → catalog → apply → report), certificate signing with puppetserver ca, mTLS on TCP 8140, puppet.conf settings, noop mode, runinterval, PuppetDB, Facter and structured/trusted facts, puppet apply

10%

Environments and Code Deployment

Directory environments, environment.conf, r10k and Code Manager, Puppetfile, Git branches as environments, modulepath, site/ vs modules/ layout, Code Manager webhooks

10%

Bolt Orchestration and Puppet Enterprise

Bolt tasks and plans, inventory.yaml, SSH/WinRM transports, bolt apply, PE Console classification, RBAC, ENC, puppet-lint, rspec-puppet testing

How to Pass the Puppet 206 Exam

What You Need to Know

Passing score: 60% (approximate)
Exam length: 60 questions
Time limit: 90 minutes
Exam fee: $200

Keys to Passing

Complete 500+ practice questions
Score 80%+ consistently before scheduling
Focus on highest-weighted sections
Use our AI tutor for tough concepts

Puppet 206 Study Tips from Top Performers

1Build a lab with one Puppet server and 2-3 agents — practice the full agent run, certificate signing, and Code Manager deploys

2Memorize resource ordering: before/require, notify/subscribe, -> and ~> chaining arrows, and how they affect refresh events

3Master the Roles and Profiles pattern — roles include profiles, profiles wrap component modules, never include profiles directly on nodes

4Practice writing Hiera 5 hiera.yaml: hierarchy ordering, datadir, lookup_options, merge strategies, interpolation tokens including %{trusted.certname}

5Drill class parameter automatic lookup: Hiera automatically resolves <class>::<param> regardless of default values

6Know the Puppet language data types and use them on parameters: Integer[1,100], Enum['a','b','c'], Sensitive, Optional[String]

7Practice Bolt tasks and plans with inventory.yaml — understand when to use Bolt (orchestration) vs the Puppet agent (continuous enforcement)

Frequently Asked Questions

What is the Puppet Professional 206 exam?

The Puppet 206 exam (also called PPT-206 or Puppet Certified Professional) is a vendor certification from Perforce (Puppet) that validates professional-level Puppet skills. It tests Puppet language fluency, module design, Hiera data, agent/server operations, code deployment, and Bolt orchestration. Targeted at engineers with hands-on Puppet experience managing infrastructure as code.

How many questions are on the Puppet 206 exam?

The exam has 60 multiple-choice scenario-based questions and a 90-minute time limit. It is delivered as an online, remotely proctored exam via Questionmark. Many questions present a real-world scenario and ask which Puppet language construct, module pattern, or operational command should be used.

How much does the Puppet 206 exam cost?

The Puppet 206 exam costs approximately $200 USD (pricing varies by region and currency). The exam fee covers a single attempt; retakes require an additional fee. Vouchers may be bundled with Puppet training courses.

What are the largest topic areas on the Puppet 206 exam?

Puppet language fundamentals are the largest area (~25%), covering resource syntax, conditionals, iteration, and data types. Modules and the Roles/Profiles pattern (~20%) and Hiera data hierarchy (~20%) follow closely. Agent/server architecture (~15%), environments and code deployment with r10k or Code Manager (~10%), and Bolt orchestration/Puppet Enterprise (~10%) round out the exam.

Does the Puppet certification expire?

Yes — the Puppet Certified Professional credential is typically valid for two years. To maintain certification, you must retake and pass the current exam version before expiration. Puppet updates the exam periodically as the platform evolves.

How should I prepare for the Puppet 206 exam?

Plan for 50-80 hours of study spread over 6-8 weeks. Build a Puppet master and at least two agents in a lab; write modules following the Roles and Profiles pattern; configure Hiera with multiple hierarchy levels; deploy code via r10k from a Git control repo; and practice Bolt tasks and plans. Take 100+ practice questions and aim for 80%+ before scheduling.

What jobs benefit from Puppet 206 certification?

Puppet 206 aligns with roles such as DevOps Engineer, Site Reliability Engineer, Infrastructure Engineer, Configuration Management Engineer, and Platform Engineer. It is commonly cited in job postings for organizations standardizing on Puppet Enterprise or large open-source Puppet deployments.