This video gives an overview of the entire course.

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

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

• Troubleshoot Hiera
• Query Hiera

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

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()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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