Advanced Ansible: Dynamic Inventory and Tower

plugin: aws_ec2
regions:
  - us-east-1
  - us-west-2
  - eu-west-1

filters:
  instance-state-name: running
  tag:Managed: ansible

keyed_groups:
  # Group by instance type
  - key: instance_type
    prefix: type
  
  # Group by environment tag
  - key: tags.Environment
    prefix: env
  
  # Group by application tag
  - key: tags.Application
    prefix: app
  
  # Group by availability zone
  - key: placement.availability_zone
    prefix: az

hostnames:
  - tag:Name
  - private-ip-address

compose:
  ansible_host: public_ip_address
  ansible_user: "'ec2-user' if 'amazon' in image_id else 'ubuntu'"
  
groups:
  production: "'production' in tags.Environment"
  staging: "'staging' in tags.Environment"
  webservers: "'web' in tags.Role"
  databases: "'db' in tags.Role"

# List inventory
ansible-inventory -i aws_ec2.yml --list

# Graph inventory
ansible-inventory -i aws_ec2.yml --graph

# Run playbook with dynamic inventory
ansible-playbook -i aws_ec2.yml deploy.yml

plugin: azure_rm

auth_source: auto

include_vm_resource_groups:
  - production-rg
  - staging-rg

keyed_groups:
  - prefix: tag
    key: tags
  - prefix: azure_loc
    key: location
  - prefix: azure_os
    key: os_profile.system

conditional_groups:
  linux: "'Linux' in os_profile.system"
  windows: "'Windows' in os_profile.system"
  production: "'production' in tags.environment"

#!/usr/bin/env python3

import json
import sys
import requests

def get_inventory():
    # Fetch inventory from API
    response = requests.get('https://api.example.com/inventory')
    data = response.json()
    
    inventory = {
        '_meta': {
            'hostvars': {}
        }
    }
    
    for server in data['servers']:
        # Add to groups
        for group in server['groups']:
            if group not in inventory:
                inventory[group] = {
                    'hosts': [],
                    'vars': {}
                }
            inventory[group]['hosts'].append(server['hostname'])
        
        # Add host variables
        inventory['_meta']['hostvars'][server['hostname']] = {
            'ansible_host': server['ip_address'],
            'ansible_user': server['ssh_user'],
            'environment': server['environment'],
            'application': server['application']
        }
    
    return inventory

def get_host(hostname):
    # Fetch specific host variables
    response = requests.get(f'https://api.example.com/hosts/{hostname}')
    return response.json()

if __name__ == '__main__':
    if len(sys.argv) == 2 and sys.argv[1] == '--list':
        print(json.dumps(get_inventory(), indent=2))
    elif len(sys.argv) == 3 and sys.argv[1] == '--host':
        print(json.dumps(get_host(sys.argv[2]), indent=2))
    else:
        print("Usage: inventory.py --list or inventory.py --host <hostname>")
        sys.exit(1)

version: '3.8'

services:
  awx_web:
    image: ansible/awx:latest
    container_name: awx_web
    depends_on:
      - awx_postgres
      - awx_redis
    ports:
      - "80:8052"
    environment:
      - SECRET_KEY=${SECRET_KEY}
      - DATABASE_USER=awx
      - DATABASE_PASSWORD=${DB_PASSWORD}
      - DATABASE_NAME=awx
      - DATABASE_PORT=5432
      - DATABASE_HOST=awx_postgres
      - REDIS_HOST=awx_redis
      - REDIS_PORT=6379
    volumes:
      - awx_projects:/var/lib/awx/projects
      - awx_rsyslog:/var/log/tower

  awx_task:
    image: ansible/awx:latest
    container_name: awx_task
    depends_on:
      - awx_postgres
      - awx_redis
    environment:
      - SECRET_KEY=${SECRET_KEY}
      - DATABASE_USER=awx
      - DATABASE_PASSWORD=${DB_PASSWORD}
      - DATABASE_NAME=awx
      - DATABASE_PORT=5432
      - DATABASE_HOST=awx_postgres
      - REDIS_HOST=awx_redis
      - REDIS_PORT=6379
    volumes:
      - awx_projects:/var/lib/awx/projects

  awx_postgres:
    image: postgres:13
    container_name: awx_postgres
    environment:
      - POSTGRES_USER=awx
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=awx
    volumes:
      - awx_postgres:/var/lib/postgresql/data

  awx_redis:
    image: redis:7-alpine
    container_name: awx_redis

volumes:
  awx_postgres:
  awx_projects:
  awx_rsyslog:

# Install AWX CLI
pip install awxkit

# Configure AWX CLI
awx login -f human \
  --conf.host https://awx.example.com \
  --conf.username admin \
  --conf.password password

# Create organization
awx organizations create \
  --name "MyOrg" \
  --description "My Organization"

# Create inventory
awx inventory create \
  --name "Production" \
  --organization "MyOrg"

# Create project
awx projects create \
  --name "MyProject" \
  --organization "MyOrg" \
  --scm_type git \
  --scm_url "https://github.com/myorg/ansible-playbooks.git" \
  --scm_branch main

# Create job template
awx job_templates create \
  --name "Deploy Application" \
  --job_type run \
  --inventory "Production" \
  --project "MyProject" \
  --playbook "deploy.yml" \
  --credentials "SSH Key"

# Launch job
awx job_templates launch "Deploy Application"

#!/usr/bin/python

from ansible.module_utils.basic import AnsibleModule
import socket

def check_port(host, port, timeout=5):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        result = sock.connect_ex((host, port))
        sock.close()
        return result == 0
    except Exception as e:
        return False

def main():
    module = AnsibleModule(
        argument_spec=dict(
            host=dict(type='str', required=True),
            port=dict(type='int', required=True),
            timeout=dict(type='int', default=5)
        ),
        supports_check_mode=True
    )

    host = module.params['host']
    port = module.params['port']
    timeout = module.params['timeout']

    if module.check_mode:
        module.exit_json(changed=False)

    is_open = check_port(host, port, timeout)

    if is_open:
        module.exit_json(
            changed=False,
            msg=f"Port {port} is open on {host}",
            port_open=True
        )
    else:
        module.fail_json(
            msg=f"Port {port} is closed on {host}",
            port_open=False
        )

if __name__ == '__main__':
    main()

- name: Check if port is open
  check_port:
    host: example.com
    port: 443
    timeout: 10
  register: port_check

- name: Display result
  debug:
    msg: "Port is {{ 'open' if port_check.port_open else 'closed' }}"

---
- name: Rolling update with health checks
  hosts: webservers
  serial: "25%"
  max_fail_percentage: 25
  
  pre_tasks:
    - name: Remove from load balancer
      delegate_to: localhost
      uri:
        url: "http://lb.example.com/api/remove/{{ inventory_hostname }}"
        method: POST
      register: lb_remove
      until: lb_remove.status == 200
      retries: 3
      delay: 5
  
  tasks:
    - name: Stop application
      service:
        name: myapp
        state: stopped
    
    - name: Deploy new version
      copy:
        src: /tmp/myapp-v2.0.tar.gz
        dest: /opt/myapp/
    
    - name: Start application
      service:
        name: myapp
        state: started
    
    - name: Wait for application to be ready
      wait_for:
        port: 8080
        delay: 10
        timeout: 60
    
    - name: Run health check
      uri:
        url: "http://{{ inventory_hostname }}:8080/health"
        status_code: 200
      register: health_check
      until: health_check.status == 200
      retries: 5
      delay: 10
  
  post_tasks:
    - name: Add back to load balancer
      delegate_to: localhost
      uri:
        url: "http://lb.example.com/api/add/{{ inventory_hostname }}"
        method: POST
      register: lb_add
      until: lb_add.status == 200
      retries: 3
      delay: 5

---
- name: Database migration
  hosts: webservers
  
  tasks:
    - name: Run database migration (once)
      command: /opt/myapp/migrate.sh
      run_once: true
      delegate_to: "{{ groups['databases'][0] }}"
    
    - name: Clear cache on all nodes
      command: /opt/myapp/clear-cache.sh
    
    - name: Notify monitoring system
      uri:
        url: "https://monitoring.example.com/api/deployment"
        method: POST
        body_format: json
        body:
          application: myapp
          version: "{{ app_version }}"
          hosts: "{{ groups['webservers'] }}"
      delegate_to: localhost
      run_once: true