puppet

Execute a Puppet subcommand

$ puppet [subcommand]

$ puppet --version

$ puppet --help

$ puppet help [subcommand]

puppet subcommand [options] [arguments]

Common subcommands include:
agent: The client daemon that fetches and applies configurations from a Puppet master.
apply: Applies Puppet manifests locally without a master.
master: The central server that compiles and serves configurations.
module: Manages Puppet modules (install, list, search).
resource: Interacts with resource types (e.g., file, service) on the system.
cert: Manages SSL certificates for Puppet nodes.

--debug
    Global Option. Turns on full debugging output, useful for troubleshooting.

--verbose
    Global Option. Increases the verbosity of output.

--noop
    Global Option. Enables "no-op" mode, showing what changes would be made without actually applying them. Often used with `puppet agent` or `puppet apply`.

--environment
    Global Option. Specifies the Puppet environment to use for configuration lookup.

--config
    Global Option. Specifies the path to the main Puppet configuration file (`puppet.conf`).

--test
    Agent-specific Option. Used with `puppet agent` to enable a one-time run in test mode (implies `--noop`, `--verbose`, and disables daemonization).

Puppet is an open-source configuration management tool used for automating IT infrastructure management. It allows system administrators to define the desired state of their infrastructure using a high-level, declarative language called the Puppet DSL (Domain Specific Language). This "infrastructure as code" approach ensures consistency, repeatability, and scalability across numerous servers.

Puppet primarily operates in a client-server (agent-master) architecture, where a central Puppet Master compiles configurations (manifests) and agents apply them to individual nodes. It also supports a standalone mode using `puppet apply` for managing single systems without a master. Key features include idempotency (ensuring a resource is configured only if it's not already in the desired state), dependency management, and reporting. Puppet automates tasks like software installation, file management, service management, and user provisioning, significantly reducing manual effort and potential errors in large-scale deployments.

Complexity and Learning Curve: Puppet DSL and concepts (resources, classes, roles, profiles) can be complex for newcomers, requiring a significant learning investment.
Resource Consumption: The Puppet Master can be resource-intensive, especially in large environments with many agents checking in frequently.
Dependency Management: Managing complex inter-resource dependencies within manifests can become challenging and lead to unexpected behavior if not handled carefully.
Debugging: Debugging configuration issues, particularly in complex manifests or with custom types, can sometimes be intricate.

Puppet operates on several core concepts including:
Resources: The fundamental units of system configuration (e.g., a file, a service, a user).
Manifests: Files written in Puppet DSL that describe the desired state of resources.
Modules: Self-contained, reusable bundles of manifests, templates, and plugins, often shared via the Puppet Forge.
Facter: A system inventory tool that collects facts about the node (e.g., OS, IP address) for use in manifests.
Idempotency: Puppet ensures that applying a configuration multiple times has the same effect as applying it once, only making changes if the system deviates from the desired state.

Agent/Master Mode: The most common setup, where a Puppet agent on each managed node communicates with a central Puppet master for configurations.
Standalone Mode (Puppet Apply): For smaller environments or specific tasks, `puppet apply` directly executes manifests on a local node without requiring a master.

Puppet was created by Luke Kanies and first released in 2005. It was initially designed to solve the challenges of managing large numbers of servers consistently and efficiently. Over the years, Puppet has evolved significantly, becoming a cornerstone of the DevOps movement and a leading tool for "infrastructure as code."

Initially known for its agent-master architecture, subsequent releases introduced features like Puppet Apply for standalone operations and improved module management. The company behind Puppet, Puppet Inc. (originally Puppet Labs), was later acquired by Perforce Software in 2023, continuing its development and community support. Its declarative approach profoundly influenced modern system administration practices.

ansible(1), chef(1), salt(1)