Puppet 5 Beginner's Guide - Third Edition (ebook)(audiobook)(audiobook)

Spis treści

• Puppet 5 Beginners Guide Third Edition
  • Table of Contents
  • Puppet 5 Beginner's Guide Third Edition
  • Credits
  • About the Author
  • Acknowledgments
  • About the Reviewer
  • www.PacktPub.com
    • eBooks, discount offers, and more
      • Why subscribe?
  • Customer Feedback
  • Preface
    • What this book covers
    • What you need for this book
    • Who this book is for
    • Conventions
    • Reader feedback
    • Customer support
      • Downloading the example code
      • Errata
      • Piracy
      • Questions
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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

pokaż cały spis treści

ukryj recenzje