Index
A
- acceptance testing, Acceptance Testing-Resource validation
- access control lists (ACLs), The ACL type
- account defined type, The account defined type
- ACL types, The ACL type
- after attribute, The after attribute
- alias metaparameter, alias
- anchor pattern, Anchors
- anchor type, The anchor type
- Apache, Implement the smallest usable component
- application defaults, module layer and, Module layer: application defaults
- application logic, Application logic, Application Logic and Puppet Modules-Identifying site-specific data in Puppet modules
- archive type, The archive resource
- array-style resource declaration, Use Arrays for Similar Resources
- audit metaparameter, audit
- Augeas Providers, Augeas providers
- authentication database, Puppet as, The accounts hierarchies
B
- base profiles, avoiding, Avoid creating a base profile
- Beaker, Resource validation
- before metaparameter, Ordering metaparameters: before and require
- best practice, defined, What Is a Best Practice?
- branch-per-task/branch-per-issue deployment model, Single Branch (GitHub Flow)
- (see also single branch (GitHub Flow) release management strategy)
- business data, global layer and, Global layer: business data
- business logic, Business logic
C
- catalogs
- CD (continuous delivery), Implement Continuous Integration, Delivery, and Deployment
- CI (continuous integration), Implement Continuous Integration, Delivery, and Deployment, Reducing Upgrade Costs
- class inheritance, passing data via, Passing data via class inheritence
- class parameters
- class(es)
- classification (see node classification)
- clever code, readable code vs., KISS: Keep It Simple
- Cobbler, Cobbler
- code
- code logic
- Code Manager, Release Engineering and r10k
- Code Manager WebHook, Puppet Enterprise: Code Manager WebHook
- codebase, Puppet
- coding practices, Coding Practices-Summary
- balance of code vs. data, Balance of Code Versus Data
- balance of resources vs. logic, Balance of Resources Versus Logic
- best practices for readable code patterns, Code Practices-Generating Lists
- conditional logic, Conditional Logic-Conditional Logic
- data transformation, Data Transformation-Data Transformation
- function calls, Function Calls-Catalog Tests
- generating lists, Generating Lists
- iteration, Iteration-Iteration with functions
- principles for development, Coding Principles-YAGNI: You Ain’t Gonna Need It (or You’re Not Google)
- style guide, The Style Guide
- templates, Templates-EPP Versus ERB
- variables, Variables-Strict Variables
- coding principles, Coding Principles-YAGNI: You Ain’t Gonna Need It (or You’re Not Google)
- command line, resource declaration on, Declare a resource on the command line
- component modules, business logic and, Business Logic Should Not Be Written into Component Modules
- concat defined type, The datacat types, The concat defined type
- concurrency protection, Concurrency protection
- conditional logic
- configuration, Puppet environment, Environment Configuration
- contain keyword, Containment
- containers, acceptance testing with, Use containers or virtualization for acceptance testing
- containment, Class Containment-Intentionally uncontained classes
- continuous delivery (CD), Implement Continuous Integration, Delivery, and Deployment
- continuous deployment, Implement Continuous Integration, Delivery, and Deployment
- continuous integration (CI), Implement Continuous Integration, Delivery, and Deployment, Reducing Upgrade Costs
- control repository, The Control Repository-Alternative file and directory conventions
- convergence, idempotency vs., Idempotency
- create_resources() function, Iteration with resources, The create_resources() function
- custom facts, Custom facts
- custom Hiera backends, Creating Custom Hiera Backends-Creating a High-Performance Backend
- custom resource providers, Custom Resource Providers-Retrieving existing resource instances
- adding providers to a resource, Adding providers to a resource
- creating, Creating a resource provider
- inheriting an existing provider, Inheriting an existing provider
- JSON/YAML/XML support, JSON, YAML, XML, and other well-known formats
- OLE support, Windows Management Interface and object linking and embedding
- retrieving existing resource instances, Retrieving existing resource instances
- reusing existing frameworks for, Reuse Existing Frameworks
- text frameworks, Text frameworks
- custom types, Custom Resource Types-The windows_env native type and provider
D
- data
- data in modules
- data lookups, Provide the Role for Use in Data Lookups
- data transformation, coding best practices for, Data Transformation-Data Transformation
- data type comparison functions, Data type comparison
- data types
- data validation functions, Data validation functions
- datacat types, The datacat types
- debugging
- declaration of resources (see resource declaration)
- declarative code, Declarative Code-Nondeclarative Code with Puppet
- deep hierarchies, Avoid unnecessary deep hierarchies
- default statements (see resource default statements)
- defined types, Resources, Useful Defined Types
- dependencies
- deploy (r10k command), What Does r10k Actually Do?
- deployments, Security of the control repository
- (see also r10k, release engineering)
- best practices for, Best Practices for Puppet Deployments-Don’t go cowboy on shared infrastructure
- concurrency protection, Concurrency protection
- enabling multiteam coordination, Enabling Multiteam Coordination-Multiple module directories within a single Puppet environment
- Git best practices, Git Best Practices
- Hiera data in control repository, Hiera data in the control repository
- isolating Puppet extensions, Isolating Puppet Extensions
- pinning module versions, Pinning Module Versions
- practices, Deployment Practices
- Puppet extensions, Deploying Extensions-Summary
- security of the control repository, Security of the control repository
- shared infrastructure and, Don’t go cowboy on shared infrastructure
- standard environment configuration practices with, Utilizing Standard Environment Configuration Practices-Environment documentation
- using repository access control to enforce deployment policy, Using Repository Access Control to Enforce Deployment Policy
- design philosophy, Puppet, The Puppet Design Philosophy-Summary
- development environments, r10k and, Build Development Environments
- Docker, Use containers or virtualization for acceptance testing
- documentation
- dependencies, Dependencies
- environment configuration, Environment documentation
- for modules, Creating Useful Documentation-Inline documentation
- inline, Inline documentation
- license information, License information
- parameters, Parameter documentation
- README markdown, README, REFERENCE, and Other Markdown
- REFERENCE markdown, REFERENCE Markdown
- usage examples, Usage examples
- DRY (Don't Repeat Yourself) principle, DRY: Don’t Repeat Yourself-DRY: Don’t Repeat Yourself, Avoid Parse-Order Problems by Using Virtual Resources
E
- Embedded Puppet Programming Language (EPP) templates, EPP Templates
- Embedded Ruby (ERB) template, ERB Templates, EPP Versus ERB
- encrypted YAML (eYAML), eYAML
- encryption, Hiera backends for, Encrypted Key/Value Storage-Encrypted Hiera is not filesystem security
- ENCs (external node classifiers), ENCs, ENCs-Build your own ENC
- building your own, Build your own ENC
- class assignment, Class list (node role)
- Cobbler, Cobbler
- data provided by, What Data Can an ENC Provide?
- Foreman, Foreman
- identifying node roles in, Identifying node roles in the ENC
- inventory/infrastructure management, Inventory and Infrastructure Management ENCs-Build your own ENC
- limitations, Roles and Profiles
- node parameters, Node parameters
- Puppet Dashboard, Puppet Dashboard
- Puppet Enterprise console, Puppet Enterprise console
- Puppet environment overrides, Puppet environment
- Puppet management consoles, Puppet Management Consoles
- Roles and Profiles vs., Roles and profiles versus node classifiers
- ensure_resource() function, The ensure_ functions
- environment (Puppet)
- environment configuration, Environment Configuration
- environment data, Global, Environment, and Module Data
- environment interpolation, Remove environment interpolation
- environment layer, Environment layer: site, service, and node-specific data
- EPP (Embedded Puppet Programming Language) templates, EPP Templates
- ERB (Embedded Ruby) template, ERB Templates, EPP Versus ERB
- eventually convergent model, Idempotency, Run-Level Idempotence
- exported resources, Exporting Resources-Safely using exported resource
- extending Puppet, Extending Puppet-Summary
- cost of, The Cost of Extending Puppet
- creating custom Hiera backends, Creating Custom Hiera Backends-Creating a High-Performance Backend
- creating facts, Creating Facts-Trusted Certificate Attributes
- custom types/providers, Custom Types and Providers-Windows Management Interface and object linking and embedding
- deploying extensions, Deploying Extensions-Summary
- gem dependencies, Deploying Gem Dependencies
- indirection, Indirection
- installing Ruby gem extensions on Puppet Server, Deploying Ruby Gem Extensions on Puppet Server
- minimizing development costs, Minimizing Development Costs
- pluginsync, pluginsync
- public classes and method calls, Using Puppet’s Public Classes and Method Calls
- Puppet Faces API, Puppet Faces
- reducing upgrade costs, Reducing Upgrade Costs
- testing, Testing-Resource validation
- external facts, External facts
- external node classifiers (see ENCs)
- eYAML (encrypted YAML), eYAML
F
- fact-based node classification, Fact-Based Classification-Serverless Classification
- facts
- abuses of, Abusing Facts
- as source of external untrusted data, Input Validation
- creating, Creating Facts-Trusted Certificate Attributes
- custom (see custom facts)
- distributing in modules, Distributing Facts in Modules
- external, External facts
- node-provided, Hiera as a node classifier, Node-provided facts
- structured, Structured Facts
- trusted certificate attributes, Trusted Certificate Attributes
- when Puppet can't determine data programatically, Facts Puppet Can’t Know
- facts hash, Use the facts hash to retrieve variables
- filebuckets, Filebuckets
- file_line type, The file_line resource type
- flat hierarchies, Avoid unnecessary deep hierarchies
- Foreman, Foreman
- fully qualified domain name (FQDN), Node Statements, Partial node match
- fully qualified paths, removing, Remove Fully Qualified Paths
- fully qualified variables, passing data via, Passing data via fully qualified variable references
- function calls
- catalog tests, Catalog Tests
- coding best practices for, Function Calls-Catalog Tests
- data type comparison, Data type comparison
- data validation, Data validation functions
- for logging/debugging, Functions for Logging and Debugging
- for resource declaration, Resource Declaration by Functions-The ensure_ functions
- Hiera, Hiera Function Calls-Data-driven class assignment
- input validation, Input Validation Functions
- iteration with, Iteration with functions
- parentheses with, Always Use Parentheses
- path manipulation, Path Manipulation
- string manipulation, String Manipulation Functions
- value existence type comparison, Value existence comparison
H
- Hiera, Hiera Data-Summary
- accessing, Accessing Hiera-Interpolation in Your Data
- accounts hierarchies, The accounts hierarchies
- automatic parameter lookups, Automatic Parameter Lookups
- backends, Hiera Backends
- built-in backends, The Built-In Backends-eYAML
- business/service/site/node/application data, Business, Service, Site, Node, and Application Data
- converting serialized data into resource declarations, Converting Serialized Hiera Data into Resource Declarations
- creating custom backends, Creating Custom Hiera Backends-Creating a High-Performance Backend
- custom backends, Custom Hiera Backends-Encrypted Hiera is not filesystem security
- customizing using facts, Customizing Hiera hierarchy using facts
- data in modules pattern, Module layer: application defaults, Hiera Data in Modules-Hiera Data in Modules
- data sources, Hiera Data Sources
- database/NoSQL backends, Database and NoSQL Engines
- declaring classes from, Declaring classes from Hiera data
- design guidelines, Design Guidelines-Deep hierarchies should contain data relevant to the top level
- eliminating data, Eliminating Data
- encrypted key/value storage backends, Encrypted Key/Value Storage-Encrypted Hiera is not filesystem security
- environment configuration practices for deployment, Keeping Hiera configuration within the environment
- eYAML and, eYAML
- fact-based node classification, Fact-Based Hiera Classification
- for profiles, Shared Hiera data
- function calls, Hiera Function Calls-Data-driven class assignment
- (see also lookup() function call, Hiera)
- global/environment/module data, Global, Environment, and Module Data
- hierarchy design, Designing the Hiera Hierarchy-Service discovery
- HOCON and, HOCON
- in control repository, Hiera data in the control repository
- interpolation in data, Interpolation in Your Data
- JSON and, JSON
- listing classes in, Listing classes in Hiera data
- module layer, Module layer: application defaults
- node classification, Hiera as a node classifier
- node parameters with Hiera classification, Node Parameters with Hiera Classification
- packages level, Packages hierarchy level
- params.pp and, The params.pp Pattern
- Puppetfile, Hiera data
- role definition in, Hiera-defined roles
- separating code and data, Separating Code and Data-Hiera Backends
- service discovery backends, Service Discovery Backends
- service discovery from, Service discovery from Hiera
- state information from custom backend, Hiera
- static data in, Static data in Hiera
- team level, Team hierarchy level
- third-party external data sources in, Accessing third-party external data sources in Hiera
- useful hierarchy levels, Useful Hierarchy Levels-Team hierarchy level
- variable interpolation, Variable Interpolation
- (see also interpolation, Hiera hierarchy)
- YAML and, YAML
- hierarchy design, Hiera, Designing the Hiera Hierarchy-Service discovery
- Human-Optimized Config Object Notation (HOCON), HOCON
I
- IDE (integrated development environment), Favor Editors or IDEs with Puppet Plugins
- idempotency, Idempotency-Nondeterministic Code
- imperative code, declarative code vs., Declarative Code
- (see also procedural code)
- indirectors, Indirection
- infrastructure management, Inventory and Infrastructure Management ENCs-Build your own ENC
- inheritance
- inifile, inifile
- ini_setting, The ini_setting and ini_subsetting resource types, inifile
- ini_subsetting, The ini_setting and ini_subsetting resource types
- inline documentation, Inline documentation, puppet-strings
- input validation, Input testing with rspec-Testing input validation
- instances method, Retrieving existing resource instances
- integrated development environment (IDE), Favor Editors or IDEs with Puppet Plugins
- interface, defining for types, Defining the type’s interface
- interface-driven design principle, Interface-Driven Design-Interface-Driven Design
- interpolation
- inventory information, Inventory and reporting
- iteration, Iteration-Iteration with functions
J
- JSON (JavaScript Object Notation), JSON
L
- leaf classes, Resource Default Statements
- license information documentation, License information
- lint tool, Puppet code lint
- lists, generating, Generating Lists
- logging, function calls for, Functions for Logging and Debugging
- lookup() function call, Hiera, Hiera Function Calls-Data-driven class assignment
- lookups, Provide the Role for Use in Data Lookups
- low coupling/high cohesion philosophy, Avoid tight relationships whenever possible
M
- main class manifest, The Module’s Main Class-An example main class
- manifest file, Environment manifests
- manifests, avoiding node data in, Avoiding Node Data in Manifests
- MCollective, Orchestrating Deployments with MCollective/Choria
- metadata test, Puppet metadata
- metaparameters (see resource metaparameters)
- metaprofiles
- metatypes, Resources Metatypes
- module data, Global, Environment, and Module Data
- module layer, Module layer: application defaults
- modules
- application logic and, Application Logic and Puppet Modules-Identifying site-specific data in Puppet modules
- as reusable building blocks, The Single Responsibility Principle
- basic layout, Basic Module Layout
- business logic and component modules, Business Logic Should Not Be Written into Component Modules
- business logic in, Identifying business logic in Puppet modules
- checking applicability to your needs, Module Applicability to Your Needs-Module Applicability to Your Needs
- checklist for, Module Checklist
- class parameters, Module Parameters-Parameter naming conventions
- class relationships, Class Relationships
- contributing your own module to Forge, Contributing Modules
- data in, Data in the Module-Hiera Data in Modules
- data in modules pattern, Hiera Data in Modules-Hiera Data in Modules
- dependencies, Dependencies
- design best practices, Designing Modules Well
- design of, Puppet Module Design-Summary
- designing for public consumption, Design Modules for Public Consumption
- distributing facts in, Distributing Facts in Modules
- documentation for, Creating Useful Documentation-Inline documentation
- indicators of quality design, Picking Good Modules
- input validation, Input Validation
- interfacing with classes, Interfacing with Classes-Passing data via class inheritence
- keeping module focused, Keep the Module Focused
- main class, The Module’s Main Class-An example main class
- making use of module structure, Make Use of Module Structure
- modularizing classes, Modularizing Classes-Passing data via class inheritence
- parameter defaults, Parameter defaults
- parameter naming conventions, Parameter naming conventions
- params.pp pattern, The params.pp Pattern
- per-expression defaults and, Per-expression defaults provide a solution
- pinning versions, Pinning Module Versions
- planning/scoping, Planning and Scoping Your Module-Input Validation
- profiles for defining relationships between modules and dependencies, Defining Module Relationships in Profiles
- Puppet Development Kit, The Puppet Development Kit
- resource default statements and, Per-expression defaults provide a way to avoid surprises
- reusing defined types, Reusing Defined Types-Including other classes
- separation of concerns, Separation of Concerns
- single responsibility principle, The Single Responsibility Principle
- site-specific data in, Identifying site-specific data in Puppet modules
- vendor-provided or community, Using Vendor-Provided or Community Modules-Contributing Modules
- modules directory, The modules directory
N
- namevar attribute, Displaying all instances of a resource
- Network Time Protocol (NTP) module, Example component module
- node
- node classification, Node Classification-Appropriate uses of node data, Node Classification-Summary
- node data (see node-specific data)
- node parameters
- node statements, Node Statements-Node Parameters Within Node Blocks
- node-provided facts, Node-provided facts
- node-specific data
- appropriate use of, Appropriate uses of node data
- avoiding in manifests, Avoiding Node Data in Manifests
- code logic and, Node data
- defined, Node Classification
- environment layer and, Environment layer: site, service, and node-specific data
- Hiera as data store for, Business, Service, Site, Node, and Application Data
- node classification and, Node-Specific Data
- non-declarative code, Nondeclarative Code with Puppet-Nondeclarative Code with Puppet
- nondeterministic code, Nondeterministic Code
- noop (no-operation) mode, Run-Level Idempotence, noop
- NoSQL custom backend (Hiera), Database and NoSQL Engines
- notification metaparameters, Notification metaparameters: notify and subscribe
- notify metaparameter, Notification metaparameters: notify and subscribe
- notify resource, Resource-Level Idempotence
- NTP (Network Time Protocol) module, Example component module
P
- package resource, Don’t Reinvent the Wheel
- Packer, Use containers or virtualization for acceptance testing
- parameterized class declarations, passing data via, Passing data via parameterized class declarations
- parameters (see class parameters)
- params.pp pattern, The Style Guide, The params.pp Pattern
- parentheses, function calls and, Always Use Parentheses
- path manipulation functions, Path Manipulation
- PDK (see Puppet Development Kit)
- per-expression defaults, Per-expression defaults provide a solution
- pluginsync, pluginsync
- PowerShell DSC, PowerShell DSC
- prerun_command configuration setting, Puppet Prerun Command
- privilege escalation, Input Validation
- procedural code, Procedural Example-Gain by replacing procedural code
- production deployment, r10k, Deploy Production Environments
- profiles, Profiles-Creating instances from a data example
- acceptance tests for confirming implementation, Confirming Profile Implementation with Acceptance Tests
- Apache and, Implement the smallest usable component
- creating instances from data, Creating instances from a data example
- creating metaprofiles to group configurations, Creating Metaprofiles to Group Configurations-Encapsulate one-off configurations in new profiles
- defined, Roles and Profiles
- defining module relationships in, Defining Module Relationships in Profiles
- designing appropriate structure for, Designing an Appropriate Profile Structure-Creating instances from a data example
- for each service instance, A profile for each service instance
- handling multiple instances, Handling multiple instances
- implementing business logic in, Implementing Business Logic in Profiles-Implementing Business Logic in Profiles
- implementing smallest usable component, Implement the smallest usable component
- providing actionable data in profile parameters, Providing Actionable Data in Profile Parameters
- sample service profile, A Sample Service Profile
- shared Hiera data for, Shared Hiera data
- technology stack implementation, Profiles implement technology stacks
- testing, Testing Roles and Profiles-Confirming Profile Implementation with Acceptance Tests
- unit tests for validating, Validating Profiles by Using Unit Tests
- providers (see resource providers)
- puppet apply command, puppet apply
- Puppet Dashboard, Puppet Dashboard
- puppet describe command, puppet describe
- Puppet Development Kit (PDK), The Puppet Development Kit
- Puppet Enterprise
- Puppet Faces API, Puppet Faces
- puppet resource command, puppet resource-Declare a resource on the command line
- Puppet Server, Deploying Ruby Gem Extensions on Puppet Server
- puppet-strings command, puppet-strings
- Puppetfile, Puppetfile
- puppetfile (r10k command), What Does r10k Actually Do?
R
- r10k, Release Engineering and r10k, Deploying with r10k-Deploying with r10k
- adding to existing deployments, Adding r10k to existing deployments
- as build tool, Build and Package
- building development environments with, Build Development Environments
- combining multiple invocation methods, Combining Multiple Invocation Methods
- concurrency protection, Concurrency protection
- configuration file, r10k Configuration File
- configuring an environment in control repository, Configuring an Environment in the Control Repository
- control repository, The Control Repository-Alternative file and directory conventions
- deploying on receipt of webhook, Deploying on Receipt of a WebHook
- deploying with, Deploying with r10k-Implementing Test Cases
- deployment of monolithic repo, Adding r10k deployment of monolithic repo
- deployment walkthrough, r10k Deployment Walkthrough-Deploying with r10k
- enabling monolithic/per-module hybrid development, Enabling Monolithic and Per-module Hybrid Deployment
- files used to provide metadata, Files used by r10k
- GitFlow release management strategy, GitFlow-GitFlow
- implementing CI/CD/continuous deployment with, Implement Continuous Integration, Delivery, and Deployment
- implementing test cases, Implementing Test Cases
- installing, Installing r10k
- invoking, Invoking r10k-Concurrency
- invoking in testing frameworks, Invoking r10k in Testing Frameworks
- migrating to, Migrating to r10k-Implementing Test Cases
- modulepath adjustment, Modulepath adjustment
- moving modules to their own repositories, Moving Modules to their Own Repositories-Moving dependent modules
- moving shared tools to their own repository, Moving Shared Tools to Their Own Repository
- orchestrating deployments with MCollective/Choria, Orchestrating Deployments with MCollective/Choria
- pinning module versions, Pinning Module Versions
- placing roles and profiles in the site/ module directory, Placing Roles and Profiles in the site/ Module Directory
- primary commands, What Does r10k Actually Do?
- production environment deployment, Deploy Production Environments
- Puppet prerun command, Puppet Prerun Command
- Puppetfile, Puppetfile
- release management strategies with, Release Management Strategies with r10k-GitFlow
- removing fully qualified paths, Remove Fully Qualified Paths
- repository-per-module benefits, Repository-per-Module Benefits
- simplifying acceptance testing with, Simplifying Acceptance Testing
- single branch (GitHub Flow) release management strategy, Single Branch (GitHub Flow)
- stage/production branch release management strategy, Stage/Production Branches
- test branch creation, Creating a test branch
- uses for, Uses for r10k-A hybrid approach
- readable code, clever code vs., KISS: Keep It Simple
- README markdown, README, REFERENCE, and Other Markdown
- reboot type, The reboot type
- REFERENCE markdown, REFERENCE Markdown
- referencing variables, Referencing Variables-Variable should be fully qualified
- registry type, The registry type
- regular expression (regex)
- release engineering, Release Engineering and r10k-Summary
- release management
- repository-per-module, Repository-per-Module Benefits
- require metaparameter, Ordering metaparameters: before and require
- resource chaining, Resource Chaining
- resource collectors, Dangling relationships to unrealized resources causes breakage, Resource Collectors
- resource declaration, Resource Declaration-Safely using exported resource
- array-style, Use Arrays for Similar Resources
- automatic resource relationships, Using Automatic Resource Relationships for Clean Code
- avoiding complex structures in, Avoid complex structures in resource declarations
- converting serialized Hiera data into, Converting Serialized Hiera Data into Resource Declarations
- create_resources() function, The create_resources() function
- DRY principle applied to, DRY: Don’t Repeat Yourself-DRY: Don’t Repeat Yourself
- ensure states, Ensure states
- ensure_resource() function, The ensure_ functions
- exporting resources, Exporting Resources-Safely using exported resource
- functions for, Resource Declaration by Functions-The ensure_ functions
- interpolation, Interpolation
- on command line, Declare a resource on the command line
- overriding/modifying declared resources, Overriding and Modifying Declared Resources-Resource Collectors
- procedural code replaced by, Gain by replacing procedural code
- resource chaining, Resource Chaining
- resource default statements, Resource Default Statements-Per-expression defaults provide a way to avoid surprises
- resource metaparameters, Resource Metaparameters-tag
- resources metatypes, Resources Metatypes
- static declaration, Static declaration
- using variables for data-driven declaration, Use Variables for Data-Driven Declaration
- virtual resources for avoiding parse-order problems, Avoid Parse-Order Problems by Using Virtual Resources-Dangling relationships to unrealized resources causes breakage
- resource default statements, Resource Default Statements-Per-expression defaults provide a way to avoid surprises
- resource metaparameters, Resource Metaparameters-tag
- alias, alias
- audit, audit
- avoiding tight relationships, Avoid tight relationships whenever possible
- before, Ordering metaparameters: before and require
- noop, noop
- notify, Notification metaparameters: notify and subscribe
- ordering with, Ordering metaparameters: before and require
- require, Ordering metaparameters: before and require
- schedule, schedule
- stage, stage
- subscribe, Notification metaparameters: notify and subscribe
- tag, tag
- resource providers, Resource Types and Providers
- adding providers to a resource, Adding providers to a resource
- Augeas Providers, Augeas providers
- creating, Creating a resource provider
- custom, Custom Resource Providers-Retrieving existing resource instances
- defined, Resource Types and Providers, Resources
- inheriting an existing provider, Inheriting an existing provider
- JSON/YAML/XML support, JSON, YAML, XML, and other well-known formats
- OLE support, Windows Management Interface and object linking and embedding
- retrieving existing resource instances, Retrieving existing resource instances
- reusing existing frameworks for, Reuse Existing Frameworks
- text frameworks, Text frameworks
- windows_env native type and provider, The windows_env native type and provider
- resource types
- about, Resource Types and Providers, Resource Types Abstract Implementation Details
- ACL, The ACL type
- anchor, The anchor type
- Augeas Providers, Augeas providers
- avoiding duplication, Avoiding Creation of Duplicate Types-The archive resource
- choosing appropriate type, Use the Most Specific Resource Type
- creating new type, Creating a New Resource Type
- custom, Custom Resource Types-The windows_env native type and provider, Custom Types and Providers-Windows Management Interface and object linking and embedding
- datacat, The datacat types
- defined (see defined types)
- defining interface, Defining the type’s interface
- describing state with, Describing state with a type
- file_line, The file_line resource type
- gnupg_key, The gnupg_key type
- ini_setting/ini_subsetting, The ini_setting and ini_subsetting resource types
- reboot, The reboot type
- registry, The registry type
- user defined, Useful Defined Types
- vcs_repo, The vcs_repo type
- windows_env native type and provider, The windows_env native type and provider
- resource validation
- resource-level idempotence, Resource-Level Idempotence-Resource-Level Idempotence
- resources, Resources-Summary
- best practices, Resource Best Practices-The account defined type
- catalog tests, Catalog Tests
- chaining, Resource Chaining
- class relationships, Class Relationships
- collectors, Resource Collectors
- conditional logic and, Conditional Logic-Conditional Logic
- conditional logic vs., Balance of Resources Versus Logic
- custom types, Custom Resource Types-The windows_env native type and provider
- declaration (see resource declaration)
- default statements, Resource Default Statements-Per-expression defaults provide a way to avoid surprises
- defined, Examining a Naked Resource
- defined types interacting with, Interacting with Other Resouces in the Module-Including other classes
- exporting, Exporting Resources-Safely using exported resource
- implementing change with, Using Resources to Implement Change-puppet apply
- iteration with, Iteration with resources
- logic vs., Balance of Resources Versus Logic
- metaparameters (see resource metaparameters)
- most common descriptions of, Examining a Naked Resource
- providers (see resource providers)
- puppet apply command, puppet apply
- puppet describe command, puppet describe
- puppet resource command, puppet resource-Declare a resource on the command line
- puppet-strings gem, puppet-strings
- state information from, Exported resources
- tools for exploring, Exploring Resources with Tools-puppet apply
- types (see resource types)
- wrapper modules and, Avoid tight relationships whenever possible
- resources metatypes, Resources Metatypes
- revision control, Release Management Strategies with r10k
- roles, Roles-Identifying node roles using node facts
- about, Roles
- acceptance tests for, Confirming Profile Implementation with Acceptance Tests
- business logic and, Roles describe business logic and site-specific configurations
- (see also roles and profiles)
- classes for declaring, Role classes
- creating readable roles, Creating Readable Roles-Hiera-defined roles
- data lookups and, Provide the Role for Use in Data Lookups
- defined, Roles and Profiles
- designing for singular use case, Design Roles for a Singular Use Case
- fact-based role assignment, Fact-Based Role Assignment
- Hiera-defined, Hiera-defined roles
- identifying node roles in ENCs, Identifying node roles in the ENC
- identifying node roles using node facts, Identifying node roles using node facts
- testing, Testing Roles and Profiles-Confirming Profile Implementation with Acceptance Tests
- unit tests for, Validating Profiles by Using Unit Tests
- roles and profiles, Roles and Profiles-Summary
- acceptance tests for, Confirming Profile Implementation with Acceptance Tests
- business logic with, Business Logic with Roles and Profiles
- converting node inheritance to, Replacing Node Inheritance-Node classification using roles and profiles
- fact-based declaration, Security and Fact-Selected Roles or Profiles
- node classification and, Roles and Profiles, Node classification using roles and profiles
- node classifiers vs., Roles and profiles versus node classifiers
- placing in the site/ module directory, Placing Roles and Profiles in the site/ Module Directory
- profiles, Profiles-Creating instances from a data example
- roles, Roles-Identifying node roles using node facts
- testing, Testing Roles and Profiles-Confirming Profile Implementation with Acceptance Tests
- unit tests for, Validating Profiles by Using Unit Tests
- rollbacks, unmanaged state and, Ensure states
- Rubocop tool, Ruby code cop
- Ruby
- run-level idempotence, Run-Level Idempotence
S
- scaling, module applicability to, Module Applicability to Your Needs
- schedule metaparameter, schedule
- security
- selectors, variable assignment with, Assignment with Selectors
- separation of concerns (SoC) principle, Separation of Concerns
- serialization, Examining a Naked Resource
- serverless node classification, Serverless Classification
- service data
- service discovery, Service discovery from Hiera, Service Discovery Backends
- side effects, idempotency and, Side Effects
- single branch (GitHub Flow) release management strategy, Single Branch (GitHub Flow)
- single responsibility principle, The Single Responsibility Principle
- site, defined, Site-specific data
- site-specific data
- code logic and, Site-specific data
- environment layer and, Environment layer: site, service, and node-specific data
- Hiera and, Business, Service, Site, Node, and Application Data
- profiles and, Providing Actionable Data in Profile Parameters
- Puppet modules, Identifying site-specific data in Puppet modules
- roles and, Roles describe business logic and site-specific configurations
- site/ module directory, Placing Roles and Profiles in the site/ Module Directory
- stage metaparameter, stage
- state
- state information
- stateless design, Stateless-Custom facts
- static analysis, Static Code Analysis
- static data, Static data in Hiera
- static declaration, Static declaration
- strict variables, Strict Variables
- string manipulation functions, String Manipulation Functions
- structured facts, Structured Facts
- style guide, Puppet, The Style Guide
- subscribe metaparameter, Notification metaparameters: notify and subscribe
T
- tag metaparameter, tag
- teams
- technology stack, profiles and, Profiles implement technology stacks
- templates
- testing
- text configuration files, Text frameworks
- text editors, Favor Editors or IDEs with Puppet Plugins
- tidy resource metatype, Resources Metatypes
- top-level variables, order of assignment for, Order of Assignment for Top-Level Variables
- transformation (see data transformation)
- trusted facts, Mitigating the risk by using trusted facts
- trusted variables, Trusted Variables
- types (see resource types)
V
- Vagrant, Use containers or virtualization for acceptance testing
- validation (see input validation)
- value existence type comparison functions, Value existence comparison
- variables
- assignment with selectors, Assignment with Selectors
- attribute values chosen by conditional evaluation, Attribute Values Chosen by Conditional Evaluation
- coding best practices, Variables-Strict Variables
- for data-driven declaration, Use Variables for Data-Driven Declaration
- fully qualifying, Variable should be fully qualified-Variable should be fully qualified
- inheritance, Variable Inheritance
- naming of, Variable Naming
- order of assignment for top-level, Order of Assignment for Top-Level Variables
- referencing, Referencing Variables-Variable should be fully qualified
- regular expressions and, Avoid anonymous regular expressions
- strict, Strict Variables
- trusted, Trusted Variables
- various use cases, Other Variable Use Cases
- vcs_repo type, The vcs_repo type
- virtual resources
- virtualization, acceptance testing with, Use containers or virtualization for acceptance testing
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.