Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
IT Automation and Configuration Management with Puppet
Rating: 3.6 out of 5(12 ratings)
185 students

IT Automation and Configuration Management with Puppet

Control your IT infrastructure effectively and become a Configuration Management master with the power and flexibility o
Created byPackt Publishing
Last updated 2/2019
English

What you'll learn

  • Implement consistent configuration across all the servers whether Windows or Linux
  • Learn to configure Puppet Master & Puppet Agent, create Puppet programs - manifests.
  • Configure Windows and Linux systems & manage configurations for any of your applications.
  • Minimize configuration mistakes & downtime with Puppet to overcome problems when using scripts.
  • Build an automated application infrastructure by defining Puppet resources, modules, and classes
  • Deploy Puppet agents and servers in a public cloud environment so that you can quickly see the results of your Puppet code
  • Create Puppet classes and modules to apply your automation and multiple servers in parallel
  • Capture unique configuration for each system using Facter and Hiera so your Puppet code can be more modular and reusable

Course content

3 sections • 103 lectures • 11h 51m total length

  • The Course Overview3:00

    This video gives an overview of the entire course.

  • Why Hiera?5:48

    What do we mean by configuration data? There will be lots of pieces of information in your manifests which we can regard as configuration data. Let’ see them in detail.

       •  Take a look at why data needs to be maintained

       •  See the settings that depend on nodes and operating systems that differ

       •  Set up Hiera

  • Adding Hiera Data to Your Puppet repo3:17

    Let’ see how to use Hiera to store and query configuration Data.

       •  Troubleshoot Hiera

       •  Query Hiera

  • Types of Hiera Data2:54

    In this video, we'll look at how to write Hiera data sources, including string, array, and hash data Structures.

       •  Take a look at Single values, Boolean values

       •  Learn about Arrays and Hashes

  • Interpolation in Hiera Data2:55

    Now, we’ll see how to interpolate values into Hiera strings using lookup(), including Puppet facts and other Hiera data, and how to duplicate Hiera data structures using alias().

       •  Use lookup()

       •  Use alias()

       •  Use literal()

  • The Hierarchy6:11

    So far, we've only used a single Hiera data source. Actually, you can have as many data sources as you like. Each usually corresponds to a YAML file, and they are listed in the hierarchy section of the hiera.yaml file.

       •  Deal with multiple values

       •  See merge behaviors

       •  Take a look at Data sources based on facts

  • Creating Resources with Hiera Data4:22

    We've seen how to use Hiera data to fill in the title and attributes of resources in the manifest. We can now take this idea one step further and create resources directly from Hiera queries.

       •  Build resources from Hiera arrays

       •  Build resources from Hiera hashes

  • Managing Secret Data9:05

    Puppet often needs to know your secrets; for example, passwords, private keys, and other credentials need to be configured on the node, and Puppet must have access to this information. Let’s see how to do that.

       •  Set up GnuPG

       •  Add an encrypted Hiera source

       •  Create and edit an encrypted secret

  • Using Puppet Forge Modules6:37

    Although you could write your own manifests for everything you want to manage, you can save yourself a lot of time and effort by using public Puppet modules wherever possible.

       •  See Puppet Forge

       •  Use the r10k module management tool

  • Using Modules in Your Manifests9:28

    Now that we know how to find and install public Puppet modules, let's see how to use them.

       •  Use puppetlabs/mysql

       •  Use puppetlabs/apache

       •  Use puppet/archive

  • Exploring the Standard Library6:26

    One of the oldest-established Puppet Forge modules is puppetlabs/stdlib, the official Puppet standard library. Let's look more closely now and see what the standard library provides and where you might use it.

       •  Safely installing packages with ensure_packages

       •  Modify files in place with file_line

       •  See some other useful functions

  • Writing Your Own Modules10:20

    As we've seen, a Puppet module is a way of grouping together a set of related code and resources that performs some particular task, like managing the Apache web server or dealing with archive files. But how do you actually create a module?

       •  Create a repo and write module code

       •  Create and validate the module metadata

       •  Install and apply your module

  • Classes7:20

    We've come across the class concept a few times so far, without really explaining it. Let's explore a little further now and see how to use this key Puppet language building block.

       •  Learn about the class keyword

       •  Declare parameters to classes

       •  See parameter data types

  • Defined Resource Types4:00

    Whereas a class lets you group together related resources, a defined resource type lets you create new kinds of resources and declare as many instances of them as you like.

       •  Look at defined resource type definition

       •  Define type aliases

  • Managing Classes with Hiera3:49

    Let’s see how to use the classes array in Hiera to include common classes on all nodes, and other classes only on particular nodes.

       •  Use include with lookup()

       •  Take a look at common and per-node classes

  • Roles and Profiles5:13

    Now that we know how to include different sets of classes on a given node, depending on the job the node is supposed to do, let's think more about how to name those classes in the most helpful way.

       •  Create a class called role::app_server

       •  Rewrite the app_server role to include profiles

  • What Are Templates?2:22

    The methods we’ve learnt so far are very useful, but they are limited in one respect: they can only use static text, rather than building the contents of the file dynamically. Let’s see how we can do that with templates.

       •  See the dynamic data problem

       •  Take a look at Puppet template syntax

  • Using Templates in Your Manifests5:59

    Since the end result of a template is a file, you won't be surprised that we use Puppet's file resource to work with templates. In fact, we use an attribute of the file resource that you've seen before: the content attribute.

       •  Reference template files

       •  See computations in templates

       •  See conditional statements in templates

  • Iteration in Templates8:34

    If we can generate parts of a file from Puppet expressions, and also include or exclude parts of the file depending on conditions, could we generate parts of the file with a Puppet loop?

       •  That is to say, could we iterate over an array or hash, generating template content for each element?

       •  Iterate over Facter data and structured facts

       •  Iterate over Hiera data and work with templates

       •  Pass parameters to templates and render templates on the command line

  • Understanding Containers and Deployment with Docker3:03

    Although the technology behind containers is at least thirty years old, it's only in the last few years that containers have really taken off. This is largely thanks to the rise of Docker, a software platform which makes it easier to create and manage containers.

       •  Take a look at the deployment problem

       •  Build Docker containers

  • Managing Docker with Puppet5:56

    Puppet can certainly install and manage the Docker service for you, just as it can any other software, but it can also do a lot more.

       •  Install Docker

       •  Run multiple instances of container

  • Managing Docker Images5:27

    Of course, it's very useful to be able to download and run public images from Docker Hub or other registries, but to unlock the real power of Docker we need to be able to build and manage our own images too.

       •  Build images from Dockerfiles

       •  Manage Dockerfiles

  • Building Dynamic Containers3:41

    Although Dockerfiles are a fairly powerful and flexible way of building containers, they are only static text files, and very often you will need to pass information into the container to tell it what to do. We might call such containers—whose configuration is flexible and based on data available at build time—dynamic containers.

       •  Configure containers

  • Persistent Storage for Containers4:52

    There are two ways of persisting data in a container: the first is to mount a directory from the host machine inside the container, known as a host-mounted volume, and the second is to use what's called a Docker volume. We'll look at both of these in this video.

       •  See Host-mounted volumes

       •  Take a look at Docker volumes

  • Networking and Orchestration4:25

    We started off the section by saying that containers are completely self-contained, and have no access to each other, even if they're running on the same host. But to run real applications, we need containers to communicate. Fortunately, there is a way to do this: the Docker network.

       •  Learn container orchestration

  • Running Puppet Inside Containers3:10

    If a container can contain a whole operating system, such as Ubuntu, you might be wondering: "can't I just run Puppet inside the container?" Let’s find out.

       •  Configure containers with Puppet

  • Introducing the Cloud4:12

    Before exploring the advantages of cloud computing, perhaps we should define what it is. In the pre-cloud days, if you needed computing power, you bought an actual, physical computer.

       •  But from the customer's point of view, we don't necessarily want a computer: we just want to compute.

       •  Automate cloud provisioning

       •  Use CloudFormation and Terraform

  • Setting Up an Amazon AWS Account4:05

    Let’s see how to set up a new account and get the credentials you need to start building infrastructure with Puppet.

       •  Create an AWS account

       •  Create IAM policy and user

       •  Store AWS credentials

  • Getting Ready to Use puppetlabs/aws3:05

    In this video, we'll see how to generate an SSH key pair to connect to your EC2 instances, and also install the puppetlabs/aws module with its dependencies.

       •  Create a key pair

       •  Install the puppetlabs/aws module

       •  Installing the AWS SDK gem

  • Creating EC2 Instances with Puppet9:38

    Although you can manage many different types of AWS resources with Puppet, the most important is the EC2 instance. In this video, we'll see how to create your first EC2 instance.

       •  Choose an Amazon Machine Image (AMI)

       •  Create the EC2 instance

       •  Access your EC2 instance

  • Managing Custom VPCs and Subnets7:10

    In the previous video, we used the pre-existing default VPC and subnet to create our instance. In production you'll want to use a dedicated VPC for your Puppet-managed resources, to keep it separate from any other resources. You could, for example, have a staging VPC and a production VPC.

       •  Create an instance in a custom VPC

       •  See other AWS resource types

  • Provisioning AWS Resources from Hiera Data4:47

    There's nothing wrong with managing AWS resources directly in the code, as we've done previously, but we can do just a little bit better. Let’s see how.

       •  Iterate over Hiera data to create resources

       •  Clean up unused resources

  • Getting the Demo repo16:24

    It's now time to see how all the ideas from the previous sections fit together. It should be helpful for you to see how a complete Puppet infrastructure works, and you can also use this repo as a basis for your own projects.

       •  Copy the repo

       •  Understand the demo repo

  • Adapting the repo for Your Own Use2:59

    You will need to change some of the data and settings in the demo repo to be able to use it yourself. Let’s see how to do that.

       •  Configure users

       •  Add per-node data files and role classes

       •  Modify the bootstrap credentials

  • Bootstrapping a New Node3:12

    If you'd like to try out the demo repo on a Vagrant box, there is a suitable Vagrantfile included within the repo directory.

       •  Bootstrap a Vagrant VM

       •  Bootstrap physical or cloud nodes

       •  Use other distributions and providers

Requirements

  • Taking up this Course doesn't need you to be an expert with Puppet. A System Administrator or a DevOps professional with basic knowledge of Windows, Linux or the Linux command line, who installs and configures an IT infrastructure across a network as well as manages their configurations and automates infrastructure, will feel perfectly comfortable in understanding the topics presented.

Description

Video Learning Path Overview

A Learning Path is a specially tailored course that brings together two or more different topics that lead you to achieve an end goal. Much thought goes into the selection of the assets for a Learning Path, and this is done through a complete understanding of the requirements to achieve a goal.

It's no surprise that the need to automate common activities has become the major requirement in many large organizations. Automation provides faster deployments and fewer failures, improves security, and reduces costs for your organization. Puppet is an ideal tool for automating IT infrastructure and Configuration Management in your organization and this course will show you how.

In this well thought out Learning Path, you'll go from beginner to confident Puppet user with a series of clear, practical examples to help you manage every aspect of your server setup. You’ll learn to implement consistent configuration across every server and deploy applications to multiple servers.

Moving further, you’ll get hands-on with managing your IT infrastructure the Puppet 5 platform. You’ll build a custom software installation and configuration to match your application infrastructure. Explore the latest features of Puppet 5 by executing, testing, and deploying Puppet across your systems in no time.

By the end of this Course, you’ll be able to control your IT infrastructure effectively and become a Configuration Management master with the power and flexibility of Puppet 5.0.

Key Features

  • Develop the skills to run Puppet 5, the latest version of this stable and mature technology, without hiccups.

  • Get easy solutions to ensure the correct server configuration (Windows or Linux server).

  • Use Puppet with hands-on examples to build a reliable & secure automated infrastructure and create your own Puppet code.

Author Bios

  • John Arundel is a DevOps consultant, which means he helps people build world-class web operations teams and infrastructures and has fun doing it. He was formerly a senior operations engineer at global telco Verizon, designing resilient, high-performance infrastructures for major corporations such as Ford, McDonald's, and Bank of America. He is now an independent consultant, working closely with selected clients to deliver web-scale performance and enterprise-grade resilience on a startup budget. He likes writing books, especially about Puppet (Puppet 2.7 Cookbook and Puppet 3 Cookbook are available from Packt). He also provides training and coaching on Puppet and DevOps, which, it turns out, is far harder than simply doing the work himself. Off the clock, he is a medal-winning, competitive rifle and pistol shooter and a decidedly uncompetitive piano player. He lives in a small cottage in Cornwall, England and believes, like Cicero, that, if you have a garden and a library, then you have everything you need. You may like to follow him on Twitter at @bitfield.

  • Abdul Basit Alvi is a certified professional with expertise in open source cloud systems and mobile core networks. He has over 3 years of experience in deploying and managing open source cloud systems and using puppet for configuration management and deployment of large scale cloud systems such as OpenStack. He also has experience in using configuration management tools such as Ansible and Puppet for Orchestration and Automation of various virtual network functions in mobile core networks.

  • Alan Hohn is a Software Architect who primarily works in Java, Go, and Python. He has a lot of experience re-architecting embedded systems and in combining embedded and enterprise approaches. Currently, he works as a Lockheed Martin Fellow encouraging the adoption of virtualization, DevOps, and cloud technologies. This also means that he frequently tries out new technologies and new approaches. He enjoys teaching on technical topics and enjoys hearing from those who find his courses useful. He is employed by Lockheed Martin Rotary and Mission Systems and his personal blog is called Variegated.

Who this course is for:

  • DevOps Professionals, System Administrators or Developers, those who are looking to implement a configuration management system in their organization that automates all their IT configurations and software deployment for Windows and Linux (configure an IT infrastructure across a network) will find this course useful. They may or may not have used Puppet prior to this course, but it’s an added advantage if they have some prior experience with the Linux command line. Customers should be familiar with Windows or Linux.

Report abuse