Intro to Ansible

Administering and configuring infrastructure is a necessary but sometimes very difficult undertaking. Manual configuration of infrastructure is a full time job that takes away from other valuable activities that is prone to errors and difficulties in reproducing system state. Ansible allows one to create plans for managing infrastructure using an agentless (no outside system required) approach. During this show we will cover what Ansible is, how to set up Ansible, and use Ansible to create reproducible server configurations.

In this episode, Daniel and Justin explore the configuration management tool Ansible. Moreover, Justin demonstrates how to setup Vagrant and Virtualbox in order to simulate collections of servers to be administered by Ansible.

In this episode, Daniel and Justin work to install and set up Ansible on a control machine. Justin further discusses the requirements of Ansible in order appropriately control the other machines which includes setting up ssh access to other machines, copying identities, and ensuring that Python is available on the other machines.

In this episode, Daniel and Justin demonstrate the use of Ansible to run some simple ad-hoc commands against other servers. Moreover, Justin demonstrates the use of a hosts file and modifying some of the Ansible configuration to manage multiple environments from the same control machine.

In this episode, Daniel and Justin demonstrate installing packages through the Ansible command line interface. Justin highlights some of the modules that may be necessary in order to manage packages for a given host.

In this episode, Daniel and Justin return to further explore installing packages as well as highlighting some of the "gotchas" that can crop up when installing packages using Ansible.

In this episode, Daniel and Justin start working with users on remote nodes using Ansible. Justin demonstrates creating users, creating groups, and adding users to groups.

In this episode, Daniel and Justin take a look at managing system services. Justin demonstrates how to enable and disable a service as well as start, restart, reload, and stop a services as well as describe the nuanced differences among those actions.

In this episode, Ronnie and Justin dive into more command line commands such as uptime, preparing systems for administration, or querying aspects of a system. Justin highlights the nuances among the raw, command, and shell modules when using each one.

In this episode, Ronnie and Justin start creating Ansible playbooks that allow clearer and more reproducible configurations when managing resources with Ansible. Particularly, Justin takes a look some of the basic organization of a playbook based Ansible commands.

In this episode, Ronnie and Justin take a look at creating a list of actions to take when creating a playbook called tasks. Justin further explains how to add tasks as well as considerations when creating a list of tasks.

In this episode, Ronnie and Justin continue building out Ansible playbooks using some configuration settings or additional information that is necessary to configure a respective node, otherwise known as variables. Justin demonstrates several ways to provide variables to the Ansible playbook.

In this episode, Zach and Justin continue building out Ansible playbooks using some configuration settings or additional information that is necessary to configure a respective node, otherwise known as variables. Justin demonstrates the usage of variable files, interactive prompts, and passing variables through the command line interface.

In this episode, Zach and Justin dive into the use of handlers for reacting to events during the processing of an Ansible playbook. Justin demonstrates the creation of handlers as a response to tasks throughout the playbook such as installing an application that needs to be started or reloaded because configuration has changed.

In this episode, Zach and Justin explore using templated files to configure services that are part of your configuration. Justin explores the use of output of variables as a way to template files for configuration purpose using the basic of the Jinja2 templating language.

In this episode, Zach and Justin continue their exploration of Jinja2 templating language as a way to template configurations using Ansible. Specifically, Justin demonstrates the use of iteration, if-else conditions, as well as utilizing the templating tools with different data structures available in Ansible.

In this episode, Zach and Justin take a look at iteration in the context of a playbook. Justin demonstrates the use of iteration in completing tasks such as installing a set of packages as well as illustrates edge cases when using loops and variables in the context of a playbook.

In this episode, Cherokee and Justin look at adding some decision making capabilities within an Ansible playbook. Justin demonstrates the use of decisions to apply changes using the when attribute based on conditions of the different nodes (i.e. Debian vs RedHat).

In this episode, Daniel and Justin take a look at organization of playbooks into a role based arrangement. Justin explains the use of roles as a way of segmenting the individual pieces of a configuration in order to be reused.

In this episode, Daniel and Justin explore the creation of tasks using a role based arrangement. Justin further clarifies how Ansible determines what tasks to run when including a role.

In this episode, Daniel and Justin explore the use of handlers when creating roles. Justin demonstrates the use of handlers within a role.

In this episode, Daniel and Justin explore the use of the when statement during the use of roles. Justin illustrates the differences in roles when the individual systems have differing requirements.

In this episode, Daniel and Justin take a look at using templates with roles. Justin demonstrates the use of templates in roles by templating an NGINX configuration.

In this episode, Daniel and Justin continue seeing their exploration of NGINX using static files. Justin explores the use of files internal to an Ansible role as well as external to the role and provides a comparison between the two approaches.

In this episode, Vonne and Justin review the requirements that have been set forth for a deployment. Justin discusses the thought process for creating a plan for deployment and describes why one should use configuration management and version control instead of manual configuration.

In this episode, Zach and Justin set up the Ansible project that will manage the static site deployment. Additionally, Justin gets nginx up and running on the server utilizing ansible playbooks.

In this episode, Daniel and Justin use templating to manage the configuration for serving a site using NGINX.

In this episode, Daniel and Justin reorganize the previous playbook as a role in order to provide reuse. Justin demonstrates the use of the dynamic aspects of Ansible in order to make a static site deployment tool.

In this episode, Cherokee and Justin explore the architecture for creating an NFS server and associated clients. Justin diagrams and discusses some of the hidden complexities that can crop up when creating Ansible playbooks.

In this episode, Cherokee and Justin create the playbook responsible for creating the NFS server. Additionally, Justin discusses some of the shortcomings of need client information during the configuration of another host.

In this episode, Cherokee and Justin create the playbook responsible for creating the NFS clients.

In this episode, Cherokee and Justin revisit the playbook that set up the nfs server in order to extract that into a role based solution. Justin demonstrates the picking apart of the originally created playbook to create the nfs-server role.

In this episode, Cherokee and Justin revisit the nfs client playbook in order to extract that playbook into a role based solution.