Mastering Ansible
4.3 (1,721 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.
8,781 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Mastering Ansible to your Wishlist.

Add to Wishlist

Mastering Ansible

A complete guide to configuration management and orchestration with Ansible.
Bestselling
4.3 (1,721 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.
8,781 students enrolled
Created by Chris Lunsford
Last updated 12/2015
English
English
Current price: $10 Original price: $55 Discount: 82% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 5 hours on-demand video
  • 1 Article
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Execute ad-hoc commands against servers using Ansible
  • Write Ansible configuration playbooks to deploy a 3-tier web application
  • Configure Ansible roles with tasks, handlers, files, templates, and default variables
  • Write operational playbooks to check cluster status and perform a cluster restart.
  • Optimize Ansible playbooks to reduce playbook execution time.
  • Test and troubleshoot Ansible playbook execution.
View Curriculum
Requirements
  • You should have a Linux or Mac OS X computer, or access to at lease one Linux virtual machine for installing Ansible.
  • You'll need a code editor or IDE of your choice.
  • You'll need a terminal and ssh client for running Ansible against target hosts.
  • You should have access to 5 Linux servers (bare-metal or virtual machine) if you want to setup the course environment and follow along step-by-step.
Description

Mastering Ansible is a step-by-step journey of learning Ansible for configuration management and orchestration.

The course is designed as a journey through configuring a realistic application stack from the ground up. Instead of going page-by-page through the Ansible documentation, topics are ordered to align with the growing complexity of our application as we build it up and refactor it.

In addition to the core concepts of configuration with Ansible, we spend time on building tools to help us maintain and troubleshoot our application. The goal is to have a workflow where all of the configuration and troubleshooting is done through ansible playbooks that can be committed to a repository and improved over time.

The course is divided into 6 sections, starting with initial installation and foundational concepts. Starting in section 3, we build up a sample application environment layer-by-layer, learning a new concept in each lecture. After the application is up and running, we refactor our setup in section 4 with an emphasis on modularity and encapsulation. In section 5, we optimize our code and learn about techniques to reduce the playbook execution time. The course finishes with a final section on troubleshooting and testing.

For each lecture, we introduce a new Ansible concept and apply it to our playbooks. For most lectures, we execute the new concept in the demo environment so you can see what the output should look like. In the notes of each lecture, you'll find a link to the relevant documentation pages, along with a snapshot of the codebase at the end of that lecture.

This course was built with Ansible version 1.9.3, applied to a 3-tiered web application environment leveraging NGINX, Apache2, Python, and MySQL on Ubuntu Linux servers. We do not cover administering Windows servers in this course.

This course is designed as an introduction to Ansible, but also as a guide for engineers interested in configuration management, orchestration, infrastructure-as-code, and devops principles.

Who is the target audience?
  • The course is designed for students who have little or no experience with Ansible, but are familiar with Linux systems administration concepts.
  • No programming or previous automation experience is required.
  • If you've never logged into a Linux shell and run commands before, you will learn the Ansible syntax but you may not understand the 'why' behind the tasks that we configure. We try to explain all systems concept that we cover, but we aren't starting from the beginning with Linux in this course.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
55 Lectures
04:48:39
+
Introduction
2 Lectures 08:42

Welcome to Mastering Ansible! This lecture covers the course goals and format. The course is divided into 6 sections, starting with Environment Setup and Foundational Concepts. For the bulk of the course, we configure a realistic 3-tier web application, refactor it, and then optimize it. We finish the course with a section on testing and troubleshooting. Prior linux systems administration experience is expected.

Preview 02:49

Understand broad automation concepts: configuration management and orchestration. Configuration management is concerned with getting a single server into a desired state. Orchestration is focused on executing tasks in a specific order across one or many hosts. Throughout this course, we'll use Ansible to do both.

Configuration Management & Orchestration
05:53
+
Preparation
2 Lectures 08:14

In this course, we will implement a 3-tier web application topology using one (1) NGINX load-balancer, two (2) application nodes running Apache2 and Python, one (1) MySQL database server, and one (1) control machine for running Ansible. If you want to follow along, you can setup an environment that fits these requirements:

  1. Access to a control machine that can run Ansible
  2. Servers running Ubuntu Trusty (14.04) - 5 in total
  3. SSH keypair trusts from the control machine to all other nodes (so no password is required to login via ssh)
  4. Access via a user that has superuser (sudo) privileges on the end hosts


In the Appendix (Lecture 55), I provide details on the docker setup that I use throughout the course.

In the materials below, is a Vagrantfile that can be used to create a similar vagrant setup. Rename "Vagrantfile.txt" to "Vagrantfile" and read the "README" comments inside of the file to get started.

Environment Setup
05:09

The first step in using Ansible is installing Ansible! In this lecture, we will:

  • Install the Ansible tools using a package manager (apt-get for the Ubuntu-based demo environment)
  • Test the installed binaries by checking the version on the command line
Preview 03:05
+
Foundation
6 Lectures 27:36

Ansible needs to know all of the hosts that it can connect to and manage. In this lecture, we will cover:

  • The concept of the inventory file and how Ansible uses it
  • The default Ansible inventory file format and location (/etc/ansible/hosts).
Inventory Pt 1
03:44

We need to populate an inventory file so that Ansible can reach our environment hosts. Rather than populate the default location on the control machine, we can create a simple file in our local repository and tell Ansible to use it, by default. In this lecture, we will:

  • Configure a local inventory file with hostnames and groups (dev)
  • Configure a local config file to use the new inventory file by default (ansible.cfg)
Inventory Pt 2
04:53

Once the inventory is populated, you can tell Ansible to execute against all or some subset of the included hosts. In this lecture, we'll:

  • Use host patterns to target a subset of the full inventory: all, *, <hostname>, <groupname>, :, !
Host Selection
03:45

It's time to execute Ansible against our environment hosts. In this lecture, we will:

  • Learn about the basic building block of Ansible: the task.
  • Understand the structure of tasks: modules and arguments.
  • Execute ad-hoc tasks using the ansible command with the ping and command modules.
Tasks
05:06

Running ad-hoc Ansible commands are great for troubleshooting and discovery, but the real power of Ansible is in coding those tasks into playbooks that you can save and run, as needed. In this lecture, we will:

  • Group tasks for a common set of hosts together into plays.
  • Create our first playbook (hostname.yml) to encode the command task into an Ansible YAML file.
Plays
04:35

With our playbook written, it's time to execute it and review the output. In this lecture, we will:

  • Execute the hostname.yml playbook against hosts using the ansible-playbook command.
  • Review the output of the ansible-playbook command.
Preview 05:33

Foundation Concepts
3 questions
+
Playbooks
16 Lectures 01:30:43

Now that you understand the framework for encoding tasks and executing playbooks, we will start building up our application environment. For every task, we'll find a relevant module and add the necessary parameters to our playbooks. You can browse the module documentation if you're looking for the right module or parameters to fit your needs.

Playbooks Introduction
04:42

We start our configuration with installing the necessary packages for each tier. In this lecture, we will:

  • Install packages with the apt module
  • Set package installed state using one of: present, latest, absent.
  • Ensure the apt cache is updated before package installation with update_cache=yes
Packages: apt
04:33

While executing Ansible tasks, you may run into "permission denied" errors. This generally means the task you're executing requires some sort of superuser or sudo privilege. In this lecture, we will:

  • Enable privilege escalation in Ansible with become/sudo at the play level. This will resolve "permission denied" errors on the end hosts where superuser privileges are required.
  • Execute the configuration playbooks to apply the package installation changes on the load-balancer and database hosts.
Packages: become
04:07

For the webserver hosts, we need to install multiple packages via apt. Rather than create four individual apt tasks, we'll learn about a new Ansible feature: loops using with_items. In this lecture, we will:

  • Loop through a task multiple times by providing a list of inputs using with_items
  • Install multiple packages with a single task on the webserver hosts using with_items
Packages: with_items
05:08

With the packages installed, we want to get a handle on the services we'll need to get up and keep running. In this lecture, we will:

  • Manage running service state with the service module
  • Enable services to start on system startup with enabled=yes
Services: service
06:49

  • Write a support playbook to do a full stack restart using the service module
Support Playbook 1 - Stack Restart
03:08

  • Enable apache2 modules using the apache2_module ansible module.
  • Configure handlers to restart services only when needed.
  • Trigger handlers after configuration changes using notify.
Services: apache2_module, handlers, notify
05:39

  • Copy files and directories from a local machine to a target host
  • Set file attributes on the target host such as owner, group, and file mode
Files: copy
05:54

  • Install python dependencies using the pip module and a requirements.txt file
  • Setup a python virtual environment to host the python web application
Application Modules: pip
03:11

  • Create and remove symbolic links using the file module.
Files: file
05:27

  • Inject variables into files before copying to the target host with the template module.
  • Implement for loops in a jinja2 template.
Files: template
06:31

  • Edit a single line in a file on the target host using regular expressions and the lineinfile module.
Files: lineinfile
06:49

  • Create a mysql database using the mysql_db module.
  • Create a mysql user and set the password and allowed host using the mysql_user module.
Application Modules: mysql_db, mysql_user
04:57

  • Write a support playbook to check the status of the application stack.
  • Check that a host is listening on a specific TCP port and interface using the wait_for module.
Support Playbook 2 - Stack Status: wait_for
09:25

  • Extend the stack status playbook to perform http requests against the application using the uri module.
  • Save the contents of the HTTP request using the register module
  • Check the contents of a variable and conditionally cause a failure using the when and fail modules.
Support Playbook 2 - Stack Status: uri, register, fail, when
11:10

  • Review the progress made on configuring the demo application environment.
Playbooks Summary
03:13

Playbook Concepts
6 questions
+
Modular Configuration with Roles
13 Lectures 01:19:47
  • Understand the purpose and structure of roles in ansible.
  • Use the ansible-galaxy command to create a role skeleton.
Roles Overview
04:41

  • Convert an ansible playbook to a role by copying tasks and handlers.
  • Address ordering issues by moving service tasks after configuration tasks.

Converting to Roles: tasks, handlers
05:02

  • Convert an ansible playbook to a role by copying files and templates.
  • Address ordering issues by moving service tasks after configuration tasks.
Converting to Roles: files, templates
05:50

  • Group multiple playbooks into a single playbook using the include module.
Site.yml: include
02:59

  • Use system facts as variables to configure host-specific values.
  • Query a target host for system facts using the setup module.
Variables: facts
06:09

  • Provide default values for variables defined in a role.
Variables: defaults
05:20

  • Understand variable precedence in ansible.
  • Define variable values using vars.
  • Define variable values when including roles to override role defaults.
Variables: vars
08:20

  • Use a dictionary/hash and with_dict to execute a task multiple times.
Variables: with_dict
07:12

  • Execute a shell command on a target host with the shell module.
  • Capture the output of a shell command with the register module.
  • Loop through the items in a registered array variable using with_items.
  • Conditionally perform an action on the target host using when.
Selective Removal: shell, register, with_items, when
05:45

  • Convert the remaining playbooks to roles.
  • Convert a file to a template to parameterize values and leverage passed variables.
Variables - continued
06:25

  • Define variables in a separate file using group_vars
Variables: vars_files, group_vars
06:34

  • Encrypt variable values using ansible-vault.
  • Configure a vault password file to store the vault passphrase.
  • Add a configuration default to use a vault password file automatically.
Variables: vault
10:49

  • Learn about the ansible public roles repository: galaxy.ansible.com.
  • Understand tradeoffs and considerations of using public roles.
External Roles & Galaxy
04:41

Test your knowledge on Ansible variables

Variables
2 questions
+
Advanced Execution
7 Lectures 31:00

Now that our application is configured, and we've completed the bulk of our refactoring into roles, we will look at ways to optimize our playbooks and speed up our execution time.

Advanced Execution Introduction
02:58

  • Disable fact gathering to speed up execution using gather_facts.
Removing Unnecessary Steps: gather_facts
03:29

  • Increase apt cache timer with the apt module and cache_valid_time.
  • Extract a repeated sequential task and perform it in parallel across all hosts to reduce execution time.
Extracting Repetitive Tasks: cache_valid_time
04:10

  • Limit playbook execution to a subset of hosts without modifying plays
Limiting Execution by Hosts: limit
02:40

  • Add user-defined tags to tasks.
  • Limit playbook execution by including (--tags) or excluding (--skip-tags) defined tags.
Limiting Execution by Tasks: tags
06:37

  • Override ansible's built-in logic to define when a task is marked as changed.
  • Use a python function (.keys()) in an ansible when clause to determine the task will be marked as changed.
Idempotence: changed_when, failed_when
06:23

  • Learn about ansible transport optimizations to reduce execution time and overhead.
  • Learn about when to use accelerated mode and ssh pipelining.
Accelerated Mode and Pipelining
04:43
+
Troubleshooting, Testing, & Validation
5 Lectures 22:08
  • Learn how to resolve ordering problems that cause playbook execution dead-ends
  • Skip problematic tasks using ignore_errors.
Troubleshooting Ordering Problems
05:47

  • Step through tasks one-by-one using --step.
  • Display a list of tasks included in a playbook using --list-tasks.
  • Jump to a task and begin execution at an arbitrary point using --start-at-task.
Jumping to Specific Tasks: list-tasks, step, start-at-task
04:00

  • Use the ansible provided retry host list to re-run a playbook on failed or unreachable hosts.
Retrying Failed Hosts
02:43

  • Validate the syntax of an ansible playbook using --syntax-check.
  • Perform a dry-run (no-op) of an execution against a live host using --check
Syntax-Check & Dry-Run: syntax-check, check
05:20

  • Print a msg or the contents of a variable using the debug module.
Debugging: debug
04:18

Testing Concepts
2 questions
+
Appendix
4 Lectures 20:33
  • Understand SSH public/private key architecture.
  • Learn how to create an RSA keypair.
  • Learn how to setup an SSH trust to login to a host without using a password.
Authentication with SSH Keys
06:47

  • Understand the basics of the YAML format: files, keys/values, hashes, and lists.
A Brief Overview of YAML
06:11

  • Understand the basics of the Jinja2 templating language: variables, templates, and loops
A Brief Overview of Jinja2
05:58

  • Setup a development environment to test ansible using docker-machine and docker-compose.
Dev Environment with Docker
01:37
About the Instructor
Chris Lunsford
4.3 Average rating
1,719 Reviews
8,781 Students
1 Course
Software Founder, Developer, Operations Engineer

I am an IT professional with a decade of experience in network, datacenter, cloud and systems operations. My expertise is in applying software development practices to infrastructure operations.

In the early days of my IT career, I worked at a large networking company administering devices to support Service Providers in the US and Canada. After several years of doing test and validation for SP Core Networks, I worked a project on a recently announced Data Center compute product and got hooked on Data Center technology. I moved on to support Data Center Solutions and became an expert on the full Data Center stack: firewalls, load-balancers, compute, network, storage, and virtualization. The balance of my time at the company was spent building out a major hosted cloud effort based on OpenStack, integrating principles and tools from the emerging DevOps movement.

I left corporate life to co-found a small software company, focused on reducing the pain of being an operations engineer in Cloud and Data Center environments. I teach on Udemy to help transfer my own lessons learned to others who are faced with managing complex server and network environments, and to explore ways to integrate software practice and lean methodologies with IT operations.