Puppet 5 Beginners Guide 3rd Edition

• Cover
• Copyright
• Credits
• About the Author
• Acknowledgments
• About the Reviewer
• www.PacktPub.com
• Customer Feedback
• Table of Contents
• Preface
• Chapter 1: Getting started with Puppet
  • Why do we need Puppet anyway?
    • Keeping the configuration synchronized
    • Repeating changes across many servers
    • Self-updating documentation
    • Version control and history
    • Why not just write shell scripts?
    • Why not just use containers?
    • Why not just use serverless?
  • Configuration management tools
  • What is Puppet?
    • Resources and attributes
    • Puppet architectures
  • Getting ready for Puppet
    • Installing Git and downloading the repo
    • Installing VirtualBox and Vagrant
    • Running your Vagrant VM
    • Troubleshooting Vagrant
  • Summary
• Chapter 2: Creating your first manifests
  • Hello, Puppet – your first Puppet manifest
    • Understanding the code
    • Modifying existing files
    • Dry-running Puppet
    • How Puppet applies the manifest
    • Creating a file of your own
  • Managing packages
    • How Puppet applies the manifest
    • Exercise
    • Querying resources with the puppet resource
  • Services
    • Getting help on resources with puppet describe
    • The package-file-service pattern
    • Notifying a linked resource
    • Resource ordering with require
  • Summary
• Chapter 3: Managing your Puppet code with Git
  • What is version control?
    • Tracking changes
    • Sharing code
  • Creating a Git repo
    • Making your first commit
    • How often should I commit?
    • Branching
  • Distributing Puppet manifests
    • Creating a GitHub account and project
    • Pushing your repo to GitHub
    • Cloning the repo
  • Fetching and applying changes automatically
    • Writing a manifest to set up regular Puppet runs
    • Applying the run-puppet manifest
    • The run-puppet script
    • Testing automatic Puppet runs
    • Managing multiple nodes
  • Summary
• Chapter 4: Understanding Puppet resources
  • Files
    • The path attribute
    • Managing whole files
    • Ownership
    • Permissions
    • Directories
    • Trees of files
    • Symbolic links
  • Packages
    • Uninstalling packages
    • Installing specific versions
    • Installing the latest version
    • Installing Ruby gems
    • Installing gems in Puppet's context
    • Using ensure_packages
  • Services
    • The hasstatus attribute
    • The pattern attribute
    • The hasrestart and restart attributes
  • Users
    • Creating users
    • The user resource
    • The group resource
    • Managing SSH keys
    • Removing users
  • Cron resources
    • Attributes of the cron resource
    • Randomizing cron jobs
    • Removing cron jobs
  • Exec resources
    • Automating manual interaction
    • Attributes of the exec resource
    • The user attribute
    • The onlyif and unless attributes
    • The refreshonly attribute
    • The logoutput attribute
    • The timeout attribute
    • How not to misuse exec resources
  • Summary
• Chapter 5: Variables, expressions, and facts
  • Introducing variables
    • Using Booleans
    • Interpolating variables in strings
    • Creating arrays
    • Declaring arrays of resources
    • Understanding hashes
    • Setting resource attributes from a hash
  • Introducing expressions
    • Meeting Puppet's comparison operators
    • Introducing regular expressions
    • Using conditional expressions
    • Making decisions with if statements
    • Choosing options with case statements
  • Finding out facts
    • Using the facts hash
    • Running the facter command
    • Accessing hashes of facts
    • Referencing facts in expressions
    • Using memory facts
    • Discovering networking facts
    • Providing external facts
    • Creating executable facts
  • Iterating over arrays
    • Using the each function
    • Iterating over hashes
  • Summary
• Chapter 6: Managing data with Hiera
  • Why Hiera?
    • Data needs to be maintained
    • Settings depend on nodes
    • Operating systems differ
    • The Hiera way
  • Setting up Hiera
  • Adding Hiera data to your Puppet repo
    • Troubleshooting Hiera
  • Querying Hiera
    • Typed lookups
  • Types of Hiera data
    • Single values
    • Boolean values
    • Arrays
    • Hashes
  • Interpolation in Hiera data
    • Using lookup()
    • Using alias()
    • Using literal()
  • The hierarchy
    • Dealing with multiple values
    • Merge behaviors
    • Data sources based on facts
    • What belongs in Hiera?
  • Creating resources with Hiera data
    • Building resources from Hiera arrays
    • Building resources from Hiera hashes
    • The advantages of managing resources with Hiera data
  • Managing secret data
    • Setting up GnuPG
    • Adding an encrypted Hiera source
    • Creating an encrypted secret
    • How Hiera decrypts secrets
    • Editing or adding encrypted secrets
    • Distributing the decryption key
  • Summary
• Chapter 7: Mastering modules
  • Using Puppet Forge modules
    • What is the Puppet Forge?
    • Finding the module you need
    • Using r10k
    • Understanding the Puppetfile
    • Managing dependencies with generate-puppetfile
  • Using modules in your manifests
    • Using puppetlabs/mysql
    • Using puppetlabs/apache
    • Using puppet/archive
  • Exploring the standard library
    • Safely installing packages with ensure_packages
    • Modifying files in place with file_line
    • Introducing some other useful functions
    • The pry debugger
  • Writing your own modules
    • Creating a repo for your module
    • Writing the module code
    • Creating and validating the module metadata
    • Tagging your module
    • Installing your module
    • Applying your module
    • More complex modules
    • Uploading modules to Puppet Forge
  • Summary
• Chapter 8: Classes, roles, and profiles
  • Classes
    • The class keyword
    • Declaring parameters to classes
    • Automatic parameter lookup from Hiera data
  • Parameter data types
    • Available data types
    • Content type parameters
    • Range parameters
    • Flexible data types
  • Defined resource types
    • Type aliases
  • Managing classes with Hiera
    • Using include with lookup()
    • Common and per-node classes
  • Roles and profiles
    • Roles
    • Profiles
  • Summary
• Chapter 9: Managing files with templates
  • What are templates?
    • The dynamic data problem
    • Puppet template syntax
  • Using templates in your manifests
    • Referencing template files
    • Inline templates
    • Template tags
    • Computations in templates
    • Conditional statements in templates
  • Iteration in templates
    • Iterating over Facter data
    • Iterating over structured facts
    • Iterating over Hiera data
    • Working with templates
    • Passing parameters to templates
    • Validating template syntax
    • Rendering templates on the command line
    • Legacy ERB templates
  • Summary
• Chapter 10: Controlling containers
  • Understanding containers
    • The deployment problem
    • Options for deployment
    • Introducing the container
    • What Docker does for containers
  • Deployment with Docker
    • Building Docker containers
    • The layered filesystem
    • Managing containers with Puppet
  • Managing Docker with Puppet
    • Installing Docker
    • Running a Docker container
    • Stopping a container
    • Running multiple instances of a container
  • Managing Docker images
    • Building images from Dockerfiles
    • Managing Dockerfiles
  • Building dynamic containers
    • Configuring containers with templates
    • Self-configuring containers
  • Persistent storage for containers
    • Host-mounted volumes
    • Docker volumes
  • Networking and orchestration
    • Connecting containers
    • Container orchestration
    • What is orchestration?
    • What orchestration tools are available?
  • Running Puppet inside containers
    • Are containers mini VMs or single processes?
    • Configuring containers with Puppet
    • Containers need Puppet too
  • Summary
• Chapter 11: Orchestrating cloud resources
  • Introducing the cloud
    • Automating cloud provisioning
    • Using CloudFormation
    • Using Terraform
    • Using Puppet
  • Setting up an Amazon AWS account
    • Creating an AWS account
    • Creating an IAM policy
    • Creating an IAM user
    • Storing your AWS credentials
  • Getting ready to use puppetlabs/aws
    • Creating a key pair
    • Installing the puppetlabs/aws module
    • Installing the AWS SDK gem
  • Creating EC2 instances with Puppet
    • Choosing an Amazon Machine Image (AMI)
    • Creating the EC2 instance
    • Accessing your EC2 instance
    • VPCs, subnets, and security groups
    • The ec2_securitygroup resource
    • The ec2_instance resource
  • Managing custom VPCs and subnets
    • Creating an instance in a custom VPC
    • The ec2_vpc resource
    • The ec2_vpc_internet_gateway resource
    • The ec2_vpc_routetable resource
    • The ec2_vpc_subnet resource
    • Other AWS resource types
  • Provisioning AWS resources from Hiera data
    • Iterating over Hiera data to create resources
    • Cleaning up unused resources
  • Summary
• Chapter 12: Putting it all together
  • Getting the demo repo
    • Copying the repo
  • Understanding the demo repo
    • The control repo
    • Module management
    • Classes
    • Roles
    • Profiles
    • Users and access control
    • SSH configuration
    • Sudoers configuration
    • Time zone and clock synchronization
    • Puppet configuration
  • The bootstrap process
  • Adapting the repo for your own use
    • Configuring users
    • Adding per-node data files and role classes
    • Modifying the bootstrap credentials
  • Bootstrapping a new node
    • Bootstrapping a Vagrant VM
    • Bootstrapping physical or cloud nodes
    • Using other distributions and providers
  • Summary
  • The beginning
• Index