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.
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.
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.
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:
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.
Ansible needs to know all of the hosts that it can connect to and manage. In this lecture, we will cover:
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:
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:
It's time to execute Ansible against our environment hosts. In this lecture, we will:
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:
With our playbook written, it's time to execute it and review the output. In this lecture, we will:
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.
We start our configuration with installing the necessary packages for each tier. In this lecture, we will:
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:
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:
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:
Test your knowledge on Ansible variables
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.
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.