Learning Puppet 4. A Guide to Configuration Management and Automation - Helion
ebook
Autor: Jo RhettISBN: 978-14-919-0800-6
stron: 594, Format: ebook
Data wydania: 2016-03-24
Księgarnia: Helion
Cena książki: 152,15 zł (poprzednio: 176,92 zł)
Oszczędzasz: 14% (-24,77 zł)
If you're a system administrator, developer, or site reliability engineer responsible for handling hundreds or even thousands of nodes in your network, the Puppet configuration management tool will make your job a whole lot easier. This practical guide shows you what Puppet does, how it works, and how it can provide significant value to your organization.
Through hands-on tutorials, DevOps engineer Jo Rhett demonstrates how Puppet manages complex and distributed components to ensure service availability. You’ll learn how to secure configuration consistency across servers, clients, your router, and even that computer in your pocket by setting up your own testing environment.
- Learn exactly what Puppet is, why it was created, and what problems it solves
- Tailor Puppet to your infrastructure with a design that meets your specific needs
- Write declarative Puppet policies to produce consistency in your systems
- Build, test, and publish your own Puppet modules
- Manage network devices such as routers and switches with puppet device and integrated Puppet agents
- Scale Puppet servers for high availability and performance
- Explore web dashboards and orchestration tools that supplement and complement Puppet
Osoby które kupowały "Learning Puppet 4. A Guide to Configuration Management and Automation", wybierały także:
- Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)
- Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
- DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
- Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku 58,64 zł, (12,90 zł -78%)
- Scrum. O zwinnym zarządzaniu projektami. Wydanie II rozszerzone 58,64 zł, (12,90 zł -78%)
Spis treści
Learning Puppet 4. A Guide to Configuration Management and Automation eBook -- spis treści
- Foreword
- Preface
- Who This Book Is For
- What to Expect from Me
- What You Will Need
- What Youll Find in This Book
- How to Use This Book
- IPv6 Ready
- SSL is now TLS
- Conventions Used in This Book
- Safari Books Online
- How to Contact Us
- Acknowledgments
- Introduction
- What Is Puppet?
- Why Declarative
- How Puppet Works
- Why Use Puppet
- Is Puppet DevOps?
- Time to Get Started
- I. Controlling with Puppet Apply
- 1. Thinking Declarative
- Handling Change
- Using Idempotence
- Declaring Final State
- Reviewing Declarative Programming
- 2. Creating a Learning Environment
- Installing Vagrant
- Installing Vagrant on Mac
- Installing Git Tools on Windows
- Installing VirtualBox on Windows
- Installing Vagrant on Windows
- Starting a Bash Shell
- Downloading a Box
- Cloning the Learning Repository
- Install the Vagrant vbguest Plugin
- Initializing the Vagrant Setup
- Verifying the /vagrant Filesystem
- Initializing Non-Vagrant Systems
- Installing Some Helpful Utilities
- Choosing a Text Editor
- On the Virtual System
- On Your Desktop
- In Your Profile
- Reviewing the Learning Environment
- Installing Vagrant
- 3. Installing Puppet
- Adding the Package Repository
- What Is a Puppet Collection?
- Installing the Puppet Agent
- Reviewing Dependencies
- Reviewing Puppet 4 Changes
- Linux and Unix
- Windows
- Making Tests Convenient
- Running Puppet Without sudo
- Running Puppet with sudo
- Reviewing Puppet Installation
- Adding the Package Repository
- 4. Writing Manifests
- Implementing Resources
- Applying a Manifest
- Declaring Resources
- Viewing Resources
- Executing Programs
- Was That Idempotent?
- Managing Files
- Finding File Backups
- Restoring Files
- Avoiding Imperative Manifests
- Testing Yourself
- Reviewing Writing Manifests
- 5. Using the Puppet Configuration Language
- Defining Variables
- Defining Numbers
- Creating Arrays and Hashes
- Mapping Hash Keys and Values
- Using Variables in Strings
- Using Braces to Limit Problems
- Preventing Interpolation
- Using Unicode Characters
- Avoiding Redefinition
- Avoiding Reserved Words
- Learning More
- Finding Facts
- Calling Functions in Manifests
- Using Variables in Resources
- Defining Attributes with a Hash
- Declaring Multiple Resource Titles
- Declaring Multiple Resource Bodies
- Modifying with Operators
- Adding to Arrays and Hashes
- Removing from Arrays and Hashes
- Order of Operations
- Using Comparison Operators
- Evaluating Conditional Expressions
- Matching Regular Expressions
- Building Lambda Blocks
- Looping Through Iterations
- each()
- reverse_each()
- step()
- filter()
- map()
- reduce()
- slice()
- with()
- Capturing Extra Parameters
- Iteration Wrap-Up
- each()
- Reviewing Puppet Configuration Language
- Defining Variables
- 6. Controlling Resource Processing
- Adding Aliases
- Specifying an Alias by Title
- Adding an Alias Metaparameter
- Preventing Action
- Auditing Changes
- Defining Log Level
- Filtering with Tags
- Skipping Tags
- Limiting to a Schedule
- Utilizing periodmatch
- Avoiding Dependency Failures
- Declaring Resource Defaults
- Reviewing Resource Processing
- Adding Aliases
- 7. Expressing Relationships
- Managing Dependencies
- Referring to Resources
- Ordering Resources
- Assuming Implicit Dependencies
- Triggering Refresh Events
- Chaining Resources with Arrows
- Processing with Collectors
- Understanding Puppet Ordering
- Debugging Dependency Cycles
- Avoiding the Root User Trap
- Utilizing Stages
- Reviewing Resource Relationships
- 8. Upgrading Puppet 3 Manifests
- Replacing Deprecated Features
- Junking the Ruby DSL
- Upgrading Config Environments
- Removing Node Inheritence
- Disabling puppet kick
- Qualifying Relative Class Names
- Losing the Search Function
- Replacing Import
- Documenting Modules with Puppet Strings
- Installing the Tagmail Report Processor
- Querying PuppetDB
- Preparing for the Upgrade
- Validating Variable Names
- Quoting Strings
- Preventing Numeric Assignment
- File mode is not Numeric
- Testing Boolean Facts
- Qualifying Defined Types
- Adding Declarative Permissions
- Removing Cron Purge
- Replacing MSI Package Provider
- Adjusting Networking Facts
- Testing with the Future Parser
- Using Directory Environments
- Duplicating a Master or Node
- Enhancing Older Manifests
- Adding else to unless
- Calling Functions in Strings
- Matching String Regexps
- Letting Expressions Stand Alone
- Chaining Assignments
- Chaining Expressions with a Semicolon
- Using Hash and Array Literals
- Configuring Error Reporting
- Replacing Deprecated Features
- 9. Wrap-Up of Puppet Basics
- Best Practices for Writing Manifests
- Learning More About Puppet Manifests
- II. Creating Puppet Modules
- 10. Creating a Test Environment
- Verifying the Production Environment
- Creating the Test Environment
- Changing the Base Module Path
- Skipping Ahead
- 11. Separating Data from Code
- Introducing Hiera
- Creating Hiera Backends
- Hiera Data in YAML
- Hiera Data in JSON
- Puppet Variable and Function Lookup
- Configuring Hiera
- Backends
- Backend Configuration
- Logger
- Hierarchy
- Merge Strategy
- Complete Example
- Looking Up Hiera Data
- Checking Hiera Values from the Command Line
- Performing Hiera Lookups in a Manifest
- Testing Merge Strategy
- Providing Global Data
- 12. Using Modules
- Finding Modules
- Puppet Forge
- Public GitHub Repositories
- Internal Repositories
- Evaluating Module Quality
- Puppet Supported
- Puppet Approved
- Quality Score
- Community Rating
- Installing Modules
- Installing from a Puppet Forge
- Installing from GitHub
- Testing a Single Module
- Defining Config with Hiera
- Assigning Modules to Nodes
- Using Hiera for Module Assignment
- Assigning Classes to Every Node
- Altering the Class List per Node
- Avoiding Node Assignments in Manifests
- Upgrading from Puppet 2 or 3
- Examining a Module
- Reviewing Modules
- Finding Modules
- 13. Designing a Custom Module
- Choosing a Module Name
- Avoiding Reserved Names
- Generating a Module Skeleton
- Modifying the Default Skeleton
- Understanding Module Structure
- Installing the Module
- Creating a Class Manifest
- What Is a Class?
- Declaring Class Resources
- Accepting Input
- Sharing Files
- Testing File Synchronization
- Synchronizing Directories
- Parsing Templates
- Common Syntax
- Using Puppet EPP Templates
- Providing parameters
- Iterating over values with EPP
- Learning more about EPP
- Using Ruby ERB Templates
- Accessing Puppet variables with ERB
- Iterating over values with ERB
- Learning more about ERB
- Creating Readable Templates
- Testing the Module
- Peeking Beneath the Hood
- Best Practices for Module Design
- Reviewing Custom Modules
- Choosing a Module Name
- 14. Improving the Module
- Validating Input with Data Types
- Valid Types
- Validating Values
- Testing Values
- Comparing Strings with Regular Expressions
- Matching a Regular Expression
- Revising the Module
- Looking Up Input from Hiera
- Naming Parameters Keys Correctly
- Using Array and Hash Merges
- Understanding Lookup Merge
- Specifying Merge Strategy in Data
- Replacing Direct Hiera Calls
- Building Subclasses
- Creating New Resource Types
- Understanding Variable Scope
- Using Out-of-Scope Variables
- Understanding Top Scope
- Understanding Node Scope
- Understanding Parent Scope
- Tracking Resource Defaults Scope
- Avoiding Resource Default Bleed
- Redefining Variables
- Calling Other Modules
- Sourcing a Common Dependency
- Using a Different Module
- Ordering Dependencies
- Depending on Entire Classes
- Placing Dependencies Within Optional Classes
- Notifying Dependencies from Dynamic Resources
- Solving Unknown Resource Dependencies
- Containing Classes
- Creating Reusable Modules
- Avoiding Fixed Values in Attribute Values
- Ensuring Fixed Values for Resource Names
- Defining Defaults in a Params Manifest
- Best Practices for Module Improvements
- Reviewing Module Improvements
- Validating Input with Data Types
- 15. Extending Modules with Plugins
- Adding Custom Facts
- External Facts
- Structured data
- Programs
- Facts on Windows
- Custom (Ruby) Facts
- Avoiding delay
- Confining facts
- Ordering by precedence
- Aggregating results
- Debugging
- Understanding Implementation Issues
- External Facts
- Defining Functions
- Puppet Functions
- Ruby Functions
- Accepting varied input with dispatch
- Accessing facts and values
- Calling other functions
- Sending back errors
- Learning more about functions
- Using Custom Functions
- Creating Puppet Types
- Defining Ensurable
- Accepting Params and Properties
- Validating Input Values
- Defining Implicit Dependencies
- Learning More About Puppet Types
- Adding New Providers
- Determining Provider Suitability
- Assigning a Default Provider
- Defining Commands for Use
- Ensure the Resource State
- Adjusting Properties
- Providing a List of Instances
- Taking Advantage of Caching
- Learning More About Puppet Providers
- Identifying New Features
- Binding Data Providers in Modules
- Using Data from a Function
- Using Data from Hiera
- Performing Lookup Queries
- Requirements for Module Plugins
- Reviewing Module Plugins
- Adding Custom Facts
- 16. Documenting Modules
- Learning Markdown
- Writing a Good README
- Documenting the Classes and Types
- Installing YARD and Puppet Strings
- Fixing the Headers
- Listing Parameters
- Documenting Variable References
- Showing Examples
- Listing Authors and Copyright
- Documenting Functions
- Generating Documentation
- Updating Module Metadata
- Identifying the License
- Promoting the Project
- Indicating Compatibility
- Defining Requirements
- Listing Dependencies
- Identifying a Module Data Source
- Updating Old Metadata
- Maintaining the Change Log
- Evolving and Improving
- Best Practices for Documenting Modules
- 17. Testing Modules
- Installing Dependencies
- Installing Ruby
- Adding Beaker
- Bundling Dependencies
- Preparing Your Module
- Defining Fixtures
- Defining RSpec Unit Tests
- Defining the Main Class
- Passing Valid Parameters
- Failing Invalid Parameters
- Testing File Creation
- Validating Class Inclusion
- Using Facts in Tests
- Using Hiera Input
- Defining Parent Class Parameters
- Testing Functions
- Adding an Agent Class
- Testing Other Types
- Creating Acceptance Tests
- Installing Ruby for System Tests
- Defining the Nodeset
- Configuring the Test Environment
- Creating an Acceptance Test
- Running Acceptance Tests
- Running tests on all nodes
- Troubleshooting Beaker failures
- Accessing a Beaker host console
- Doing more with Beaker
- Using Skeletons with Testing Features
- Finding Documentation
- Reviewing Testing Modules
- Installing Dependencies
- 18. Publishing Modules
- Updating the Module Metadata
- Packaging a Module
- Uploading a Module to the Puppet Forge
- Publishing a Module on GitHub
- Automating Module Publishing
- Getting Approved Status from Puppet Labs
- III. Using a Puppet Server
- 19. Preparing for a Puppet Server
- Understanding the Catalog Builder
- Node
- Agent
- Server
- Planning for Puppet Server
- The Server Is Not the Node
- The Node Is Not the Server
- Store Server Data Files Separately
- Functions Run on the Server
- Choosing Puppet Master Versus Puppet Server
- Upgrading Easily with Puppet Master
- Embracing the Future with Puppet Server
- Why Theres Really No Choice
- Ensuring a High-Performance Server
- Understanding the Catalog Builder
- 20. Creating a Puppet Master
- Starting the puppetmaster VM
- Installing the Puppet Master
- Configuring a Firewall for the Puppet Master
- Running the WEBrick Server
- Testing with the Puppet Master Service
- Scaling the Puppet Master with Passenger
- Installing Apache
- Installing Phusion Passenger
- Configuring the Puppet Master
- IPv6 Dual-Stack Puppet Master
- Debugging Puppet Master
- 21. Creating a Puppet Server
- Starting the puppetserver VM
- Installing Puppet Server
- Configuring a Firewall for Puppet Server
- Configuring Puppet Server
- Defining Server Paths
- Enabling use of /var filesystem
- Limiting Memory Usage
- Configuring TLS Certificates
- Avoiding Obsolete Settings
- Configuring Server Logs
- Configuring Server Authentication
- Understanding authorization rules
- Controlling authorization for Puppet 3 agents
- Defining Server Paths
- Running Puppet Server
- Adding Ruby Gems
- IPv6 Dual-Stack Puppet Server
- 22. Connecting a Node
- Creating a Key Pair
- Authorizing the Node
- Downloading the First Catalog
- Installing Hiera Data and Modules
- Testing with a Client Node
- Learning More About Puppet Server
- 23. Migrating an Existing Puppet Master
- Migrating the Puppet Master Config
- Synchronizing All Environments
- Copying Hiera Data
- Moving the MCollective Config Directory
- Removing Node Inheritance
- Testing a Client Node
- Upgrading Clients
- 24. Utilizing Advantages of a Puppet Server
- Using Server Data in Your Manifests
- Trusted Facts
- Server Facts
- Server Configuration Settings
- Backing Up Files Changed on Nodes
- Processing Puppet Node Reports
- Enabling Transmission of Reports
- Running Audit Inspections
- Storing Node Reports
- Logging Node Reports
- Transmitting Node Reports via HTTP
- Transmitting Node Reports to PuppetDB
- Emailing Node Reports
- Creating a Custom Report Processor
- Using Server Data in Your Manifests
- 25. Managing TLS Certificates
- Reviewing Node Authentication
- Autosigning Agent Certificates
- Name-Based Autosigning
- Policy-Based Autosigning
- Adding Custom Data to CSRs
- Inspecting CSRs
- Using Extension Requests in Puppet
- Naive Autosigning
- Using an External Certificate Authority
- Distributing Certificates Manually
- Installing Certificates on the Server
- Disabling CA on a Puppet Server
- Disabling CA on a Puppet Master
- Using Different CAs for Servers and Agents
- Distributing the CA Revocation List
- Learning More About TLS Authentication
- 26. Growing Your Puppet Deployment
- Using a Node Terminus
- Running an External Node Classifier
- Querying LDAP
- Starting with Community Examples
- Deploying Puppet Servers at Scale
- Keeping Distinct Domains
- Sharing a Single Puppet CA
- Using a Load Balancer
- Managing Geographically Dispersed Servers
- Managing Geographically Dispersed Nodes
- Falling Back to Cached Catalogs
- Making the Right Choice
- Best Practices for Puppet Servers
- Reviewing Puppet Servers
- Using a Node Terminus
- IV. Integrating Puppet
- 27. Tracking Puppet Status with Dashboards
- Using Puppet Dashboard
- Installing Dashboard Dependencies
- Starting the dashboard VM
- Preparing the database
- Ensuring dependencies
- Installing Apache for Puppet Dashboard
- Installing Passenger for Puppet Dashboard
- Configuring Firewall for Puppet Dashboard
- Enabling the Puppet agent on Puppet Dashboard
- Enabling Puppet Dashboard
- Installing Puppet Dashboard
- Configuring Puppet Dashboard
- Defining the Puppet Dashboard schema
- Connecting Puppet Dashboard to Puppet Server
- Enabling the Dashboard Rails service
- Viewing the dashboard
- Sending node reports to the dashboard
- Enabling worker processes
- Viewing node status
- Viewing nodes by status
- Reviewing a nodes history
- Analyzing a nodes run report
- Finding node failures
- Identifying out-of-sync nodes
- Using Dashboard as a Node Classifier
- Setting the environment for a node
- Adding classes to the dashboard
- Creating node groups
- Installing the node classifier
- Testing class and parameter assignment
- Querying the dashboards ENC
- Implementing Dashboard in Production
- Eliminating certificate errors
- Optimizing the database
- Pruning old reports
- Rotating logs
- Ensuring a high-performance dashboard
- Sizing the dashboard database
- Installing Dashboard Dependencies
- Evaluating Alternative Dashboards
- Puppetboard
- Puppet Explorer
- PanoPuppet
- ENC Dashboard
- Foreman
- Upgrading to the Enterprise Console
- Viewing Status
- Classifying Nodes
- Inspecting Events
- Tracking Changes
- Controlling Access
- Evaluating Puppet Enterprise
- Finding Plugins and Tools
- Using Puppet Dashboard
- 28. Running the Puppet Agent on Windows
- Creating a Windows Virtual Machine
- Creating a VirtualBox Windows VM
- Adding an Internal Network Adapter
- Connecting the Windows Installation Media
- Configuring the Internal Network Adapter
- Installing Puppet on Windows
- Configuring Puppet on Windows
- Running Puppet Interactively
- Starting the Puppet Service
- Debugging Puppet Problems
- Writing Manifests for Windows
- Finding Windows-Specific Modules
- Concluding Thoughts on Puppet Windows
- Creating a Windows Virtual Machine
- 29. Customizing Environments
- Understanding Environment Isolation
- Enabling Directory Environments
- Assigning Environments to Nodes
- Configuring an Environment
- Choosing a Manifest Path
- Utilizing Hiera Hierarchies
- Binding Data Providers in Environments
- Querying Data from a Function
- Querying Data from Hiera
- Strategizing How to Use Environments
- Promoting Change Through Layers
- Solving One-Off Problems Using Environments
- Supporting Diverse Teams with Environments
- Managing Environments with r10k
- Listing Modules in the Puppetfile
- Creating a Control Repository
- Configuring r10k Sources
- Adding New Environments
- Populating a New Installation
- Updating a Single Environment
- Replicating Hiera Data
- Invalidating the Environment Cache
- Restarting JRuby When Updating Plugins
- Reviewing Environments
- 30. Controlling Puppet with MCollective
- Configuring MCollective
- Enabling the Puppet Labs Repository
- Installing the MCollective Module
- Generating Passwords
- Configuring Hiera for MCollective
- Enabling the Middleware
- Connecting MCollective Servers
- Validating the Installation
- Creating Another Client
- Installing MCollective Agents and Clients
- Sharing Facts with Puppet
- Pulling the Puppet Strings
- Viewing Node Inventory
- Checking Puppet Status
- Disabling the Puppet Agent
- Invoking Ad Hoc Puppet Runs
- Limiting Targets with Filters
- Providing a List of Targets
- Limiting Concurrency
- Manipulating Puppet Resource Types
- Restricting which resources can be controlled
- Block MCollective from Puppet resources
- Comparing to Puppet Application Orchestration
- Learning More About MCollective
- Configuring MCollective
- 31. Managing Network Infrastructure with Puppet
- Managing Network Devices with Puppet Device
- Enabling SSH on the Switch
- Configuring the Puppet Proxy Agent
- Installing the Device_Hiera Module
- Defining Resource Defaults in Hiera
- Centralizing VLAN Configuration
- Applying Default Configs to Interfaces
- Customizing Interface Configurations
- Testing Out the Switch Configuration
- Adding Resource Types and Providers
- Merging Defaults with Other Resources
- Using the NetDev Standard Library
- Finding NetDev Vendor Extensions
- Creating a NetDev Device Object
- Reducing Duplication with Device_Hiera
- Puppetizing Cisco Nexus Switches
- Configuring the Puppet Server
- Preparing the NX-OS Device
- Installing the NX-OS Puppet Agent
- Enabling the NX-OS Puppet Agent
- Managing Configuration
- Puppetizing Juniper Devices
- Supported Devices
- Installing Modules on the Puppet Server
- Preparing the Junos Device
- Installing the Junos Puppet Agent
- Creating the Puppet User
- Adjusting Physical Interface Settings
- Simplifying Layer-2 VLANs
- Enabling Link Aggregation
- Defining Ad Hoc Configuration Parameters
- Distributing Junos Event Scripts
- Running Puppet Automatically
- Troubleshooting
- Best Practices for Network Devices
- Reviewing Network Devices
- Managing Network Devices with Puppet Device
- 32. Assimilating Puppet Best Practices
- Managing Change
- Expecting Change
- Controlling Rate of Change
- Tracking Change
- Choosing Puppet Apply Versus Puppet Server
- Benefits of Puppet Apply
- Benefits of Puppet Server
- Benefits Shared
- Summarizing the Differences
- Creating a Private Puppet Forge
- Pulp
- Puppet Forge Server
- Django Forge
- Good Practices
- Indenting Heredoc
- Splaying Puppet Agent Cron Jobs
- Cleaning Puppet Reports
- Trimming the File Bucket
- Drinking the Magic Monkey Juice
- Hating on Params.pp
- Disabling Environments
- Tracking Providers
- Breaking the Rules
- Working Good, Fast, Cheap
- Choosing Fight or Flight
- Letting the Strings Pull You
- Leveraging Puppet for Small Changes
- Tossing Declarative to the Wind
- Allowing Anyone to sudo puppet
- Managing Change
- 33. Finding Support Resources
- Accessing Community Support
- Engaging Puppet Labs Support
- Contacting the Author
- Afterword
- Some Best Practices May Not Work for You
- Learning to Fail is the Secret to Success
- A. Installing Puppet on Other Platforms
- Debian and Ubuntu
- Fedora
- Other Platforms
- B. Configuring Firewalls on Other Platforms
- IP Tables
- Uncomplicated Firewall
- C. Installing Ruby
- Ruby for Mac
- Ruby for Windows
- Ruby for Linux
- Index