Skip to main content
Mapagam

50 SECTIONS · 1449 TOPICS

Ansible Roadmap

  1. Installing and Configuring Ansible

    1. 1. Installing Ansible
    2. Example: Install Ansible using pip
    3. 2. Verifying Installation
    4. Example: Check Ansible version
    5. 3. Understanding ansible.cfg
    6. Example: Basic ansible.cfg
    7. 4. Configuring Default Settings
    8. Example: Setting Default User in ansible.cfg
    9. 5. Setting Up SSH Keys
    10. Example: SSH Key Setup Script
    11. 6. Configuring SSH Connection
    12. Example: SSH Configuration in Inventory
    13. 7. Disabling Host Key Checking
    14. Example: Disabling host key checking in ansible.cfg
    15. 8. Setting Default Inventory
    16. Example: Default Inventory File (hosts.ini)
    17. Example: YAML Inventory File (hosts.yaml)
    18. 9. Configuring Log Path
    19. Example: Setting Log Path in ansible.cfg
    20. 10. Understanding Configuration Precedence

  2. Understanding Ansible Core Concepts

    1. 1. Understanding Control Node
    2. Example: Basic Inventory File
    3. Example: Simple Playbook
    4. 2. Understanding Managed Nodes
    5. Example: Inventory configuration for managed nodes
    6. 3. Understanding Modules
    7. Example: Using the copy module to deploy a config file
    8. Example: Using the shell module to run a command
    9. 4. Understanding Plugins
    10. Example: Using a Custom Filter Plugin
    11. Example: Using the Filter in a Playbook
    12. 5. Understanding Collections
    13. Example: Using a Collection in a Playbook
    14. Key Features of Collections
    15. 6. Understanding Inventory
    16. Example: Basic Inventory File
    17. Example: Using Groups
    18. Inventory Types
    19. 7. Understanding Playbooks
    20. Example: Basic Playbook Structure
    21. 8. Understanding Tasks
    22. Example: Creating a Directory
    23. Example: Conditional Task Execution
    24. Example: Looping Over a List
    25. 9. Understanding Handlers
    26. Example: Restarting a Service
    27. 10. Understanding Facts
    28. Example: Using Facts in a Playbook
    29. 11. Understanding Push vs Pull
    30. Push vs Pull Comparison
    31. 12. Understanding Idempotency
    32. Example: Idempotent Package Installation

  3. Managing Inventory Files

    1. 1. Creating Static Inventory
    2. Example: Using Static Inventory
    3. 2. Creating YAML Inventory
    4. Example: Basic YAML Inventory
    5. Example: Inventory with Variables
    6. 3. Defining Hosts and Groups
    7. Example: Basic Inventory File
    8. Example: Group Inheritance
    9. 4. Using Inventory Patterns
    10. Example: Using host patterns in a playbook
    11. 5. Creating Child Groups
    12. Example: Defining child groups
    13. 6. Listing Inventory Hosts
    14. Example: List all hosts in inventory
    15. Example: Show variables for a specific host
    16. Example: Show variables for a specific group
    17. 7. Graphing Inventory
    18. Example: Visualizing inventory with graphviz
    19. Graphing Inventory Summary
    20. 8. Verifying Inventory
    21. Example: Basic inventory verification
    22. 9. Using Multiple Inventory Sources
    23. Example: Combining Static and Dynamic Inventory
    24. Static vs Dynamic Inventory
    25. 10. Organizing Inventory Directory Structure
    26. Example: Standard Inventory Directory Layout
    27. Best Practices for Inventory Organization

  4. Working with Host and Group Variables

    1. 1. Defining Host Variables
    2. Example: Setting Host Variables in Inventory
    3. Example: Using Host Variables in Playbook
    4. 2. Defining Group Variables
    5. Example: Defining Group Variables in YAML
    6. Example: Defining Group Variables in JSON
    7. 3. Setting Connection Variables
    8. Example: Setting SSH connection variables for a group
    9. Example: Using become with a different user
    10. 4. Using Behavioral Parameters
    11. Example: Setting behavioral parameters in inventory
    12. Example: Using behavioral parameters in group vars
    13. 5. Setting Privilege Escalation
    14. Example: Using become with sudo
    15. 6. Understanding Variable Precedence
    16. Example: Variable Precedence in Playbook
    17. 7. Using all and ungrouped Groups
    18. Example: Defining variables for all hosts
    19. Example: Defining variables for ungrouped hosts
    20. 8. Setting Group Priority
    21. Example: Setting Group Priority in Inventory
    22. 9. Merging Variables
    23. Example: Merging Host and Group Variables
    24. 10. Organizing Variable Files
    25. Example: Directory Structure for Variables
    26. Best Practices

  5. Working with Dynamic Inventory

    1. 1. Understanding Dynamic Inventory
    2. Example: Dynamic Inventory Script
    3. Key Benefits of Dynamic Inventory
    4. 2. Using AWS EC2 Plugin
    5. Example: Basic AWS EC2 Inventory Configuration
    6. Example: Using AWS EC2 with Custom Tags
    7. 3. Using Azure Plugin
    8. Example: Basic Azure Inventory Configuration
    9. Example: Using Environment Variables for Authentication
    10. 4. Using GCP Plugin
    11. Example: GCP Inventory Configuration
    12. 5. Configuring Inventory Plugins
    13. Example: Using the AWS EC2 Inventory Plugin
    14. Example: Using the Azure Inventory Plugin
    15. 6. Setting Plugin Options
    16. Example: Configuring AWS EC2 Plugin with Filters
    17. 7. Caching Inventory Data
    18. Example: Configure caching in
    19. 8. Creating Custom Inventory Scripts
    20. Example: Simple Custom Inventory Script (Python)
    21. Key Points
    22. 9. Using Constructed Inventory
    23. Example: Constructed Inventory Configuration
    24. 10. Testing Dynamic Inventory
    25. Example: Test dynamic inventory script

  6. Running Ad-Hoc Commands

    1. 1. Executing Ad-Hoc Commands
    2. Example: Ping all hosts
    3. Example: List files in /tmp
    4. 2. Using Module Arguments
    5. Example: Running a shell command with arguments
    6. Example: Using copy module with arguments
    7. 3. Specifying Module
    8. Example: Running a command with shell module
    9. Example: Targeting Multiple Groups
    10. Example: Excluding Hosts
    11. 5. Setting Parallelism
    12. Example: Running tasks with limited parallelism
    13. 6. Checking Connectivity
    14. 7. Running Shell Commands
    15. Example: Running a shell command
    16. Example: Running a shell command with arguments
    17. 8. Copying Files
    18. Example: Copying a File
    19. Example: Copying a Directory
    20. 9. Gathering Facts
    21. Example: Gathering Facts with Ad-Hoc Command
    22. Example: Limiting Facts Collection
    23. 10. Managing Packages
    24. Example: Install a package with apt
    25. Example: Install a package with yum
    26. Example: Install a package with dnf
    27. Example: Install a package with pacman
    28. 11. Managing Services
    29. Example: Start and Enable a Service
    30. Example: Stop and Disable a Service
    31. 12. Using Privilege Escalation
    32. Example: Running a command with privilege escalation

  7. Creating Ansible Playbooks

    1. 1. Understanding Playbook Structure
    2. Example: Basic Playbook Structure
    3. 2. Defining Plays
    4. Example: Basic Play Definition
    5. 3. Specifying Target Hosts
    6. Example: Hosts and Groups
    7. Example: Using Inventory File
    8. 4. Setting Remote User
    9. Example: Setting remote user for a task
    10. Example: Using become to switch user
    11. 5. Enabling Privilege Escalation
    12. Example: Using become to run as root
    13. 6. Configuring Become Method
    14. Example: Using become with sudo
    15. 7. Defining Tasks
    16. Example: Installing a Package
    17. Example: Conditional Task Execution
    18. Example: Looping Over a List
    19. 8. Setting Gather Facts
    20. Example: Disabling Fact Gathering
    21. 9. Using Proper YAML Syntax
    22. Example: Basic Playbook Structure
    23. 10. Validating Playbook Syntax
    24. Example: Basic syntax check

  8. Working with Tasks

    1. 1. Defining Task Structure
    2. Example: Basic Task Definition
    3. Example: Task with Loop and Condition
    4. 2. Using Module Arguments
    5. Example: Using
    6. Example: Using
    7. Example: Using
    8. 3. Setting Task State
    9. 4. Registering Task Results
    10. Example: Registering a command result
    11. Example: Registering a file lookup result
    12. 5. Adding Task Conditions
    13. Example: Using when with multiple conditions
    14. 6. Controlling Task Execution
    15. Example: Using when to conditionally execute a task
    16. Example: Using loop to iterate over a list
    17. Example: Using until to retry a task
    18. 7. Ignoring Errors
    19. Example: Using ignore_errors
    20. 8. Delegating Tasks
    21. Example: Delegating a task to a different host
    22. Example: Delegating task and storing facts
    23. 9. Running Tasks Once
    24. Example: Using run_once
    25. Example: Using delegate_to
    26. 10. Setting Task Environment
    27. Example: Setting Environment Variables
    28. Example: Using vars to Set Variables
    29. 11. Adding Task Tags
    30. Example: Applying Tags to a Task
    31. Example: Running Specific Tags
    32. 12. Using Task Timeout
    33. Example: Setting a Task Timeout

  9. Working with Variables

    1. 1. Defining Playbook Variables
    2. Example: Defining Variables in a Playbook
    3. 2. Using Variable Files
    4. Example: vars.yml content
    5. Example: Using vars file in playbook
    6. 3. Setting Host Variables
    7. Example: Setting Host Variables in Inventory
    8. 4. Setting Group Variables
    9. Example: Setting Group Variables in group_vars
    10. Example: Using Group Variables in Playbook
    11. 5. Using Extra Variables
    12. Example: Setting Variables from CLI
    13. Example: Using JSON File for Extra Vars
    14. 6. Registering Variables
    15. Example: Using Registered Variables
    16. 7. Setting Facts
    17. Example: Setting a Fact in a Playbook
    18. 8. Accessing Variables
    19. Example: Accessing Host Variables
    20. Example: Using Facts
    21. Example: Loop with Item Variable
    22. 9. Using Variable Syntax
    23. Example: Using Host Variables
    24. Example: Using Facts
    25. Example: Using Registered Variables
    26. 10. Accessing Nested Variables
    27. Example: Accessing Nested Variables in a Playbook
    28. 11. Understanding Variable Precedence
    29. Example: Variable Precedence in Playbook
    30. 12. Providing Default Values
    31. Example: Setting Default Values in a Playbook

  10. Working with Magic Variables

    1. 1. Using hostvars
    2. Example: Accessing host-specific variables
    3. 2. Using inventory_hostname
    4. Example: Using inventory_hostname in a task
    5. Example: Using inventory_hostname_short in a task
    6. 3. Using inventory_hostname_short
    7. Example: Using inventory_hostname_short in a task
    8. 4. Using group_names
    9. Example: Using group_names in a Playbook
    10. 5. Using groups
    11. Example: Accessing group members
    12. Example: Using group names in conditionals
    13. 6. Using ansible_play_hosts
    14. Example: Looping over all hosts in a play
    15. Example: Check if a host is part of the play
    16. 7. Using ansible_play_batch
    17. Example: Using ansible_play_batch in a Playbook
    18. 8. Using playbook_dir
    19. Example: Reading playbook_dir in a task
    20. 9. Using role_path
    21. Example: Accessing role_path in a task
    22. 10. Using ansible_version
    23. Example: Display Ansible Version

  11. Working with Facts

    1. 1. Gathering Facts
    2. Example: Using gathered facts in a task
    3. 2. Accessing Ansible Facts
    4. Example: Using Facts in a Playbook
    5. Example: Using Facts in a Template
    6. 3. Using Hardware Facts
    7. Example: Using Hardware Facts in a Playbook
    8. 4. Using Network Facts
    9. Example: Gathering Network Facts
    10. Example: Using Interface Facts
    11. 5. Using OS Facts
    12. Example: Using OS Facts in a Playbook
    13. 6. Filtering Facts
    14. Example: Filtering Facts by OS Family
    15. Example: Using Facts to Determine Memory Usage
    16. Example: Filtering by Network Interface
    17. 7. Creating Custom Facts
    18. Example: Setting a Custom Fact in a Playbook
    19. Example: Using Facts in Templates
    20. 8. Caching Facts
    21. Example: Configure Redis caching
    22. 9. Disabling Fact Gathering
    23. Example: Disabling fact gathering for a playbook
    24. 10. Using Local Facts
    25. Example: Setting Local Facts
    26. Example: Reading Local Facts
    27. 11. Refreshing Facts Mid-Playbook
    28. Example: Refreshing Facts Mid-Playbook

  12. Using Conditionals

    1. 1. Using When Statements
    2. Example: Conditional Task Execution
    3. Example: Multiple Conditions
    4. 2. Comparing Variables
    5. Example: Comparing Variables in a Loop
    6. Example: Using 'in' Operator
    7. 3. Checking Variable Existence
    8. Example: Using
    9. Example: Using
    10. 4. Testing Boolean Values
    11. Example: Using Boolean Tests in Conditionals
    12. 5. Using Logical Operators
    13. Example: Combining Conditions with Logical Operators
    14. Example: Complex Condition with Nested Logical Operators
    15. 6. Checking String Content
    16. 7. Using Jinja2 Tests
    17. Example: Using Jinja2 Tests in Conditionals
    18. 8. Evaluating Registered Results
    19. Example: Using Registered Results in Conditionals
    20. 9. Checking File States
    21. Example: Check File State
    22. Example: Delete a File if It Exists
    23. 10. Using Complex Conditionals
    24. Example: Complex conditional in a task
    25. Example: Using variables with complex conditionals
    26. 11. Applying Conditionals to Blocks
    27. Example: Conditional block with loop

  13. Implementing Loops

    1. 1. Using Simple Loops
    2. Example: Looping over a list of files
    3. Example: Using loop with a variable
    4. 2. Looping with Lists
    5. Example: Looping over a list of packages
    6. Example: Using loop_var to access item index
    7. 3. Looping with Dictionaries
    8. Example: Looping Through a Dictionary
    9. Example: Looping Through Dictionary Keys
    10. 4. Using Loop Control
    11. Example: Loop Control with Label
    12. Example: Loop Control with Index
    13. 5. Setting Loop Variable Name
    14. Example: Using loop_var in a task
    15. 6. Adding Loop Labels
    16. Example: Using loop_control.label
    17. 7. Using Loop Index
    18. Example: Using loop.index in a task
    19. Example: Using loop.revindex in a task
    20. 8. Pausing Between Iterations
    21. Example: Pausing Between Loop Iterations
    22. 9. Looping Until Condition
    23. Example: Looping Until a File Exists
    24. Example: Looping Until a Service is Running
    25. 10. Using Legacy Loops
    26. 11. Flattening Nested Lists
    27. Example: Flattening nested lists in a task
    28. Example: Flattening with multiple levels
    29. 12. Using Loop with Conditionals
    30. Example: Loop with Conditional Filter

  14. Working with Jinja2 Templates

    1. 1. Creating Template Files
    2. Example: Basic Template File Creation
    3. Example: Using Variables in Templates
    4. 2. Using Template Module
    5. Example: Basic Template Module Usage
    6. Example: Template with Variables
    7. 3. Accessing Variables
    8. Example: Accessing Host Variables
    9. Example: Using Group Variables
    10. 4. Using Filters
    11. 5. Implementing Conditionals
    12. Example: Using when with variables
    13. Example: Using failed_when to check output
    14. Example: Using changed_when to control task state
    15. 6. Implementing Loops
    16. Example: Looping Over a List
    17. Example: Nested Loops with Index Tracking
    18. 7. Setting Template Variables
    19. Example: Using hostvars in a template
    20. Example: Conditional variable usage
    21. 8. Using Comments
    22. Example: Using Inline Comments in Jinja2
    23. 9. Including Templates
    24. Example: Including a Template
    25. Example: Importing Macros
    26. 10. Using Macros
    27. Example: Defining and Using a Macro
    28. Key Points About Macros
    29. 11. Escaping Variables
    30. Example: Escaping HTML in Templates
    31. 12. Controlling Whitespace
    32. Example: Controlling Whitespace in Templates

  15. Using Jinja2 Filters

    1. 1. Transforming Strings
    2. Example: Using replace filter
    3. 2. Working with Lists
    4. Example: Using join filter
    5. 3. Formatting Data
    6. Example: Using format filter
    7. 4. Providing Defaults
    8. Example: Using default filter
    9. 5. Combining Data
    10. Example: Using combine filter
    11. 6. Selecting Items
    12. Example: Using selectattr filter
    13. 7. Extracting Values
    14. Example: Using map filter
    15. 8. Filtering Unique
    16. Example: Using uniqueby filter
    17. 9. Sorting Data
    18. Example: Using sort filter
    19. 10. Working with IP Addresses
    20. Example: Using ipaddr filter
    21. 11. Hashing Values
    22. Example: Using md5 filter
    23. 12. Manipulating Paths
    24. Example: Using basename filter

  16. Working with Handlers

    1. 1. Defining Handlers
    2. Example: Basic Handler Definition
    3. 2. Notifying Handlers
    4. Example: Notifying a Handler
    5. 3. Executing Handlers Immediately
    6. Example: Notify Handler from Task
    7. Example: Handler Definition
    8. 4. Listening to Topics
    9. Example: Listening to a Topic
    10. 5. Forcing Handler Execution
    11. Example: Using notify to trigger handler
    12. Example: Forcing handler execution with always_run
    13. 6. Controlling Handler Order
    14. Example: Using listen and notify
    15. Handler Execution Rules
    16. 7. Using Handler Names
    17. Example: Using Handler Names
    18. 8. Notifying Multiple Handlers
    19. Example: Notifying Multiple Handlers
    20. 9. Preventing Handler Execution
    21. Example: Using
    22. 10. Importing Handlers
    23. Example: Importing Handlers from a Role
    24. Example: Including Handlers from a File
    25. 11. Including Handlers
    26. Example: Including Handlers from a File

  17. Using Blocks

    1. 1. Defining Blocks
    2. Example: Basic Block Definition
    3. 2. Grouping Tasks
    4. Example: Using Blocks with Loop and Rescue
    5. 3. Implementing Error Handling
    6. Example: Using rescue and always blocks
    7. Error Handling Best Practices
    8. 4. Setting Block Variables
    9. Example: Setting Block Variables
    10. 5. Applying Block Conditions
    11. Example: Using when with block conditions
    12. 6. Using Block Tags
    13. Example: Using block tags in a playbook
    14. 7. Setting Block Delegation
    15. Example: Delegating a block to localhost
    16. 8. Executing Rescue Tasks
    17. Example: Rescue task execution flow
    18. 9. Ensuring Cleanup
    19. Example: Using block with cleanup
    20. Block Execution Flow
    21. 10. Nesting Blocks
    22. Example: Nested Block Usage
    23. 11. Using any_errors_fatal
    24. Example: Using any_errors_fatal at playbook level

  18. Handling Errors

    1. 1. Ignoring Errors
    2. Example: Using ignore_errors
    3. 2. Defining Failure Conditions
    4. Example: Using
    5. Example: Using
    6. 3. Defining Success Conditions
    7. Example: Using
    8. Example: Using
    9. 4. Using Block Error Handling
    10. Example: Basic Block with Rescue
    11. Block Error Handling Summary
    12. 5. Catching Errors
    13. Example: Using rescue and always blocks
    14. 6. Running Cleanup
    15. Example: Cleanup with Ansible
    16. Cleanup Best Practices
    17. 7. Using any_errors_fatal
    18. Example: Using any_errors_fatal in a Playbook
    19. 8. Setting Max Fail Percentage
    20. Example: Setting max_fail_percentage to 25%
    21. 9. Retrying Tasks
    22. Example: Retry configuration
    23. 10. Aborting on First Failure
    24. Example: Using any_errors_fatal
    25. 11. Handling Connection Errors
    26. Example: Setting Connection Timeout

  19. Working with Common Modules

    1. 1. Managing Files
    2. Example: Copying a file
    3. Example: Fetching a file from remote
    4. Example: Setting file permissions
    5. 2. Executing Commands
    6. Example: Basic command execution
    7. Example: Conditional command execution
    8. 3. Managing Packages
    9. 4. Managing Services
    10. Example: Start and Enable a Service
    11. Example: Stop and Disable a Service
    12. 5. Managing Users
    13. Example: Create a user with specific group and shell
    14. Example: Remove a user
    15. 6. Working with Git
    16. Example: Clone a Git Repository
    17. Example: Clone with Specific Branch and Force Update
    18. 7. Managing Archives
    19. Example: Create a tar.gz archive
    20. Example: Extract an archive to a directory
    21. 8. Checking File Stats
    22. Example: Check file stats
    23. 9. Setting Variables
    24. Example: Setting Variables in Playbook
    25. Example: Using
    26. 10. Managing Cron Jobs
    27. Example: Create a Cron Job
    28. Example: Remove a Cron Job
    29. 11. Pausing Execution
    30. Example: Pause for 5 seconds
    31. Example: Pause with custom message
    32. 12. Asserting Conditions
    33. Example: Basic Assertion
    34. Example: Complex Assertion with Variables

  20. Managing Files and Directories

    1. 1. Copying Files
    2. Example: Copying a file from controller to managed node
    3. Example: Copying a file with different permissions
    4. 2. Creating Directories
    5. Example: Create a directory with specific permissions and ownership
    6. 3. Creating Symlinks
    7. Example: Creating a symlink
    8. 4. Setting Permissions
    9. Example: Setting File Permissions
    10. Example: Setting Directory Permissions
    11. 5. Setting Ownership
    12. Example: Setting Ownership of a File
    13. Example: Setting Ownership Recursively
    14. 6. Removing Files
    15. Example: Remove a file
    16. Example: Remove a directory recursively
    17. 7. Creating Empty Files
    18. Example: Creating an empty file
    19. 8. Using Templates
    20. Example: Basic Template Usage
    21. Example: Template with Variables
    22. Example: Template with Loop
    23. Example: Template with Conditionals
    24. 9. Synchronizing Files
    25. Example: Synchronizing Files
    26. 10. Finding Files
    27. Example: Find all .log files in /var/log
    28. 11. Replacing Content
    29. Example: Replace file content from local source
    30. Example: Replace content with literal string
    31. 12. Modifying Lines
    32. Example: Ensure a line exists in a config file
    33. Example: Insert a line before a specific pattern

  21. Managing Packages

    1. 1. Installing Packages
    2. Example: Install a package
    3. Example: Install latest version of a package
    4. 2. Using Apt Module
    5. Example: Install a package
    6. Example: Install multiple packages
    7. Example: Update cache and install package
    8. 3. Using Yum Module
    9. Example: Install a package with Yum
    10. Example: Install a package with update_cache enabled
    11. Example: Remove a package with Yum
    12. 4. Using DNF Module
    13. Example: Install a package using DNF
    14. Example: Remove a package using DNF
    15. Example: Update package cache and install latest version
    16. 5. Updating Package Cache
    17. Example: Updating Package Cache with YUM
    18. Example: Updating Package Cache with APT
    19. 6. Removing Packages
    20. Example: Remove nginx package
    21. 7. Installing Specific Versions
    22. Example: Install specific version of a package
    23. 8. Installing Multiple Packages
    24. Example: Installing Multiple Packages
    25. 9. Using Pip Module
    26. Example: Install a Python Package
    27. Example: Install Specific Version of Package
    28. Example: Use Virtual Environment
    29. 10. Managing Repositories
    30. Example: Adding a Debian APT Repository
    31. Example: Adding a YUM Repository with GPG Key
    32. 11. Adding APT Keys
    33. Example: Adding an APT key from a URL
    34. Example: Adding an APT key from a keyserver
    35. 12. Installing from URLs
    36. Example: Installing a Debian package from URL

  22. Managing Services

    1. 1. Starting Services
    2. Example: Starting a service
    3. 2. Stopping Services
    4. Example: Stopping a service
    5. 3. Restarting Services
    6. Example: Restarting Nginx Service
    7. Example: Restarting Apache Service with systemctl
    8. 4. Reloading Services
    9. Example: Reloading a service
    10. 5. Enabling Services at Boot
    11. Example: Enabling Nginx at Boot
    12. 6. Disabling Services at Boot
    13. Example: Disable a service at boot
    14. 7. Using Systemd Module
    15. Example: Start and Enable a Service
    16. Example: Restart a Service
    17. 8. Masking Services
    18. Example: Masking a Service
    19. 9. Checking Service Status
    20. Example: Check if nginx is running
    21. Example: Check service status with pattern matching
    22. 10. Managing Service Dependencies
    23. Example: Using notify to manage service dependencies
    24. Managing Service Dependencies
    25. 11. Using service vs systemd
    26. Example: Starting a service with
    27. Example: Starting a service with
    28. Comparison:

  23. Managing Users and Groups

    1. 1. Creating Users
    2. Example: Create a user with custom group and shell
    3. Example: Create a user with encrypted password
    4. 2. Setting User Password
    5. Example: Setting a User Password
    6. 3. Setting User Shell
    7. Example: Setting User Shell
    8. 4. Creating Home Directory
    9. Example: Create User with Home Directory
    10. 5. Setting User Groups
    11. Example: Create a group
    12. Example: Remove a group
    13. 6. Removing Users
    14. Example: Remove a user with home directory
    15. Example: Remove a user without home directory
    16. 7. Managing SSH Keys
    17. Example: Add SSH key to user
    18. Example: Remove SSH key from user
    19. 8. Creating Groups
    20. Example: Create a group with a specific GID
    21. Example: Create a system group
    22. 9. Setting Group GID
    23. Example: Creating a Group with Specific GID
    24. 10. Managing Sudo Access
    25. Example: Configure Sudo Access for a User
    26. Example: Define Sudoers Content
    27. 11. Locking and Unlocking Users
    28. Example: Locking a User Account
    29. Example: Unlocking a User Account

  24. Executing Commands

    1. 1. Using Command Module
    2. Example: Basic command execution
    3. Example: Command with environment variables
    4. 2. Using Shell Module
    5. Example: Running a shell command
    6. Example: Conditional execution
    7. 3. Using Raw Module
    8. Example: Running a raw command
    9. Example: Conditional execution
    10. 4. Setting Working Directory
    11. Example: Setting Working Directory
    12. 5. Creating Files Before Command
    13. Example: Creating a file with content
    14. 6. Removing Files After Command
    15. Example: Remove a file after command execution
    16. 7. Running Scripts
    17. Example: Running a Bash Script
    18. Example: Conditional Script Execution
    19. 8. Changing Command Status
    20. Example: Using changed status in a task
    21. 9. Capturing Output
    22. Example: Using Registered Variables
    23. Example: Capturing Output from a Script
    24. 10. Setting Environment Variables
    25. Example: Setting environment variables in a task
    26. 11. Running as Different User
    27. Example: Running a Task as Root
    28. Example: Using Different Privilege Escalation Method
    29. 12. Understanding Command vs Shell
    30. Example: Using the
    31. Example: Using the

  25. Working with Tags

    1. 1. Adding Task Tags
    2. Example: Adding tags to a task
    3. Example: Using tags with a loop
    4. 2. Running Specific Tags
    5. Example: Running Playbook with Specific Tags
    6. Example: Skipping Tags
    7. 3. Skipping Tags
    8. Example: Skipping Tags During Playbook Run
    9. Example: Including Specific Tags Only
    10. 4. Listing Available Tags
    11. Example: Listing Tags in a Playbook
    12. 5. Using Multiple Tags
    13. Example: Using Multiple Tags
    14. Example: Running Playbooks with Multiple Tags
    15. 6. Using Special Tags
    16. Example: Using
    17. Example: Using
    18. Example: Using
    19. 7. Tagging Plays
    20. Example: Basic Play with Tags
    21. Example: Skip Tags in Play
    22. 8. Tagging Roles
    23. Example: Using Tags in Roles
    24. Example: Skipping Tags
    25. 9. Tagging Blocks
    26. Example: Using tags to control task execution
    27. Example: Conditional execution using tags
    28. 10. Understanding Tag Inheritance
    29. Example: Tag Inheritance in Playbook
    30. 11. Using Tag Patterns
    31. Example: Using Tag Patterns in Playbook
    32. Example: Running Playbook with Tag Patterns

  26. Working with Includes and Imports

    1. 1. Understanding Static vs Dynamic
    2. Example: Static Include
    3. Example: Dynamic Import
    4. 2. Including Tasks
    5. Example: Using include_tasks
    6. Example: Using import_tasks
    7. 3. Importing Tasks
    8. Example: Importing tasks from a file
    9. Example: Including tasks dynamically
    10. 4. Including Playbooks
    11. Example: Including a Playbook
    12. 5. Importing Playbooks
    13. Example: Importing a Playbook
    14. 6. Including Roles
    15. Example: Including a Role
    16. Example: Including Multiple Roles
    17. 7. Importing Roles
    18. Example: Using import_role
    19. Example: Using include_role with vars
    20. Key Differences
    21. 8. Passing Variables
    22. Example: Passing Variables to a Task
    23. Example: Using Extra Vars in Playbook
    24. 9. Using Conditionals
    25. Example: Using when with a variable
    26. Example: Using when with a complex condition
    27. 10. Using Tags
    28. Example: Using Tags in Playbook
    29. Example: Running Tasks with Specific Tags
    30. Example: Skipping Tasks with Specific Tags
    31. 11. Looping Over Includes
    32. Example: Looping Over Include Files
    33. 12. Understanding Precedence
    34. Example: Precedence in Playbook

  27. Creating and Managing Roles

    1. 1. Understanding Role Structure
    2. Example: Basic role directory structure
    3. 2. Creating Roles
    4. Example: Basic Role Structure
    5. Example: tasks/main.yml
    6. Example: meta/main.yml
    7. 3. Defining Role Tasks
    8. Example: Basic Role Task
    9. Example: Conditional Task with Loop
    10. 4. Setting Role Defaults
    11. Example: Setting Role Defaults
    12. 5. Setting Role Variables
    13. Example: Setting Role Variables in defaults/main.yml
    14. Example: Using Role Variables in tasks/main.yml
    15. 6. Creating Role Handlers
    16. Example: Basic Handler Definition
    17. Example: Handler with Variable
    18. Handler Best Practices
    19. 7. Managing Role Files
    20. Example: Using templates in a role
    21. Example: Including variables in a role
    22. 8. Managing Role Templates
    23. Example: Using a Jinja2 Template in a Role
    24. Template Variables
    25. 9. Setting Role Dependencies
    26. Example: Role Dependencies Configuration
    27. 10. Using Roles in Playbooks
    28. Example: Including a Role in a Playbook
    29. Example: Including a Role with Variables
    30. 11. Passing Variables to Roles
    31. Example: Passing Variables to a Role
    32. Example: Using Role Defaults
    33. Example: Using Host Variables
    34. 12. Controlling Role Execution
    35. Example: Using when with role execution

  28. Implementing Role Patterns

    1. 1. Including Roles Dynamically
    2. Example: Including a Role with Variables
    3. 2. Importing Roles Statically
    4. Example: Importing a Static Role
    5. Example: Importing a Specific Task File from a Role
    6. 3. Passing Variables to Roles
    7. Example: Setting Variables in Role
    8. Example: Using Extra Vars
    9. 4. Setting Role Tags
    10. Example: Defining tags in meta/main.yml
    11. Example: Applying tags in tasks
    12. 5. Using Role Conditionals
    13. Example: Conditional Role Execution
    14. Example: Delegating to Localhost
    15. 6. Setting Role Privilege Escalation
    16. Example: Using become in a role
    17. 7. Understanding Static vs Dynamic
    18. Example: Using Dynamic Variables in a Playbook
    19. 8. Using Role Collections
    20. Example: Installing a Collection
    21. 10. Creating Reusable Roles
    22. Example: Basic Role Structure
    23. Example: Using Variables in a Role
    24. 11. Organizing Role Libraries
    25. Example: Role Library Structure
    26. Best Practices

  29. Working with Ansible Galaxy

    1. 1. Installing Roles
    2. Example: Install a role
    3. Example: Install a role to a specific path
    4. 2. Creating Roles
    5. Example: Basic Role Structure
    6. Example: Defining Variables in defaults/main.yml
    7. Example: Using Templates in a Role
    8. 3. Listing Installed Roles
    9. Example: Listing installed roles
    10. Example: Listing roles in a specific path
    11. 4. Removing Roles
    12. Example: Removing a Role
    13. 5. Using Requirements File
    14. Example: requirements.yml file
    15. 6. Installing from Requirements
    16. Example: requirements.yml content
    17. Example: Installing from requirements.yml
    18. 7. Searching Galaxy
    19. Example: Search for collections
    20. 9. Installing Collections
    21. Example: Installing a collection from Ansible Galaxy
    22. Example: Installing a specific version of a collection
    23. 10. Specifying Versions
    24. Example: Installing a specific version from Ansible Galaxy
    25. Example: Using Git for version control
    26. 11. Installing from Git
    27. Example: Installing from Git
    28. 12. Setting Install Path
    29. Example: Setting Galaxy Install Path in ansible.cfg

  30. Working with Collections

    1. 1. Understanding Collections
    2. 2. Installing Collections
    3. Example: Installing a collection
    4. 3. Using Collection Modules
    5. Example: Using a collection module
    6. 4. Setting Collection Path
    7. Example: Setting collection path in ansible.cfg
    8. 5. Creating Custom Collections
    9. Example: Creating a minimal collection structure
    10. 6. Defining Collection Dependencies
    11. Example: Defining dependencies in meta/main.yml
    12. 7. Using Collections in Playbooks
    13. Example: Using a collection in a playbook
    14. 8. Listing Collections
    15. Example: Listing collections
    16. 9. Upgrading Collections
    17. Example: Upgrading a collection
    18. 10. Verifying Collections
    19. Example: Verifying a collection
    20. 11. Building Collections
    21. Example: Building a collection
    22. 12. Publishing Collections
    23. Example: Publishing a collection

  31. Working with Ansible Vault

    1. 1. Creating Encrypted Files
    2. Example: Creating an encrypted file
    3. 2. Encrypting Existing Files
    4. Example: Encrypting an existing file
    5. 3. Decrypting Files
    6. Example: Decrypting a file
    7. 4. Editing Encrypted Files
    8. Example: Editing an encrypted file
    9. 5. Viewing Encrypted Files
    10. Example: Viewing an encrypted file
    11. 6. Changing Vault Password
    12. Example: Changing the vault password
    13. 7. Using Vault in Playbooks
    14. Example: Using vault in a playbook
    15. 8. Using Vault Password File
    16. Example: Using a vault password file
    17. 9. Using Multiple Vault IDs
    18. Example: Using multiple vault IDs
    19. 10. Encrypting Variables
    20. Example: Encrypting a variable string
    21. 11. Using Inline Vault Variables
    22. Example: Using inline vault variables
    23. 12. Setting Vault ID Default
    24. Example: Setting default vault ID in ansible.cfg

  32. Using Ansible Playbook Command

    1. 1. Running Playbooks
    2. Example: Running a playbook with inventory
    3. 2. Checking Syntax
    4. Example: Syntax Check
    5. 3. Performing Dry Run
    6. Example: Running a playbook with dry-run
    7. 4. Showing Differences
    8. Example: Using --diff flag
    9. 5. Limiting Hosts
    10. Example: Limiting to a specific host
    11. Example: Limiting to a host group
    12. Example: Using pattern matching
    13. 6. Using Tags
    14. Example: Tagging Tasks
    15. Example: Running Specific Tags
    16. 7. Starting at Task
    17. Example: Starting at a Specific Task
    18. 8. Setting Verbosity
    19. Example: Running a playbook with verbose output
    20. 9. Listing Tasks
    21. Example: Listing Tasks in a Playbook
    22. 10. Listing Hosts
    23. Example: Listing hosts in a playbook
    24. 11. Using Extra Variables
    25. Example: Setting a variable with
    26. Example: Loading variables from a file
    27. 12. Setting Inventory
    28. Example: Static Inventory File (hosts.ini)
    29. Example: Dynamic Inventory Script

  33. Debugging Playbooks

    1. 1. Using Debug Module
    2. Example: Displaying a Message
    3. Example: Displaying Variable Value
    4. 2. Printing Variables
    5. Example: Debugging Variables in a Playbook
    6. Example: Using the debug module to print a variable
    7. 3. Using Verbosity Levels
    8. Example: Running a playbook with verbose output
    9. 4. Enabling Debug Mode
    10. Example: Using debug mode in a playbook
    11. 5. Checking Task Output
    12. Example: Using debug module to display task output
    13. Example: Debugging with custom message
    14. 6. Using Playbook Debugger
    15. Example: Using debug module in playbook
    16. Workflow: Using debug in Ansible Playbook
    17. 7. Setting Breakpoints
    18. Example: Using debug module with breakpoints
    19. 8. Inspecting Variables
    20. Example: Debugging Variables with debug module
    21. Example: Print all facts
    22. 9. Checking Task Status
    23. Example: Displaying Variable Value
    24. Example: Conditional Debug Output
    25. 10. Continuing Execution
    26. Example: Using
    27. Workflow: Debugging with Step Mode
    28. 11. Logging Output
    29. Example: Setting up logging in ansible.cfg
    30. Example: Using debug module to log output
    31. 12. Using Assert Module
    32. Example: Asserting Command Success

  34. Working with Lookup Plugins

    1. 1. Understanding Lookup Plugins
    2. Example: Using lookup plugin to read a file
    3. Example: Using lookup plugin to get environment variable
    4. 2. Reading Files
    5. Example: Reading a File
    6. Example: Reading a File with Line-by-Line Processing
    7. 3. Using Environment Variables
    8. Example: Retrieving Environment Variables
    9. 4. Reading Templates
    10. Example: Reading a Jinja2 Template
    11. Example: Using Template Variables
    12. 5. Querying Passwords
    13. Example: Using passwordstore lookup
    14. Example: Using vault lookup
    15. 6. Using Key-Value Stores
    16. Example: Using Vault Lookup Plugin
    17. 7. Reading URLs
    18. Example: Fetching JSON from a URL
    19. 8. Using Pipe Lookup
    20. Example: Using Pipe Lookup to Get Hostname
    21. Example: Using Pipe Lookup with Complex Command
    22. 9. Querying DNS
    23. Example: Querying A Records
    24. Example: Querying MX Records
    25. 10. Reading CSV Files
    26. Example: Reading CSV Data
    27. Example: Using CSV Data in a Loop
    28. 11. Using Sequence Lookup
    29. Example: Basic sequence usage
    30. Example: Generate a range of numbers
    31. Example: Create a sequence with custom step
    32. 12. Using ini Lookup
    33. Example: Reading a database host from an INI file

  35. Working with Callback Plugins

    1. 1. Understanding Callback Plugins
    2. Example: Enabling a Callback Plugin
    3. Example: Configuring Callback Plugin Settings
    4. 2. Using JSON Callback
    5. Example: Using JSON Callback Plugin
    6. 3. Using YAML Callback
    7. Example: YAML Callback Configuration
    8. 4. Using Timer Plugin
    9. Example: Timer Plugin Configuration
    10. Timer Plugin Features
    11. 5. Creating Custom Callbacks
    12. Example: Custom Callback Plugin Structure
    13. Key Methods in Callback Plugins
    14. 6. Enabling Multiple Callbacks
    15. Example: Configuring Multiple Callbacks
    16. 7. Using Oneline Callback
    17. Example: Using Oneline Callback
    18. 8. Configuring Callbacks
    19. Example: Enabling custom callback plugin
    20. 9. Sending Notifications
    21. Example: Slack Notification Configuration
    22. 10. Logging Results
    23. Example: Configuring JSON logging

  36. Working with Plugin Types

    1. 1. Understanding Plugin Types
    2. Example: Using a Custom Action Plugin
    3. 2. Using Filter Plugins
    4. Example: Using filter plugins in a task
    5. Example: Using regex_replace filter
    6. 3. Using Test Plugins
    7. Example: Using test plugins in a playbook
    8. Key Features of Test Plugins
    9. 4. Using Action Plugins
    10. Example: Using the copy action plugin
    11. Example: Using the command action plugin
    12. 5. Using Connection Plugins
    13. Example: Using connection plugins in a playbook
    14. Common Connection Plugins
    15. 6. Using Cache Plugins
    16. Example: Configuring Redis Cache Plugin
    17. Example: Using Cache in Playbook
    18. Cache Plugin Types
    19. 7. Configuring Plugin Paths
    20. Example: Setting plugin paths in ansible.cfg
    21. 8. Creating Custom Plugins
    22. Example: Creating a Custom Filter Plugin
    23. Example: Using the Custom Filter in a Playbook
    24. 9. Using Inventory Plugins
    25. Example: YAML Inventory with Groups
    26. Example: EC2 Inventory Plugin Configuration
    27. 10. Using Vars Plugins
    28. Example: Using vars plugin to load from YAML file

  37. Implementing Strategy Plugins

    1. 1. Understanding Strategy Plugins
    2. Example: Setting Strategy in Playbook
    3. Key Concepts
    4. 2. Using Linear Strategy
    5. Example: Using Linear Strategy in a Playbook
    6. 3. Using Free Strategy
    7. Example: Using Free Strategy in Playbook
    8. 4. Using Debug Strategy
    9. Example: Using Debug Strategy in Playbook
    10. 5. Using Host Pinned Strategy
    11. Example: Using host_pinned strategy in a playbook
    12. 6. Configuring Strategy Options
    13. Example: Setting Strategy in Playbook
    14. 7. Setting Serial Execution
    15. Example: Serial Execution in Playbook
    16. 8. Using Forks
    17. Example: Setting forks in playbook
    18. 9. Combining Strategy and Serial
    19. Example: Using
    20. 10. Creating Custom Strategies
    21. Example: Basic Custom Strategy Plugin

  38. Implementing Asynchronous Tasks

    1. 1. Setting Async Tasks
    2. Example: Running an async task with polling
    3. 2. Setting Poll Interval
    4. Example: Setting Poll Interval
    5. 3. Using Fire and Forget
    6. Example: Fire and Forget Task
    7. Example: Checking Async Task Status
    8. 4. Checking Async Status
    9. Example: Checking Async Status
    10. 5. Registering Async Job ID
    11. Example: Registering Async Job ID
    12. 6. Waiting for Completion
    13. Example: Waiting for Async Task Completion
    14. Key Points
    15. 7. Setting Async Timeout
    16. Example: Setting Async Timeout
    17. 8. Using Async with Loops
    18. Example: Using async with loop
    19. 9. Running Long Tasks
    20. Example: Running a long task asynchronously
    21. Example: Background task with status check
    22. 10. Handling Async Failures
    23. Example: Async Task with Failure Handling
    24. Async Failure Handling Best Practices
    25. 11. Cleaning Up Async Jobs
    26. Example: Cleaning Up Async Jobs

  39. Optimizing Ansible Performance

    1. 1. Increasing Parallelism
    2. Example: Setting forks in playbook
    3. Example: Using serial for large inventories
    4. 2. Enabling Pipelining
    5. Example: Enabling Pipelining in a Playbook
    6. 3. Using Fact Caching
    7. Example: Enable fact caching with JSON file
    8. 4. Disabling Fact Gathering
    9. Example: Disabling facts for a playbook
    10. 5. Using Async Tasks
    11. Example: Running an async task
    12. Example: Checking async task status
    13. 6. Implementing Strategy Plugins
    14. Example: Using the
    15. 7. Reducing SSH Overhead
    16. Example: SSH Control Master Configuration
    17. 8. Using Mitogen Plugin
    18. Example: Enabling Mitogen Plugin
    19. 9. Optimizing Template Rendering
    20. Example: Using template_cache
    21. Example: Custom Jinja2 extensions
    22. 10. Batching Tasks
    23. Example: Using batch_size in a playbook
    24. 11. Using Persistent Connections
    25. Example: Configuring persistent connections in inventory
    26. Example: Using persistent connections in a playbook
    27. 12. Minimizing Privilege Escalation
    28. Example: Disabling privilege escalation
    29. Example: Using become with specific user

  40. Testing and Validating Playbooks

    1. 1. Performing Syntax Check
    2. Example: Basic syntax check command
    3. 2. Running Check Mode
    4. Example: Running a playbook in check mode
    5. Example: Running a playbook in check mode with diff
    6. 3. Using Diff Mode
    7. Example: Enabling diff mode in a playbook
    8. 4. Testing with Molecule
    9. Example: Basic Molecule Configuration
    10. Example: Test Playbook with Molecule
    11. Key Features of Molecule
    12. 5. Creating Test Scenarios
    13. Example: Basic Test Scenario Structure
    14. Example: Testing with Mock Data
    15. Best Practices for Test Scenarios
    16. 6. Using Docker Driver
    17. Example: Running Ansible tests with Docker driver
    18. 7. Running Ansible Lint
    19. Example: Running ansible-lint
    20. 8. Validating YAML
    21. Example: Validating playbook syntax
    22. 9. Testing Idempotence
    23. Example: Idempotent File Creation
    24. Example: Idempotent Package Installation
    25. Idempotency Best Practices
    26. 10. Using Assert Module
    27. Example: Basic Assert Usage
    28. Example: Assert with Variable
    29. 11. Verifying Results
    30. Example: Check Task Results
    31. Example: Validate Configuration Files
    32. 12. Running Verify Phase
    33. Example: Using ansible-playbook with verify

  41. Implementing Advanced Patterns

    1. 1. Using Delegation Strategies
    2. 2. Implementing Rolling Updates
    3. Example: Rolling Update with Batch Size
    4. Example: Rolling Update with Delay
    5. 3. Implementing Blue-Green Deployments
    6. Example: Blue-Green Deployment Setup
    7. Example: Switching Traffic to Green
    8. Benefits of Blue-Green Deployment
    9. Blue-Green vs Other Deployment Strategies
    10. 4. Using Canary Deployments
    11. Example: Canary Deployment Playbook
    12. Canary Deployment Steps
    13. 5. Implementing Zero-Downtime Deployments
    14. Example: Rolling Update with Load Balancer
    15. Example: Blue-Green Deployment
    16. Best Practices for Zero-Downtime Deployment
    17. 6. Using Pre and Post Tasks
    18. Example: Using pre_task and post_task
    19. Key Points
    20. 7. Implementing Health Checks
    21. Example: HTTP Health Check
    22. Example: TCP Port Check
    23. Example: File Existence Check
    24. Example: Command Execution Check
    25. 8. Using Smoke Tests
    26. Example: Smoke Test Playbook
    27. 9. Implementing Rollback Strategies
    28. Example: Rollback using tags
    29. 10. Using Configuration Drift Detection
    30. Example: Detecting Configuration Drift with Ansible

  42. Implementing Security Best Practices

    1. 1. Using Ansible Vault
    2. Example: Encrypting a Variables File
    3. Example: Using Vault in Playbook
    4. 2. Managing SSH Keys
    5. Example: Using SSH Key for Authentication
    6. Best Practices for SSH Key Management
    7. 3. Setting Become Password
    8. Example: Using become_password in a playbook
    9. 4. Disabling Root Login
    10. Example: Disabling Root Login via SSH
    11. 5. Validating Module Sources
    12. Example: Verifying Collection Integrity
    13. 6. Setting File Permissions
    14. Example: Setting File Permissions with Ansible
    15. Example: Setting Directory Permissions with Ansible
    16. Key Points for File Permissions
    17. 7. Limiting Privilege Escalation
    18. Example: Using become with sudo
    19. 8. Using Separate Vault Files
    20. Example: Encrypting a Vault File
    21. Example: Using Vault File in Playbook
    22. 9. Auditing Playbook Runs
    23. Example: Enable Verbose Logging
    24. Example: Run with Diff and Check Mode
    25. 10. Implementing RBAC
    26. Example: Role Assignment in Ansible Tower
    27. 11. Using Jump Hosts
    28. Example: Using Jump Host in Inventory
    29. Example: Using Proxy Command in Playbook
    30. 12. Validating Input
    31. Example: Validating User Input in Playbook

  43. Managing AWS Infrastructure

    1. 1. Using AWS Collection
    2. Example: Configure AWS credentials
    3. Example: Launch EC2 instance
    4. 2. Configuring AWS Credentials
    5. Example: Using Environment Variables
    6. 3. Managing EC2 Instances
    7. Example: Launching EC2 Instances
    8. Example: Tagging EC2 Instances
    9. 4. Managing S3 Buckets
    10. Example: Create S3 Bucket
    11. Example: Delete S3 Bucket
    12. 5. Managing VPCs
    13. Example: Create a VPC
    14. Example: Delete a VPC
    15. 6. Managing Security Groups
    16. Example: Create a Security Group
    17. Example: Add Ingress Rule to Security Group
    18. Example: Remove a Rule from Security Group
    19. 7. Managing IAM Resources
    20. Example: Create an IAM User
    21. Example: Attach Policy to IAM Group
    22. Example: Create IAM Role with Trust Policy
    23. 8. Managing RDS Instances
    24. Example: Create an RDS Instance
    25. Example: Modify RDS Instance Storage
    26. 9. Using Dynamic Inventory
    27. Example: Basic Dynamic Inventory Configuration
    28. Example: Using Dynamic Inventory with Groups
    29. 10. Managing Load Balancers
    30. Example: Create an ELB with HTTP listener
    31. Example: Update an existing ELB with new listeners
    32. Example: Create a target group for an ALB

  44. Managing Azure and GCP Infrastructure

    1. 1. Using Azure Collection
    2. Example: Create a Resource Group
    3. Example: Create a Virtual Machine
    4. 2. Configuring Azure Credentials
    5. Example: Setting up Azure credentials in a playbook
    6. 3. Managing Azure VMs
    7. Example: Create an Azure VM
    8. Example: Scale VM Size
    9. Example: Start/Stop VM
    10. 4. Managing Azure Resources
    11. Example: Create an Azure Resource Group
    12. Example: Create an Azure Virtual Machine
    13. Example: Create an Azure Storage Account
    14. 5. Using Azure Dynamic Inventory
    15. Example: Basic Azure Dynamic Inventory Configuration
    16. Example: Using Azure CLI Authentication
    17. Example: Using Managed Identity Authentication
    18. 6. Using GCP Collection
    19. Example: Creating a GCP Compute Instance
    20. Example: Creating a GCP Storage Bucket
    21. 7. Configuring GCP Credentials
    22. Example: Setting GCP Credentials via Environment Variables
    23. Example: Using GCP Credentials in Ansible Playbook
    24. 8. Managing GCE Instances
    25. Example: Create GCE Instance
    26. Example: Delete GCE Instance
    27. 9. Managing GCP Resources
    28. Example: Create a GCP Compute Instance
    29. Example: Create a GCP Storage Bucket
    30. Example: Create a GCP SQL Instance
    31. Example: Create a GKE Cluster
    32. 10. Using GCP Dynamic Inventory
    33. Example: GCP Dynamic Inventory Configuration
    34. Key Features

  45. Working with Container Platforms

    1. 1. Managing Docker Containers
    2. Example: Start a Docker Container
    3. Example: Stop and Remove a Container
    4. 2. Building Docker Images
    5. Example: Building a Docker Image
    6. 3. Managing Docker Networks
    7. Example: Create a Docker Network
    8. Example: Remove a Docker Network
    9. 4. Managing Docker Volumes
    10. Example: Creating a Docker Volume
    11. Example: Removing a Docker Volume
    12. 5. Using Docker Login
    13. Example: Docker Login Configuration
    14. 6. Managing Kubernetes Resources
    15. Example: Deploying a Kubernetes Deployment
    16. Example: Creating a Kubernetes Service
    17. Key Features
    18. 7. Using Helm Charts
    19. Example: Deploying a Helm Chart
    20. 8. Managing Pods
    21. Example: Create a Pod
    22. Example: Delete a Pod
    23. Example: Scale Pod Replicas
    24. 9. Managing Deployments
    25. Example: Deploying a Kubernetes Deployment
    26. Example: Managing Docker Container Deployment
    27. 10. Managing ConfigMaps and Secrets
    28. Example: Creating a ConfigMap
    29. Example: Creating a Secret
    30. Example: Using ConfigMap in a Pod
    31. Example: Using Secret in a Pod

  46. Managing Network Devices

    1. 1. Understanding Network Modules
    2. Example: Using network modules to gather facts
    3. 2. Configuring Cisco IOS
    4. Example: Configure a Cisco IOS device using CLI
    5. Example: Configure interface on Cisco IOS
    6. 3. Configuring Juniper Devices
    7. Example: Configure a Juniper device with basic settings
    8. Example: Apply configuration from a file
    9. 4. Using Network CLI Connection
    10. Example: Basic Network CLI Connection Configuration
    11. 5. Using NETCONF Connection
    12. Example: Configure a Network Device via NETCONF
    13. 6. Backing Up Configurations
    14. Example: Backup Configuration Using network_cli
    15. Example: Backup Configuration Using napalm
    16. 7. Validating Configurations
    17. Example: Validate configuration using NETCONF
    18. 8. Using Command Module
    19. Example: Execute a command on a network device
    20. Example: Execute command with prompt and answer
    21. 9. Managing VLANs
    22. Example: Create a VLAN
    23. Example: Assign Interface to VLAN
    24. 10. Managing Interfaces
    25. Example: Configure Interface
    26. 11. Managing Static Routes
    27. Example: Configure Static Route on Cisco IOS
    28. Example: Ansible Playbook for Static Route

  47. Managing Windows Hosts

    1. 1. Configuring WinRM
    2. Example: Basic WinRM Configuration
    3. 2. Setting Windows Connection
    4. Example: Playbook using Windows connection
    5. 3. Using Windows Modules
    6. Example: Running a PowerShell Script
    7. Example: Managing a Windows Service
    8. 4. Managing Windows Services
    9. Example: Start a Windows Service
    10. Example: Stop and Disable a Windows Service
    11. 5. Managing Windows Packages
    12. Example: Install a Windows Package
    13. Example: Remove a Windows Package
    14. 6. Managing Windows Files
    15. Example: Copying a file to Windows host
    16. Example: Creating a directory on Windows host
    17. Example: Removing a file from Windows host
    18. 7. Executing PowerShell
    19. Example: Executing a PowerShell script
    20. Example: Executing a PowerShell script with arguments
    21. 8. Managing Windows Users
    22. Example: Create a Windows User
    23. Example: Delete a Windows User
    24. 9. Managing Windows Features
    25. 10. Managing Windows Registry
    26. Example: Setting a Windows Registry Value
    27. Example: Removing a Windows Registry Key
    28. 11. Managing Windows Updates
    29. Example: Install Windows Updates
    30. Example: Check for Available Updates

  48. Integrating with CI/CD Pipelines

    1. 1. Using Ansible in Jenkins
    2. Example: Jenkins Pipeline Script
    3. 2. Using Ansible in GitLab CI
    4. Example: Basic GitLab CI Pipeline with Ansible
    5. 3. Using Ansible in GitHub Actions
    6. Example: GitHub Actions Workflow
    7. 4. Using Ansible in CircleCI
    8. Example: Basic CircleCI Configuration
    9. Key Configuration Points
    10. 5. Managing Secrets in CI
    11. Example: Using Vault in CI Pipeline
    12. 6. Running Tests in CI
    13. Example: Running Tests in GitHub Actions
    14. 7. Deploying from CI
    15. Example: Deploying to Production
    16. 8. Using Ansible Pull
    17. Example: Running Ansible Pull
    18. 9. Scheduling Playbooks
    19. Example: Scheduling a playbook with cron
    20. 10. Using AWX Tower API
    21. Example: Triggering a Job via AWX API
    22. API Integration Summary

  49. Working with AWX and Ansible Tower

    1. 1. Understanding AWX Architecture
    2. Example: AWX Component Interaction
    3. Key Points
    4. 2. Installing AWX
    5. Example: Installing AWX using Docker
    6. Installation Steps
    7. Prerequisites
    8. 3. Creating Organizations
    9. Example: Creating an Organization via API
    10. 4. Managing Users and Teams
    11. Example: Create a new user with admin privileges
    12. Example: Update user permissions
    13. Example: Delete a user
    14. Example: Create a new team
    15. Example: Add user to team
    16. Example: Remove user from team
    17. 5. Creating Inventories
    18. Example: Creating a Smart Inventory
    19. Example: Creating a Constructed Inventory
    20. 6. Creating Projects
    21. Example: Creating a Project via API
    22. 7. Creating Job Templates
    23. Example: Creating a Job Template via API
    24. 8. Creating Workflows
    25. Example: Basic Workflow Job Template
    26. Steps to Create a Workflow
    27. Workflow Job Template Components
    28. 9. Managing Credentials
    29. Example: Creating an AWS Credential
    30. 10. Using Surveys
    31. Example: Survey Configuration in Job Template
    32. 11. Scheduling Jobs
    33. Example: Create a Scheduled Job
    34. 12. Using AWX API
    35. Example: Launching a Job Template via API

  50. Troubleshooting Ansible Issues

    1. 1. Debugging Connection Issues
    2. Example: Verifying SSH connectivity
    3. Workflow: Troubleshooting Steps
    4. 2. Resolving Authentication Errors
    5. Example: SSH Key Authentication Setup
    6. Example: Inventory Configuration with SSH Key
    7. 3. Troubleshooting Module Errors
    8. Example: Module not found error
    9. Example: Invalid parameter error
    10. Example: Permission denied error
    11. Common Troubleshooting Steps
    12. 4. Debugging Variable Issues
    13. Example: Debugging undefined variable
    14. Example: Inspecting all variables
    15. 5. Resolving Template Errors
    16. Example: Undefined Variable Handling
    17. Example: Template with Error Handling
    18. 6. Debugging Inventory Issues
    19. Example: Validate Inventory
    20. Example: List All Hosts
    21. Example: Inspect Host Variables
    22. 7. Resolving Privilege Escalation
    23. Example: Using become to run a task as root
    24. 8. Debugging Performance Issues
    25. Example: Profiling playbook execution
    26. Example: Limiting forks to reduce memory usage
    27. 9. Troubleshooting Idempotence
    28. Example: Idempotent Task
    29. Example: Non-Idempotent Task
    30. 10. Resolving Python Dependency Issues
    31. Example: Setting Python Interpreter
    32. 11. Debugging Custom Modules
    33. Example: Using debug module to inspect variables
    34. Example: Using debug to print message
    35. 12. Using Ansible Logs
    36. Example: Enabling verbose logging
    37. Example: Setting log file in configuration
    38. Example: Filtering logs by host