Ultimate Ansible Bootcamp by School of Devops®

Master the theory of Ansible, then set up a standardized environment with Docker or cloud. Follow the lab guide, watch demonstrations, and complete nano projects and quizzes.

Prepare for the Red Hat certified specialist in Ansible automation exam with a practical environment, covering inventories, modules, variables, facts, playbooks, templates, vault, and Ansible Galaxy.

Develop self-paced troubleshooting skills by interpreting logs and solving errors, then seek help in the guitar channel and community channels for timely answers and updates.

Explore why we need Ansible as a unified automation tool that replaces multiple remote management, configuration, and deployment tasks across diverse infrastructures and cloud environments, embracing infrastructure as code.

Discover how ansible delivers simplicity through yaml, a secure agentless push model, and extensible custom modules in any language.

Explore Ansible's batteries included approach, using 2000+ modules to manage users, groups, packages, services, cloud provisioning, networks, and more, all built into core with extras maintained by the community.

Learn how infrastructure as code uses a declarative syntax to define the desired state, contrast with scripts, and see how Ansible translates plans into versioned, testable infrastructure.

Discover how Ansible separates code and data to create generic templates and environment-specific configurations, enabling reusable rules shared via Ansible Galaxy for scalable deployments.

Explore idempotence as the property where repeated actions converge on the same outcome. See how Ansible compares current state and desired state and applies changes only on drift with playbooks.

Trace the story of Ansible from its founder Michael Dehghan, through its simple python-based, agentless design that boosted its use in provisioning open stack and open shift.

Set up an efficient, consistent Ansible environment with one controller and four nodes using the in-house Let's Spaces tool, covering authentication and environment preparation for hands-on sessions.

Explore how Codespaces enables a lightweight, integrated learning environment with a single control node and multiple managed nodes using Docker, virtual machines, and automated setup scripts.

Learn to set up a docker-based codespaces environment locally on macOS or Linux, clone the repo, install docker, and run docker compose up to deploy six nodes with Ansible controller.

Launch codespaces on DigitalOcean cloud by provisioning an Ubuntu 16.04 server with 2 GB RAM and a user data script to run the environment.

Learn to operate a Docker-backed integrated environment with an ed workspace, browse files, edit code, and manage the Ansible controller and nodes using start, stop, and recreate commands.

Explore ansible primitives like playbooks, inventories, roles, and tasks to automate infrastructure, and design the ansible score repository structure from a real use case.

Apply Ansible to define infrastructure as code by mapping tasks to modules, building roles for each application, and configuring web servers, templates, services, and deployments across three tiers.

Define an inventory of servers and group them by category, mapping each group to applicable rules. Use playbooks to orchestrate configurations across databases, web servers, and applications with Ansible.

Learn best practices for writing Ansible playbooks, including modular code with roles and data driven configurations using templates, plus multi-environment management and zero downtime deployment.

Explore code organization strategies for Ansible, comparing directory layouts, where to place playbooks, variables, and inventories, including environment-specific production and staging environments, and recommending a project-scoped ansible.cfg.

Write Ansible playbooks to install, configure, and deploy a three-tier web application with a load balancer, app servers, and a MySQL database, enabling environment-specific configurations and zero-downtime updates.

Design and organize an Ansible driven devops demo by creating environment-specific inventories, groups, and rules; structure playbooks and roles, map nodes to configurations, and maintain project-specific ansible.cfg.

Set up your Ansible environment, create an environment-specific inventory with servers and connection parameters, and begin exploring host patterns and ad hoc modules.

Learn to locate and customize Ansible configuration, override defaults with a project-specific ansible.cfg, understand precedence from home to command line, and validate with ansible-config.

Define custom inventories with hosts and groups, set connection parameters and host variables, and validate static or dynamic inventories in environment-specific setups using ini or yaml formats.

Explore host patterns in Ansible, including all, wildcard, grouping, exclusion, ranges, and regular expressions. Learn to run ad hoc commands with the raw module.

Learn how Ansible modules enable desired state configuration through a declarative language, mapping to system entities with a batteries included, out-of-the-box library of thousands of modules across categories.

Invoke Ansible modules from the command line and playbooks, and explore module options, mandatory fields, and idempotence. See how repeated runs report no changes when the state is already met.

Explore common Ansible modules for packages, file management, and system tasks, including group and user creation and file copy, with practical, cross-host examples.

Explore how command modules and shell interactions execute tasks on managed nodes, compare command versus shell, and apply idempotent practices such as the creates option to skip existing files.

Master the ansible-console repl shell to run modules across inventories, using -B for privileged access and pattern filtering to target hosts, executing commands like uptime and package installs in parallel.

Transform your node management from ad hoc to infrastructure as code by learning Ansible playbooks, YAML basics, and how to write and invoke plays for system configurations.

Master YAML essentials for Ansible, including lists, dictionaries, indentation, and block scalars. See how declarative shopping lists translate into YAML to define desired state.

Explore how an Ansible playbook organizes hosts, tasks, and modules into sequenced plays, using variables, become methods, and descriptive tasks for self-documenting infrastructure as code.

Develop a first Ansible playbook to configure linux servers by creating admin user with a uid, removing a user, and installing tree and other packages using modules.

Validate and apply your Ansible playbook with the playbook utility, running syntax checks and reviewing tasks, hosts, and tags before converging the system state and validating on production.

Learn how to extend an Ansible playbook by adding a service start task, verify syntax, speed up runs by disabling gather_facts, and troubleshoot failures with limit and retry file.

Add a new play for observers to the existing playbook, creating a user named Let's Deploy and installing the gate package, with a start-at-task and an observer limit.

Design an Ansible playbook to deploy a static HTML site on the load balancer, adding the engine X repository, installing engine X, and deploying from a git source.

Learn to simplify complex playbooks with rules, build a modular library of code, and create and invoke tasks, notifications, and handlers following best practices.

Explore how breaking tasks into roles reduces playbook complexity, improves environment flexibility, and enables reusable, modular configurations for applications like Apache.

Explore the anatomy of an Ansible role, from core tasks and modules to defaults, files, and templates, then see how handlers, tests, and metadata shape each application-specific role.

Discover best practices for organizing Ansible code with layered inventory groups, per-application roles, and modular plays. Structure plays, roles, and tags for scalable, maintainable infrastructure deployments.

Learn how to create and scaffold Ansible roles using Ansible Galaxy, explore its repository of open-source, user-contributed roles, and generate complete role scaffolds with Galaxy commands.

Create an ansible role for apache using galaxy scaffold, install the package, manage the service, copy configuration, and structure tasks with import_tasks for app servers.

Write and apply an Ansible playbook to provision app servers using the Apache role, install packages, start the service, verify status, and validate web server readiness.

Learn to copy configuration files from the files directory to target nodes with the Ansible copy module, and trigger service restarts via handlers when configurations change.

Create a PSP role in the same playbook, scaffold it with Ansible Galaxy, install two packages using a loop, restart the service, and validate PSP on the app servers.

Learn to create a systems rule and a site playbook in Ansible, and use nested rules and dependencies to automatically invoke linux system configuration from other roles.

Deploy the PSP application in a nano project by creating an ansible role, applying best practices and dependencies, and targeting the current release for deployment.

Learn to make Ansible rules dynamic and reusable by mastering conflicts and variables, exploring the templating engine, and applying variable precedence across environments using Ansible Galaxy.

Learn how to separate data from code using templates and variables to create dynamic configurations across environments, with runtime variable injection.

Learn how Jinja2 templates power dynamic configuration in Ansible with variables, context, and Python functions, and how template tags and .j2 extensions compile to Python bytecode at runtime.

Master Ansible variables and facts, and understand precedence rules for configuring applications and system properties across hosts. Learn to access and define variables in defaults, groups, hosts, inventories, and playbooks.

Explore advanced variables in Ansible, including valid variable naming, how to define and reference variables in inventories and playbooks, and how facts, caching, and scopes affect templates.

Define the application version as a single variable in the default file and reference it across tasks to deploy the correct version automatically, including department-specific releases.

Learn to manage application configurations in Ansible by defining variables, creating templates, and processing them to dynamically generate config files, then apply and verify updates on the app.

Learn how Ansible variable precedence drives dynamic configuration by merging dictionaries, with hash behavior set to merge, from defaults, group vars, host vars, and playbooks.

Discover how registered variables in Ansible enable conditional execution by using the task output and return codes to decide which tasks run.

Use the Ansible setup module to gather facts, display them at command line, and filter results by properties like ansible host or memory fields for use in tasks and templates.

Discover how to reuse rules from Ansible Galaxy by selecting, applying, and customizing them with variables to save time through infrastructure as code.

Explore Ansible Galaxy to browse, filter, and rate roles, then evaluate updates, contributors, compatibility, and licensing before installing and using a selected role with variables.

Select and customize an HAProxy role by assessing galaxy rules, inspecting role variables, dependencies, templates, and handlers, then tailor backend servers and playbooks for your environment.

Install and apply a HAProxy role from Ansible Galaxy, customize properties in a playbook, validate the proxy service, and prepare for troubleshooting to route traffic to backend servers.

Troubleshoot haproxy by inspecting load balancer configurations, defining backend servers and health checks, applying the Ansible playbook, and enabling proxy socket configuration to manage backend servers dynamically.

Deploy a MySQL database backend using an Ansible Galaxy rule, configure secure root access, create Tabatha's Demo and user developes, and apply the playbook to the DB group in production.

Configure a MySQL database using an Ansible Galaxy role, creating a database and user and setting root password in a production playbook. Validate by starting the service and checking database.

Connect the application server to the database by overriding configuration parameters with the correct connection string, database host, user, and password using Ansible templates.

Move additional rules into a dedicated galaxy rules folder with a role path configuration, and align site-wide configuration to enable distribution of playbooks and proxies.

Explore how to tag tasks, roles, plays, and playbooks in Ansible, list and filter by tags, and understand inheritance and tagging of import playbooks.