Index
A
- agent
- enhancing, through plugins / Enhancing the agent through plugins
- agents
- resources, exporting to / Exporting resources to other agents
- All-in-One (AIO) packaging / Upgrading to Puppet 4
- anchor pattern / The anchor pattern
- antipatterns
- avoiding / Avoiding antipatterns
- arrays
- handling / Handling hashes and arrays
- array values
- exploiting, defined types used / Exploiting array values using defined types
B
- beaker
- reference link / Safe testing with environments
- best practices, modules / Modules' best practices
C
- central firewall
- maintaining / Maintaining your central firewall
- circular dependencies
- avoiding / Avoiding circular dependencies
- classes
- about / Introducing classes and defined types
- defining / Defining and declaring classes
- declaring / Defining and declaring classes
- versus defined types / Understanding and leveraging the differences
- including, from defined types / Including classes from defined types
- events, passing between / Passing events between classes and defined types
- making, flexible through parameters / Making classes more flexible through parameters
- class parameter values
- binding, automatically / Binding class parameter values automatically
- CN (common name) / The new Puppet 4 Master
- collectors
- used, for realizing resources / Realizing resources more flexibly using collectors
- component classes
- writing / Writing component classes
- composite design / Writing comprehensive classes
- comprehensive classes
- writing / Writing comprehensive classes
- about / Writing component classes
- configuration data
- structuring, in hierarchy / Structuring configuration data in a hierarchy
- contained class / The contain function
- container relationships
- performance implications / The performance implications of container relationships
- containers
- relationships, establishing among / Establishing relationships among containers
- ordering / Ordering containers
- limitations / Limitations
- contain function / The contain function
- control structures
- adding, in manifests / Adding control structures in manifests
- core resource types
- reference link / Substantiating the model with providers
- create_resources approach
- advantages / Converting resources to data
- cron
- Puppet agent, running from / Running the agent from cron
- cron resource type
- about / The cron resource type
- custom configuration items
- automating / Automating custom configuration items
- custom facts
- Facter, extending with / Extending Facter with custom facts
- about / Extending Facter with custom facts
- custom functions
- about / Parts of a module
- module interface, refining through / Refining the interface of your module through custom functions
D
- data
- resources, converting to / Converting resources to data
- data, defining in manifest
- consequences / Consequences of defining data in the manifest
- defined type, replacing with native type
- about / Replacing a defined type with a native type
- type, naming / Naming your type
- resource type interface, creating / Creating the resource type interface
- sensible parameter hooks, designing / Designing sensible parameter hooks
- resource names, using / Using resource names
- provider, adding / Adding a provider
- management commands, declaring / Declaring management commands
- basic functionality, implementing / Implementing the basic functionality
- provider, allowing to prefetch existing resources / Allowing the provider to prefetch existing resources
- type robust, making during provisioning / Making the type robust during provisioning
- defined types
- about / Introducing classes and defined types
- creating / Creating and using defined types
- using / Creating and using defined types
- versus classes / Understanding and leveraging the differences
- using, as resource wrappers / Using defined types as resource wrappers
- using, as resource multiplexers / Using defined types as resource multiplexers
- using, as macros / Using defined types as macros
- used, for exploiting array values / Exploiting array values using defined types
- classes, including from / Including classes from defined types
- events, passing between / Passing events between classes and defined types
- dependencies
- declaring / Declaring dependencies
- documentation, in modules / Documentation in modules
- domain-specific language (DSL) / Getting started
- dynamic configuration files
- templating / Templating dynamic configuration files
- dynamic scoping / Saving redundancy using resource defaults
E
- environment directories
- environment locations
- configuring / Configuring environment locations
- environments
- maintaining / Maintaining environments
- events
- passing, between classes / Passing events between classes and defined types
- passing, between defined types / Passing events between classes and defined types
- exec resource type
- about / The exec resource type
- external fact
- reference link / Enhancing Puppet's system knowledge through facts
- external facts
- External Node Classifiers (ENCs) / Converting resources to data
F
- Facter
- systems, summarizing with / Summarizing systems with Facter
- extending, with custom facts / Extending Facter with custom facts
- goals / Goals of Facter
- Facter 2
- facts
- system knowledge, enhacning through / Enhancing Puppet's system knowledge through facts
- fact values
- accessing / Accessing and using fact values
- using / Accessing and using fact values
- features
- Forge
- Forge modules
- finding / Finding helpful Forge modules
- fully qualified domain name (FQDN) / Accessing and using fact values
- functions
- learning / Learning lambdas and functions
G
- generalization
- avoiding / Avoiding generalization
H
- hashes
- handling / Handling hashes and arrays
- HEREDOC
- Multiline, handling with / Handling multiline with HEREDOC
- Hiera
- configuring / Configuring Hiera
- Hiera data
- storing / Storing Hiera data
- Hiera lookups
- debugging / Debugging Hiera lookups
- hierarchy
- configuration data, structuring in / Structuring configuration data in a hierarchy
- Hiera values
- retrieving / Retrieving and using Hiera values in manifests
- using, in manifests / Retrieving and using Hiera values in manifests
- hosts files
- managing, locally / Managing hosts files locally
I
- Icinga / Simplifying the configuration of Nagios
- immutability / Using variables
- include keyword
- preferring / Preferring the include keyword
- Infrastructure as Code paradigm / Safe testing with environments
- installation, Puppet / Getting started
- iterator functions
- using / Using iterator functions
L
- lambdas
- learning / Learning lambdas and functions
M
- macros
- defined types, using as / Using defined types as macros
- manifest
- dry testing / Dry-testing your manifest
- manifest, and Hiera designs
- selecting between / Choosing between manifest and Hiera designs
- manifests
- control structures, adding in / Adding control structures in manifests
- about / Parts of a module
- Hiera values, using in / Retrieving and using Hiera values in manifests
- master
- configuring, to store exported resources / Configuring the master to store exported resources
- metaparameters
- about / Declaring dependencies
- model
- substantiating, with providers / Substantiating the model with providers
- module
- practical example / A practical example
- module functionality
- implementing / Implementing basic module functionality
- module interface
- refining, through custom functions / Refining the interface of your module through custom functions
- modules
- overview / An overview of Puppet's modules
- parts / Parts of a module
- structure / Module structure
- documentation / Documentation in modules
- reference link / Documentation in modules
- obtaining / Obtaining and installing modules
- installing / Obtaining and installing modules
- best practices / Modules' best practices
- implementing / Putting everything in modules
- testing / Testing your modules
- safe testing, with environments / Safe testing with environments
- building / Building a specific module
- naming / Naming your module
- making, available for Puppet / Making your module available to Puppet
- making, portable across platforms / Making your module portable across platforms
- characteristics, identifying / Identifying modules' characteristics
- monolithic implementation / Writing comprehensive classes
- mount resource type
- about / The mount resource type
- Multiline
- handling, with HEREDOC / Handling multiline with HEREDOC
N
- Nagios / Simplifying the configuration of Nagios
- Nagios configuration
- simplifying / Simplifying the configuration of Nagios
- name variable / Using resource names
- new Puppet 4 Master / The new Puppet 4 Master
- new template engine
- leveraging / Leveraging the new template engine
- Nginx
- Phusion Passenger, using with / Using Phusion Passenger with Nginx
- Nginx packages
- reference link / Using Phusion Passenger with Nginx
- notable resource types
- examining / Examining the most notable resource types
- user and group types / The user and group types
- exec resource type / The exec resource type
- cron resource type / The cron resource type
- mount resource type / The mount resource type
O
- obsolete exports
- removing / Removing obsolete exports
- old practices, breaking
- about / Breaking old practices
- node inheritance, converting / Converting node inheritance
- dealing with bool algebra, on strings / Dealing with bool algebra on Strings
- strict variable naming, using / Using strict variable naming
- new Reference syntax, learning / Learning the new reference syntax
- hyphens, cleaning in names / Cleaning hyphens in names
- no Ruby DSL anymore / No Ruby DSL anymore
- relative class name resolution / Relative class name resolution
- dealing with different data types / Dealing with different data types
- order of evaluation, controlling
- about / Controlling the order of evaluation
- dependencies, declaring / Declaring dependencies
- error propagation / Error propagation
- circular dependencies, avoiding / Avoiding circular dependencies
P
- parameterized classes
- caveats / The caveats of parameterized classes
- parser functions
- about / Parts of a module
- Passenger
- comparing, with puppetserver / Comparing Passenger with puppetserver
- performance bottlenecks
- avoiding, from templates / Avoiding performance bottlenecks from templates
- performance considerations
- about / Performance considerations
- performance implications, of container relationships / The performance implications of container relationships
- Phusion Passenger
- using, with Nginx / Using Phusion Passenger with Nginx
- plugins
- agent, enhancing through / Enhancing the agent through plugins
- Profiles pattern
- implementing / Implementing the Roles and Profiles pattern
- properties
- providers
- model, substantiating with / Substantiating the model with providers
- summarizing / Summarizing types and providers
- implementing / Putting it all together
- Puppet
- installing / Getting started
- master machine, setting up / Setting up the master machine
- master manifest, creating / Creating the master manifest
- Puppet 3 functions API
- limitations / Creating Puppet 4 functions
- Puppet 3.8
- Puppet 4
- upgrading to / Upgrading to Puppet 4
- Puppet 4 functions
- creating / Creating Puppet 4 functions
- Puppet agent
- setting up / Setting up the Puppet Agent
- life cycle / The agent's life cycle
- certificate, renewing / Renewing an agent's certificate
- running, from cron / Running the agent from cron
- updating / Updating the Puppet agent
- puppet apply command
- output, interpreting of / Interpreting the output of the puppet apply command
- PuppetDB
- stack, completing with / Completing the stack with PuppetDB
- Puppet DSL code
- testing / Testing Puppet DSL code
- Puppet Labs
- URL, for documentation / Performance considerations
- puppetlabs-strings module
- reference link / Documentation in modules
- Puppet master
- about / The Puppet Master, Puppet Master and Puppet Server
- tasks / The Puppet Master
- configuration settings, inspecting / Inspecting the configuration settings
- Puppet modules
- about / Defining and declaring classes
- Puppet server
- about / Puppet Master and Puppet Server
- puppetserver
- tuning / Tuning puppetserver
- Passenger, comparing with / Comparing Passenger with puppetserver
R
- redundancy
- saving, resource defaults / Saving redundancy using resource defaults
- relationships
- establishing, among containers / Establishing relationships among containers
- resource defaults
- used, for saving redundancy / Saving redundancy using resource defaults
- resource interaction
- implementing / Implementing resource interaction
- resource multiplexers
- defined types, using as / Using defined types as resource multiplexers
- resource parameters
- overriding / Overriding resource parameters
- resources
- about / Introducing resources and properties
- realizing, collectors used / Realizing resources more flexibly using collectors
- exporting, to agents / Exporting resources to other agents
- exporting / Exporting and importing resources
- importing / Exporting and importing resources
- converting, to data / Converting resources to data
- resource type
- life cycle, on agent side / The resource type's life cycle on the agent side
- resource types
- using, with generic providers / Resource types with generic providers
- summarizing / Summarizing types and providers
- implementing / Putting it all together
- resource wrappers
- defined types, using as / Using defined types as resource wrappers
- Roles pattern
- implementing / Implementing the Roles and Profiles pattern
- rspec-puppet tool
- reference link / Safe testing with environments
S
- separate data storage
- simple values
- working with / Working with simple values
- singletons
- about / Using templates in practice
- site manifest
- about / Creating the master manifest
- SSH host keys
- exporting / Exporting SSH host keys
- SSL issues
- troubleshooting / Troubleshooting SSL issues
- stack
- completing, with PuppetDB / Completing the stack with PuppetDB
- stdlib module / Obtaining and installing modules
- structured design patterns
- about / Structured design patterns
- structured facts
- system knowledge
- enhancing, through facts / Enhancing Puppet's system knowledge through facts
- systems
- summarizing, with Facter / Summarizing systems with Facter
T
- templates
- variables, using in / Learning the template syntax
- using, in practice / Using templates in practice
- performance bottlenecks, avoiding from / Avoiding performance bottlenecks from templates
- template syntax
- about / Learning the template syntax
- transactions
- about / Understanding the type system
- type system
- about / Understanding the type system
- using / Using the type system
U
- update path, Puppet agent
- reference link / Updating the Puppet agent
- user and group types
- about / The user and group types
- utilities, creating for derived manifests
- about / Creating utilities for derived manifests
- configuration items, adding / Adding configuration items
- customization, allowing / Allowing customization
- unwanted configuration items, removing / Removing unwanted configuration items
- dealing, with complexity / Dealing with complexity
V
- variables
- using / Using variables
- using, in templates / Learning the template syntax
- variable types
- about / Variable types
- virtual resources
- creating / Creating virtual resources