Ansible Full Course | Zero to Hero

Video summary (Ansible course: key technical concepts + demos)

1) Course roadmap + big picture of Ansible

The instructor (Rahul) previews a chapter-based curriculum and notes that timestamps will be provided.

What Ansible is: an open-source automation tool focused on three main tasks:

1. Automate software installation across servers
2. Manage server configuration (create/update/delete configuration)
3. Deploy applications (including web apps) and automate deployment steps

2) Hands-on intro: manual setup vs Ansible Playbook automation

• Demonstrates installing on a remote Linux server using SSH + one-by-one shell commands (manual approach).
• Then replaces the same workflow with a minimal Ansible Playbook that installs:
  • Python
  • Creates a directory
  • Installs and starts Apache2

Key implementation detail shown

• Playbook run uses an inventory/host file to identify target host(s).
• Task output highlights:
  • “changed” counts (e.g., “3 changed”)
  • failures in red if errors occur

Verification after execution

• ls confirms directory creation
• python3 --version confirms Python installed
• systemctl status apache2 confirms Apache running (green status)

3) “Agentless” architecture

Explains the agentless model:

• Ansible is installed on the developer/local machine
• It connects to remote servers using SSH
• Remote execution happens without installing Ansible agents on servers

4) Installing Ansible locally (Windows/Linux/macOS)

• Windows: install WSL and Ubuntu (recommends Ubuntu LTS)
• Installs Ansible on:
  • Ubuntu/Debian (APT): uses apt repositories then apt install ansible
  • CentOS (YUM): yum install ... and verifies via ansible --version
  • macOS: uses Homebrew (brew install ansible)

5) Ansible project structure (inventory, roles, tasks, main playbook)

Typical structure covered:

• inventory/host file: lists host IP/domain(s)
• roles/: each role contains task definitions
• Main playbook (e.g., VM setup playbook.yml)

Core concepts

• Playbook includes:
  • hosts (e.g., all)
  • remote_user (SSH username)
  • roles (e.g., python)
• Roles contain a main.yml inside role tasks

Execution command highlights

• ansible-playbook
• -i inventory/<hostfile>
• playbook name

6) SSH key management for Ansible

Demonstrates:

• Creating an SSH key pair (private key + public key)
• Copying the public key to the remote server using ssh-copy-id
• Referencing the private key in the inventory host file via ansible_ssh_private_key_file

Then re-runs the playbook to prove connectivity and task execution (e.g., create directory).

7) Writing YAML for Ansible Playbooks (.yml)

Focuses on:

• Indentation rules and YAML syntax basics
• List item pattern: task keys align by indentation

Example shown using the file module:

• path
• state: directory (or removal if state differs)

Explains how indentation defines parent/child relationships in tasks.

8) Ansible Handlers (notify/handler pattern)

Explains why handlers are used:

• A dependent action must happen only if a prior task changed

Example workflow:

1. Install Nginx/Apache
2. Copy/update index.html
3. Restart service only when content changes

Demonstrates:

• notify: restart engine server from a task
• handler definition using handlers: and service: state: restarted
• playbook output showing the handler triggers only when relevant updates occur

9) Variables deep dive

Covers variable types and usage:

• Data types: strings, booleans, lists, dictionaries
• List indexing: access by index (e.g., 0 for first item)
• Dictionary access: retrieve values by key (e.g., apple, banana)
• Nested dictionaries: chained indexing/expressions
• register variables: capture command/module results into a variable
• Jinja2 filters:
  • extract dict keys and convert to uppercase (| list, | upper)

Other variable mechanisms:

• External vars files: vars_files: my_vars.yml
• Runtime variables: --extra-vars "version=1.0" and variable precedence

Emphasizes variable precedence:

• runtime --extra-vars overrides vars defined elsewhere (including vars files)

10) Environment variables in Ansible (environment:)

Shows two scopes:

• Playbook-level environment vars: accessible across tasks
• Task-level environment vars: scoped only to that task

Includes output to confirm which environment variables are visible where.

11) Conditionals / control flow (when, multiple conditions, facts)

Explains:

• Ansible uses when: (not if)
• Boolean flags decide whether tasks run or are skipped

Supports:

• Multiple conditions in one when
• and operator on one line
• Conditions based on:
  • registered outputs (stdout / stdout_lines)
  • ansible_facts (e.g., OS family and version checks)

Also demonstrates loops + conditionals:

• iterate over a list, but only execute when each item matches when

Shows tasks being skipped vs changed based on conditions.

12) Roles and tasks (including importing subtasks)

Shows role structure:

• roles/<role_name>/tasks/main.yml

Roles can contain multiple tasks:

• one role installs packages + config + starts service

Role composition:

• a role’s main.yml can import subtasks like packages.yml and messages.yml

Includes verification of task order when running the role-import playbook.

13) Jinja2 templates (.j2) for dynamic configuration

Covers:

• Create a template file ending with .j2
• Use interpolation with {{ variable }}

Uses templates in playbooks via template::

• src template file
• vars: to pass values into the template

Real demo:

• Deploy a lightweight httpd/web server
• Replace config values (e.g., port) using a template
• Re-run playbook with different port values (e.g., 80 → 9090)

Key benefit:

• dynamic server configuration without rewriting playbooks

14) Deployment strategies: single server, multi-server, blue/green

Strategies are categorized into:

• Single-server deployment
• Multi-server deployment with limiting
• Blue/green deployment

Blue/green details:

• blue = passive/non-serving set (target during release)
• green = active/serving set

Uses Ansible --limit to target only the required group:

• deploy to “blue”
• later deploy/switch to “green” by changing the limit target

15) Error handling

Demonstrates task-level flags:

• ignore_errors: true
  • if a task fails (e.g., missing file), Ansible continues to other hosts/tasks
• any_errors_fatal: true
  • force playbook failure when certain errors occur

Uses failed_when:

• register copy results
• check error message and failure status

Mentions changed_when:

• control whether a task reports “changed” (example: file creation and checking rc == 0)

16) Ansible Vault for secret encryption

Covers:

• ansible-vault create
• ansible-vault edit
• ansible-vault view
• password changes: ansible-vault rekey

How to run playbooks with Vault secrets (3 ways):

1. Prompt for password: --ask-vault-pass
2. Use Vault password file: --vault-password-file
3. Export password-file path into an environment variable and run without prompts

Demo:

• Encrypt a secret in my vault.yml
• show encrypted content can’t be read without a password
• use decrypted values in playbook via variable referencing

17) Real-world project: Ansible deployment of a static blog (J-hook.com)

Describes a production workflow:

• The blog is a static site (Markdown + HTML pages), no database
• Uses Hugo to generate the site locally
• Ansible deploys to SiteGround hosting over SSH using keys

Automated deployment steps

1. Run Hugo to generate HTML into public/
2. Zip the public/ directory
3. Upload the zip to the remote server
4. Extract the zip on the server
5. Remove the zip afterward

Verification and operational detail

• Uses SiteGround cache purge (“flush cache”) so updates appear
• Confirms updated page content (e.g., “last modified” date changes, question mark removed)

SSH key setup

• Private key kept locally
• Public key installed on SiteGround via SSH key manager / import

---

Main speaker / source

• Rahul (instructor; repeated as “this is Rahul” in multiple segments)