Build your own Manageable Puppet Infrastructure
4.3 (155 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,390 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Build your own Manageable Puppet Infrastructure to your Wishlist.

Add to Wishlist

Build your own Manageable Puppet Infrastructure

Build your own production-ready Puppet Master and a workflow with code-review. Includes Hiera, Roles&Profiles, R10K etc.
4.3 (155 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,390 students enrolled
Created by Ger Apeldoorn
Last updated 7/2016
English
Price: $75
30-Day Money-Back Guarantee
Includes:
  • 7 hours on-demand video
  • 1 Article
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Setup and use your production-ready Manageable Puppet infrastructure
  • Setup and use Hiera-eyaml for secure data seperation
  • Setup and use R10k for environment management
  • Setup and use Gitlab for version control and layered code-review
  • Use git-flow and code-review to let other colleagues contribute
View Curriculum
Requirements
  • Intermediate Puppet knowledge
  • Basic Linux knowledge
  • 3 (virtual) Linux servers
Description

Installing Puppet is easy. Designing an infrastructure that you're still be happy with in 2 years requires lots of experience.

The Manageable Puppet Infrastructure is a very flexible design that has been field-tested in many companies, varying from very small to very large. The author of this course did talks about the MPI and related subjects at PuppetConf 2014 and 2015, PuppetCamps, FOSDEM and other conferences.

This course is a very practical guide on howto setup your Puppet infrastructure, while teaching you how it works and why.

Please note that this course REQUIRES pre-existing Puppet knowledge. This is advanced-level stuff, the basics are not explained in this course due to time-constraints.

The end-result of following this course is a fully functional, production-ready Manageable Puppet Infrastructure!

Who is the target audience?
  • Sysadmins that want to setup a production-ready Puppet Infrastructure.
  • Please note that this course REQUIRES pre-existing Puppet knowledge. This is advanced-level stuff, the basics are not explained in this course due to time-constraints.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
103 Lectures
07:04:58
+
What will we build during this course?
3 Lectures 07:06

Introducing this course!

Preview 03:31

Welcome to my course!
00:26

We'll get a small demo of the end-result if you follow the steps in this course.

Preview 03:09
+
Prerequisites and preparation
3 Lectures 02:54

In this lecture we will discuss what you need to get started with this course. 

Preview 01:13

Prerequisites for the VM's
00:12

There are several options available to use as a puppetmaster:

  • Puppet Enterprise
  • Satellite server
  • Katello
  • Foreman
  • A lean and mean puppetmaster 

What are the pro's and con's? Which option is best for you?

Choose your PuppetMaster version
01:29

A few Questions
2 questions
+
Installing Puppet
2 Lectures 06:08

In this lecture we will install the Puppet repositories and install the agent and the server.

Install Puppet agent and Master
02:48

We will configure our agent and do an initial puppetrun.

Preview 03:20

A few questions
3 questions
+
Creating a temporary development environment
6 Lectures 16:56

We set up a temporary development environment in order to do some initial setup and talk about where Puppet looks for modules on the filesystem.

Creating the temporary environment
03:51

Where are those modules?
3 questions

Now that we have created a temporary environment, let's see if it actually works!

Testing a Puppetrun in our new temp environment
01:08

The Puppetforge has many modules available; how can we distinguish the great ones from the awful ones?

Install some modules from the PuppetForge to configure the Puppet Master.

Selecting and installing modules from the Puppet Forge
05:35

Configuring the Puppetmaster using Forge modules.

Putting the new modules to work: Setup the Puppet Master and install PuppetDB
03:01

We have configured the PuppetDB with a module, now let's see if it works!

Preview 01:54

PuppetDB Questions
3 questions

It's nice that the puppetserver process listens to a port, but if the outside world cannot reach it....

Let's open up that firewall.

Later in the course we will update our profile to do this properly.

Open port 8140 in the firewall to accept connections
01:27
+
Setup Vagrant
6 Lectures 15:18

What type of machine will we setup for testing? There are multiple options, as long as we can break them whenever we feel like it.

What to use for testing?
01:38

In this course, we're going to use Vagrant boxes for testing machines.

Setting up Vagrant
01:02

You can easily generate a Vagrant file. To save you some time, I have already prepared one.

Get a Vagrantfile
04:35

We don't want to create new certificates anytime we start afresh with our Vagrant boxes. Therefore, let's generate, sign and save some certificates!

Setup puppet certificates for Vagrant
02:21

Let's see where we are so far!

Recap part one: What have we done on the master?
02:17

Recap part two: How did we setup our testclient?
03:25
+
Introduction to Roles and Profiles
3 Lectures 13:57

Roles and Profiles are a widely used design pattern that is extremely helpful in your Puppet environment. Here is an overview!

Preview 04:12

Allright, now that we know what they are, why do we want to use 'em?

Why do we want to use Roles and Profiles?
02:07

Initial setup of Roles and Profiles in our temporary environment
07:38

Just a few questions on Roles and Profiles.

Roles and profiles quiz
4 questions
+
Setting up Version control and Code-review
7 Lectures 22:14

Version control is essential for any type of code, not only Puppet. Using code review is also very helpful, but not for the obvious reasons.

Why do we want to use Version Control and Code review?
03:57

Which options we have available for web-based Version Control?
03:21

Let's use the clear instructions on the site to install GitLab CE.

Installing Gitlab CE: Copy/Paste FTW!
02:05

The last step of installing gitlab is reconfiguring it.

Installing Gitlab CE: Reconfiguring
01:05


Adding the Profile module to the Git repository
03:28

Adding the Profile module to the Git repository and add Role as well
05:09

A question about Git and modules
1 question
+
Setting up R10K
9 Lectures 28:52

What is R10K? We will take a close look at how R10K can help you manage your environments.

R10k introduction
02:17

In this lecture we will create our control Repository. R10K needs this to manage our puppet environments.

R10K creating the control repository
03:15

R10K manages our environments, but it needs to know which modules you want. For this, we are going to create the Puppetfile.

Creating the Puppetfile
02:27

Installing R10K is pretty simple. However, we want to make it reproducible, so we will use a module for this task. 

Installing R10k with a Puppet module
05:51

Now that we have set up R10K, we can do a test run to deploy our first environment.

Initial R10K run
03:42

Working with different branches is a lot easier if we can see which branch we are on at all times. For this, we will install a Bash plugin. 

Working with GIT branches: add a convenient GIT bash prompt
02:55

We need to create several environments to make sure that we can properly test our code before we put it into production. R10K will help us to manage those environments

This lesson explains the different environments we will create and their users.

Preview 03:08

We will create two new branches, based on the master branch. We will call this integration and testing so that R10K will create environments with the same name. 

Creating the integration and testing branches (and environments)
02:56

Often we have many people that contribute code to Puppet and only a few who fully understand the entire infrastructure.

We want to make sure that only the people that are allowed to push pop of color all the way up to production can update the corresponding branches of the control Repository.

To achieve this, we can protect the new branches of our Git Repository.

Protecting branches (and environments)
02:21

Let's see what you have learned about R10k... :)

R10k questions
3 questions
+
Setting up a personal playground environment
11 Lectures 35:33

In this lecture we will install a script to easily create development environments.

Installing a script to create personal playground environments
02:38

What does the script do?

Explaining the script
01:40

It is very difficult to make multiple Puppet developers use Git in the same way, unless you have very good guidelines. Git flow is such a set of guidelines, in this lecture we will get introduced to it.

Git flow introduction
02:33

Unfortunately, there is no package for the git-flow subcommand (git flow) in the Yum repositories. We will install git flow manually. 

Installing the Git flow subcommand
01:15

We will need to provide access to the Git repositories. For this, we will create a private and public key that we will authorize in the Gitlab web interface

After that has been taken care of, we can run the script and set up our personal playground environment.

Providing access to the git repos and running the script
03:44

There are a few steps required after setting up the dev-environment, like setting up git-flow for the control repo.

Creating the dev environment: Post configuration
02:03

The Puppet Master needs access to the development environment we just created.

A complication is that the development environment is in the home directory of each developer. 

Giving the Puppet master access to the dev environment
03:42

Create a new symlinks after each ‘r10k deploy environment’ command is not very practical. Therefore, we will install a script that does this for us automatically.

Automate the creation of symbolic links with a script
06:08

We are dealing with several GIT repos.

It's very hard to keep track of what repos have uncommitted changes, so let's install a script that can help out.

Downloading the checkrepos script
04:32

Introduction to module release numbers and how to use them in the Puppetfile.

Fixing the mystery of the not-updated profile module.
05:31

Create an initial release of the role module and use it.
01:47
+
Selecting and using Forge modules
1 Lecture 07:10

The Puppetforge is an extremely valuable resource. We will take a look at how to separate the good modules from the awful ones and why you do want to use these modules instead of writing everything yourself.

A closer look at the Puppetforge
07:10
12 More Sections
About the Instructor
Ger Apeldoorn
4.3 Average rating
251 Reviews
3,144 Students
2 Courses
Freelance Puppet consultant/trainer

Ger is a Freelance Puppet consultant and teaches the official courses for Puppet in the Netherlands.

He just loves to explain stuff, both in the classroom and over the internet.

As a consultant, he has helped many companies to implement Puppet, both Open Source and Puppet Enterprise. Ger has done many talks about Puppet Infrastructure related topics at PuppetConf, PuppetCamps, FOSDEM and other conferences.