AWX Ansible Tower

# Install Docker and Docker Compose
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# Install Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.39.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Verify installation
docker --version
docker-compose --version

# Install Docker and Docker Compose
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# Install Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.39.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Verify installation
docker --version
docker-compose --version

# cloud-lab-setup.yml
---
cloud_labs:
  aws:
    instance_type: t3.medium
    ami: ubuntu-22.04
    security_groups: ["awx-lab-sg"]

  gcp:
    machine_type: e2-medium
    image_family: ubuntu-2204-lts
    firewall_tags: ["awx-lab"]

  azure:
    vm_size: Standard_B2s
    image_offer: 0001-com-ubuntu-server-jammy
    nsg: awx-lab-nsg

# cloud-lab-setup.yml
---
cloud_labs:
  aws:
    instance_type: t3.medium
    ami: ubuntu-22.04
    security_groups: ["awx-lab-sg"]

  gcp:
    machine_type: e2-medium
    image_family: ubuntu-2204-lts
    firewall_tags: ["awx-lab"]

  azure:
    vm_size: Standard_B2s
    image_offer: 0001-com-ubuntu-server-jammy
    nsg: awx-lab-nsg

use_cases:
  compliance_automation:
    - PCI-DSS compliance checking
    - SOX controls automation
    - Risk assessment workflows

  infrastructure_management:
    - Multi-region disaster recovery
    - Automated patching windows
    - Capacity planning automation

use_cases:
  compliance_automation:
    - PCI-DSS compliance checking
    - SOX controls automation
    - Risk assessment workflows

  infrastructure_management:
    - Multi-region disaster recovery
    - Automated patching windows
    - Capacity planning automation

use_cases:
  security_automation:
    - HIPAA compliance monitoring
    - Patient data encryption
    - Access control automation

  operational_efficiency:
    - EHR system deployment
    - Medical device configuration
    - Backup and recovery automation

use_cases:
  security_automation:
    - HIPAA compliance monitoring
    - Patient data encryption
    - Access control automation

  operational_efficiency:
    - EHR system deployment
    - Medical device configuration
    - Backup and recovery automation

use_cases:
  rapid_scaling:
    - Auto-scaling infrastructure
    - CI/CD pipeline automation
    - Environment provisioning

  cost_optimization:
    - Resource right-sizing
    - Unused resource cleanup
    - Multi-cloud cost management

use_cases:
  rapid_scaling:
    - Auto-scaling infrastructure
    - CI/CD pipeline automation
    - Environment provisioning

  cost_optimization:
    - Resource right-sizing
    - Unused resource cleanup
    - Multi-cloud cost management

migration_steps:
  preparation:
    - Inventory playbooks and roles
    - Document current automation workflows
    - Identify credential management needs

  installation:
    - Deploy AWX infrastructure
    - Configure authentication (LDAP/local)
    - Set up organizations and teams

  migration:
    - Import existing playbooks as projects
    - Create job templates from ad-hoc commands
    - Migrate inventories (static to dynamic)
    - Configure credentials securely

  optimization:
    - Implement workflow templates
    - Set up notifications and monitoring
    - Establish CI/CD integration

migration_steps:
  preparation:
    - Inventory playbooks and roles
    - Document current automation workflows
    - Identify credential management needs

  installation:
    - Deploy AWX infrastructure
    - Configure authentication (LDAP/local)
    - Set up organizations and teams

  migration:
    - Import existing playbooks as projects
    - Create job templates from ad-hoc commands
    - Migrate inventories (static to dynamic)
    - Configure credentials securely

  optimization:
    - Implement workflow templates
    - Set up notifications and monitoring
    - Establish CI/CD integration

upgrade_considerations:
  feature_gaps:
    - Smart inventory → Automation mesh
    - Basic workflows → Advanced workflow designer
    - Community support → Enterprise support

  technical_requirements:
    - Data migration planning
    - License procurement
    - Support contract setup

  business_justification:
    - Compliance requirements (SOC2, FedRAMP)
    - SLA requirements
    - Enterprise integrations needed

upgrade_considerations:
  feature_gaps:
    - Smart inventory → Automation mesh
    - Basic workflows → Advanced workflow designer
    - Community support → Enterprise support

  technical_requirements:
    - Data migration planning
    - License procurement
    - Support contract setup

  business_justification:
    - Compliance requirements (SOC2, FedRAMP)
    - SLA requirements
    - Enterprise integrations needed

network_requirements:
  inbound_ports:
    - port: 80
      description: "HTTP (redirect to HTTPS)"
      required: true
    - port: 443
      description: "HTTPS for web interface"
      required: true
    - port: 22
      description: "SSH for managed nodes"
      required: true

  outbound_ports:
    - port: 443
      description: "HTTPS for cloud APIs, Git repos"
      required: true
    - port: 22
      description: "SSH to managed nodes"
      required: true
    - port: 5432
      description: "PostgreSQL (if external)"
      required: false

  firewall_rules:
    - name: "AWX Web Access"
      source: "0.0.0.0/0"
      destination: "AWX Server"
      ports: [80, 443]
    - name: "SSH to Managed Nodes"
      source: "AWX Server"
      destination: "Managed Infrastructure"
      ports: [22]

network_requirements:
  inbound_ports:
    - port: 80
      description: "HTTP (redirect to HTTPS)"
      required: true
    - port: 443
      description: "HTTPS for web interface"
      required: true
    - port: 22
      description: "SSH for managed nodes"
      required: true

  outbound_ports:
    - port: 443
      description: "HTTPS for cloud APIs, Git repos"
      required: true
    - port: 22
      description: "SSH to managed nodes"
      required: true
    - port: 5432
      description: "PostgreSQL (if external)"
      required: false

  firewall_rules:
    - name: "AWX Web Access"
      source: "0.0.0.0/0"
      destination: "AWX Server"
      ports: [80, 443]
    - name: "SSH to Managed Nodes"
      source: "AWX Server"
      destination: "Managed Infrastructure"
      ports: [22]

#!/bin/bash
# prerequisites-check.sh

echo "=== AWX Prerequisites Check ==="

# Check Docker
if command -v docker &> /dev/null; then
    echo "✓ Docker: $(docker --version)"
    docker_running=$(docker info >/dev/null 2>&1 && echo "running" || echo "not running")
    echo "  Status: $docker_running"
else
    echo "✗ Docker: Not installed"
fi

# Check Docker Compose
if command -v docker-compose &> /dev/null; then
    echo "✓ Docker Compose: $(docker-compose --version)"
else
    echo "✗ Docker Compose: Not installed"
fi

# Check Git
if command -v git &> /dev/null; then
    echo "✓ Git: $(git --version)"
else
    echo "✗ Git: Not installed"
fi

# Check system resources
echo "✓ System Resources:"
echo "  CPU Cores: $(nproc)"
echo "  RAM: $(free -h | awk '/^Mem:/ {print $2}')"
echo "  Disk Space: $(df -h / | awk 'NR==2 {print $4}')"

# Check ports
echo "✓ Port Check:"
for port in 80 443; do
    if netstat -tuln | grep -q ":$port "; then
        echo "  Port $port: In use"
    else
        echo "  Port $port: Available"
    fi
done

#!/bin/bash
# prerequisites-check.sh

echo "=== AWX Prerequisites Check ==="

# Check Docker
if command -v docker &> /dev/null; then
    echo "✓ Docker: $(docker --version)"
    docker_running=$(docker info >/dev/null 2>&1 && echo "running" || echo "not running")
    echo "  Status: $docker_running"
else
    echo "✗ Docker: Not installed"
fi

# Check Docker Compose
if command -v docker-compose &> /dev/null; then
    echo "✓ Docker Compose: $(docker-compose --version)"
else
    echo "✗ Docker Compose: Not installed"
fi

# Check Git
if command -v git &> /dev/null; then
    echo "✓ Git: $(git --version)"
else
    echo "✗ Git: Not installed"
fi

# Check system resources
echo "✓ System Resources:"
echo "  CPU Cores: $(nproc)"
echo "  RAM: $(free -h | awk '/^Mem:/ {print $2}')"
echo "  Disk Space: $(df -h / | awk 'NR==2 {print $4}')"

# Check ports
echo "✓ Port Check:"
for port in 80 443; do
    if netstat -tuln | grep -q ":$port "; then
        echo "  Port $port: In use"
    else
        echo "  Port $port: Available"
    fi
done

# Clone AWX repository
git clone https://github.com/ansible/awx.git
cd awx

# Create environment configuration
cat > .env << EOF
# Basic configuration
COMPOSE_PROJECT_NAME=awx
AWX_ADMIN_USER=admin
AWX_ADMIN_PASSWORD=SecurePassword123!

# Database settings
POSTGRES_PASSWORD=PostgresPassword123!
POSTGRES_USER=awx
POSTGRES_DB=awx

# Secret key (generate with: openssl rand -base64 30)
SECRET_KEY=$(openssl rand -base64 30)

# Host configuration
HOST_PORT=80
HOST_PORT_SSL=443
DOCKER_COMPOSE_DIR=/opt/awx

# Optional: Custom settings
DEFAULT_PROJECT_PATH=/var/lib/awx/projects
PROJECT_DATA_DIR=/var/lib/awx/projects
EOF

# Deploy AWX
make docker-compose-build
make docker-compose

# Clone AWX repository
git clone https://github.com/ansible/awx.git
cd awx

# Create environment configuration
cat > .env << EOF
# Basic configuration
COMPOSE_PROJECT_NAME=awx
AWX_ADMIN_USER=admin
AWX_ADMIN_PASSWORD=SecurePassword123!

# Database settings
POSTGRES_PASSWORD=PostgresPassword123!
POSTGRES_USER=awx
POSTGRES_DB=awx

# Secret key (generate with: openssl rand -base64 30)
SECRET_KEY=$(openssl rand -base64 30)

# Host configuration
HOST_PORT=80
HOST_PORT_SSL=443
DOCKER_COMPOSE_DIR=/opt/awx

# Optional: Custom settings
DEFAULT_PROJECT_PATH=/var/lib/awx/projects
PROJECT_DATA_DIR=/var/lib/awx/projects
EOF

# Deploy AWX
make docker-compose-build
make docker-compose

# docker-compose.override.yml
version: '3.8'

services:
  web:
    environment:
      - AWX_ADMIN_USER=admin
      - AWX_ADMIN_PASSWORD=${AWX_ADMIN_PASSWORD}
    volumes:
      - awx_projects:/var/lib/awx/projects:rw
      - awx_logs:/var/log/tower:rw
    networks:
      - awx_network

  task:
    volumes:
      - awx_projects:/var/lib/awx/projects:rw
      - awx_logs:/var/log/tower:rw
    networks:
      - awx_network

  postgres:
    environment:
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=awx
      - POSTGRES_USER=awx
    volumes:
      - awx_postgres:/var/lib/postgresql/data:rw
    networks:
      - awx_network
    ports:
      - "5432:5432"  # Expose for external access

  redis:
    networks:
      - awx_network
    ports:
      - "6379:6379"  # Expose for monitoring

volumes:
  awx_postgres:
    driver: local
  awx_projects:
    driver: local
  awx_logs:
    driver: local

networks:
  awx_network:
    driver: bridge

# docker-compose.override.yml
version: '3.8'

services:
  web:
    environment:
      - AWX_ADMIN_USER=admin
      - AWX_ADMIN_PASSWORD=${AWX_ADMIN_PASSWORD}
    volumes:
      - awx_projects:/var/lib/awx/projects:rw
      - awx_logs:/var/log/tower:rw
    networks:
      - awx_network

  task:
    volumes:
      - awx_projects:/var/lib/awx/projects:rw
      - awx_logs:/var/log/tower:rw
    networks:
      - awx_network

  postgres:
    environment:
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=awx
      - POSTGRES_USER=awx
    volumes:
      - awx_postgres:/var/lib/postgresql/data:rw
    networks:
      - awx_network
    ports:
      - "5432:5432"  # Expose for external access

  redis:
    networks:
      - awx_network
    ports:
      - "6379:6379"  # Expose for monitoring

volumes:
  awx_postgres:
    driver: local
  awx_projects:
    driver: local
  awx_logs:
    driver: local

networks:
  awx_network:
    driver: bridge

# Install kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

# Install AWX Operator
kubectl apply -f https://raw.githubusercontent.com/ansible/awx-operator/devel/deploy/awx-operator.yaml

# Verify operator installation
kubectl get pods -n awx

# Install kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

# Install AWX Operator
kubectl apply -f https://raw.githubusercontent.com/ansible/awx-operator/devel/deploy/awx-operator.yaml

# Verify operator installation
kubectl get pods -n awx

# awx-production.yaml
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-production
  namespace: awx
spec:
  # Service configuration
  service_type: LoadBalancer
  service_labels:
    app: awx-production

  # Ingress configuration
  ingress_type: ingress
  ingress_class_name: nginx
  hostname: awx.company.com
  ingress_tls_secret: awx-tls-secret

  # Database configuration
  postgres_storage_class: fast-ssd
  postgres_storage_requirements:
    requests:
      storage: 100Gi
  postgres_resource_requirements:
    requests:
      cpu: "2"
      memory: "4Gi"
    limits:
      cpu: "4"
      memory: "8Gi"

  # AWX configuration
  web_resource_requirements:
    requests:
      cpu: "1"
      memory: "2Gi"
    limits:
      cpu: "2"
      memory: "4Gi"

  task_resource_requirements:
    requests:
      cpu: "1"
      memory: "2Gi"
    limits:
      cpu: "2"
      memory: "4Gi"

  # Storage configuration
  projects_persistence: true
  projects_storage_class: standard
  projects_storage_size: 50Gi

  # Security configuration
  admin_user: admin
  admin_password_secret: awx-admin-password
  secret_key_secret: awx-secret-key

  # High availability
  replicas: 2

  # Additional configuration
  extra_settings: |
    LOGGING['handlers']['console']['level'] = 'INFO'
    INSIGHTS_URL_BASE = 'https://console.redhat.com'
    AUTOMATION_ANALYTICS_URL = 'https://console.redhat.com'

# awx-production.yaml
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-production
  namespace: awx
spec:
  # Service configuration
  service_type: LoadBalancer
  service_labels:
    app: awx-production

  # Ingress configuration
  ingress_type: ingress
  ingress_class_name: nginx
  hostname: awx.company.com
  ingress_tls_secret: awx-tls-secret

  # Database configuration
  postgres_storage_class: fast-ssd
  postgres_storage_requirements:
    requests:
      storage: 100Gi
  postgres_resource_requirements:
    requests:
      cpu: "2"
      memory: "4Gi"
    limits:
      cpu: "4"
      memory: "8Gi"

  # AWX configuration
  web_resource_requirements:
    requests:
      cpu: "1"
      memory: "2Gi"
    limits:
      cpu: "2"
      memory: "4Gi"

  task_resource_requirements:
    requests:
      cpu: "1"
      memory: "2Gi"
    limits:
      cpu: "2"
      memory: "4Gi"

  # Storage configuration
  projects_persistence: true
  projects_storage_class: standard
  projects_storage_size: 50Gi

  # Security configuration
  admin_user: admin
  admin_password_secret: awx-admin-password
  secret_key_secret: awx-secret-key

  # High availability
  replicas: 2

  # Additional configuration
  extra_settings: |
    LOGGING['handlers']['console']['level'] = 'INFO'
    INSIGHTS_URL_BASE = 'https://console.redhat.com'
    AUTOMATION_ANALYTICS_URL = 'https://console.redhat.com'

# aws-eks-awx.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: awx-eks-config
data:
  aws-region: us-west-2
  storage-class: gp3
  load-balancer-type: nlb
---
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-eks
spec:
  service_type: LoadBalancer
  service_annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: nlb
    service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing

  postgres_storage_class: gp3
  projects_storage_class: efs

  # AWS-specific optimizations
  task_resource_requirements:
    requests:
      cpu: "500m"
      memory: "1Gi"
    limits:
      cpu: "2"
      memory: "4Gi"

# aws-eks-awx.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: awx-eks-config
data:
  aws-region: us-west-2
  storage-class: gp3
  load-balancer-type: nlb
---
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-eks
spec:
  service_type: LoadBalancer
  service_annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: nlb
    service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing

  postgres_storage_class: gp3
  projects_storage_class: efs

  # AWS-specific optimizations
  task_resource_requirements:
    requests:
      cpu: "500m"
      memory: "1Gi"
    limits:
      cpu: "2"
      memory: "4Gi"

#!/bin/bash
# awx-health-check.sh

AWX_URL="http://localhost"
ADMIN_USER="admin"
ADMIN_PASSWORD="password"

echo "=== AWX Health Check ==="

# Check web service
echo "1. Checking web interface..."
if curl -s -o /dev/null -w "%{http_code}" "$AWX_URL" | grep -q "200\|302"; then
    echo "   ✓ Web interface accessible"
else
    echo "   ✗ Web interface not accessible"
fi

# Check API
echo "2. Checking API..."
API_STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$AWX_URL/api/v2/ping/")
if [ "$API_STATUS" = "200" ]; then
    echo "   ✓ API responding"
else
    echo "   ✗ API not responding (HTTP $API_STATUS)"
fi

# Check database connectivity
echo "3. Checking database..."
if docker exec awx_postgres psql -U awx -d awx -c "SELECT 1;" > /dev/null 2>&1; then
    echo "   ✓ Database accessible"
else
    echo "   ✗ Database connection failed"
fi

# Check Redis
echo "4. Checking Redis..."
if docker exec awx_redis redis-cli ping | grep -q "PONG"; then
    echo "   ✓ Redis responding"
else
    echo "   ✗ Redis connection failed"
fi

# Check authentication
echo "5. Testing authentication..."
TOKEN=$(curl -s -X POST "$AWX_URL/api/v2/tokens/" \
    -H "Content-Type: application/json" \
    -d "{\"username\":\"$ADMIN_USER\",\"password\":\"$ADMIN_PASSWORD\"}" | \
    jq -r '.token // empty')

if [ -n "$TOKEN" ]; then
    echo "   ✓ Authentication successful"
else
    echo "   ✗ Authentication failed"
fi

echo "Health check complete."

#!/bin/bash
# awx-health-check.sh

AWX_URL="http://localhost"
ADMIN_USER="admin"
ADMIN_PASSWORD="password"

echo "=== AWX Health Check ==="

# Check web service
echo "1. Checking web interface..."
if curl -s -o /dev/null -w "%{http_code}" "$AWX_URL" | grep -q "200\|302"; then
    echo "   ✓ Web interface accessible"
else
    echo "   ✗ Web interface not accessible"
fi

# Check API
echo "2. Checking API..."
API_STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$AWX_URL/api/v2/ping/")
if [ "$API_STATUS" = "200" ]; then
    echo "   ✓ API responding"
else
    echo "   ✗ API not responding (HTTP $API_STATUS)"
fi

# Check database connectivity
echo "3. Checking database..."
if docker exec awx_postgres psql -U awx -d awx -c "SELECT 1;" > /dev/null 2>&1; then
    echo "   ✓ Database accessible"
else
    echo "   ✗ Database connection failed"
fi

# Check Redis
echo "4. Checking Redis..."
if docker exec awx_redis redis-cli ping | grep -q "PONG"; then
    echo "   ✓ Redis responding"
else
    echo "   ✗ Redis connection failed"
fi

# Check authentication
echo "5. Testing authentication..."
TOKEN=$(curl -s -X POST "$AWX_URL/api/v2/tokens/" \
    -H "Content-Type: application/json" \
    -d "{\"username\":\"$ADMIN_USER\",\"password\":\"$ADMIN_PASSWORD\"}" | \
    jq -r '.token // empty')

if [ -n "$TOKEN" ]; then
    echo "   ✓ Authentication successful"
else
    echo "   ✗ Authentication failed"
fi

echo "Health check complete."

# View all AWX containers
docker ps | grep awx

# Check container logs
docker logs awx_web
docker logs awx_task
docker logs awx_postgres
docker logs awx_redis

# Access AWX database
docker exec -it awx_postgres psql -U awx -d awx

# Check AWX configuration
docker exec -it awx_web awx-manage shell

# Monitor resource usage
docker stats

# Test connectivity to managed hosts
docker exec -it awx_task ansible all -m ping -i /tmp/inventory

# View all AWX containers
docker ps | grep awx

# Check container logs
docker logs awx_web
docker logs awx_task
docker logs awx_postgres
docker logs awx_redis

# Access AWX database
docker exec -it awx_postgres psql -U awx -d awx

# Check AWX configuration
docker exec -it awx_web awx-manage shell

# Monitor resource usage
docker stats

# Test connectivity to managed hosts
docker exec -it awx_task ansible all -m ping -i /tmp/inventory

#!/bin/bash
# awx-backup.sh

BACKUP_DIR="/backup/awx/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"

echo "Starting AWX backup to $BACKUP_DIR"

# Database backup
echo "Backing up PostgreSQL database..."
docker exec awx_postgres pg_dump -U awx awx > "$BACKUP_DIR/awx_database.sql"

# Projects backup
echo "Backing up project files..."
docker run --rm -v awx_projects:/source -v "$BACKUP_DIR":/backup \
    alpine tar czf /backup/projects.tar.gz -C /source .

# Configuration backup
echo "Backing up configuration..."
cp .env "$BACKUP_DIR/"
docker-compose config > "$BACKUP_DIR/docker-compose.yml"

# Create backup manifest
cat > "$BACKUP_DIR/manifest.json" << EOF
{
  "backup_date": "$(date -Iseconds)",
  "awx_version": "$(docker exec awx_web awx-manage version)",
  "database_size": "$(du -h $BACKUP_DIR/awx_database.sql | cut -f1)",
  "projects_size": "$(du -h $BACKUP_DIR/projects.tar.gz | cut -f1)"
}
EOF

echo "Backup completed: $BACKUP_DIR"

#!/bin/bash
# awx-backup.sh

BACKUP_DIR="/backup/awx/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"

echo "Starting AWX backup to $BACKUP_DIR"

# Database backup
echo "Backing up PostgreSQL database..."
docker exec awx_postgres pg_dump -U awx awx > "$BACKUP_DIR/awx_database.sql"

# Projects backup
echo "Backing up project files..."
docker run --rm -v awx_projects:/source -v "$BACKUP_DIR":/backup \
    alpine tar czf /backup/projects.tar.gz -C /source .

# Configuration backup
echo "Backing up configuration..."
cp .env "$BACKUP_DIR/"
docker-compose config > "$BACKUP_DIR/docker-compose.yml"

# Create backup manifest
cat > "$BACKUP_DIR/manifest.json" << EOF
{
  "backup_date": "$(date -Iseconds)",
  "awx_version": "$(docker exec awx_web awx-manage version)",
  "database_size": "$(du -h $BACKUP_DIR/awx_database.sql | cut -f1)",
  "projects_size": "$(du -h $BACKUP_DIR/projects.tar.gz | cut -f1)"
}
EOF

echo "Backup completed: $BACKUP_DIR"

#!/bin/bash
# automated-backup.sh

BACKUP_BASE="/backup/awx"
RETENTION_DAYS=30

# Create daily backup
/usr/local/bin/awx-backup.sh

# Cleanup old backups
find "$BACKUP_BASE" -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \;

# Upload to cloud storage (optional)
aws s3 sync "$BACKUP_BASE" s3://company-awx-backups/ --delete

#!/bin/bash
# automated-backup.sh

BACKUP_BASE="/backup/awx"
RETENTION_DAYS=30

# Create daily backup
/usr/local/bin/awx-backup.sh

# Cleanup old backups
find "$BACKUP_BASE" -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \;

# Upload to cloud storage (optional)
aws s3 sync "$BACKUP_BASE" s3://company-awx-backups/ --delete

# disaster-recovery-plan.yml
recovery_procedures:

  complete_restore:
    steps:
      1. "Deploy fresh AWX instance"
      2. "Stop all services"
      3. "Restore database from backup"
      4. "Restore project files"
      5. "Restore configuration"
      6. "Start services and verify"

    commands: |
      # Stop services
      docker-compose down

      # Restore database
      docker-compose up -d postgres
      docker exec -i awx_postgres psql -U awx awx < /backup/awx_database.sql

      # Restore projects
      docker run --rm -v awx_projects:/target -v /backup:/source \
          alpine tar xzf /source/projects.tar.gz -C /target

      # Start all services
      docker-compose up -d

  partial_restore:
    database_only: |
      docker exec -i awx_postgres psql -U awx awx < /backup/awx_database.sql
      docker-compose restart web task

    projects_only: |
      docker run --rm -v awx_projects:/target -v /backup:/source \
          alpine tar xzf /source/projects.tar.gz -C /target

# disaster-recovery-plan.yml
recovery_procedures:

  complete_restore:
    steps:
      1. "Deploy fresh AWX instance"
      2. "Stop all services"
      3. "Restore database from backup"
      4. "Restore project files"
      5. "Restore configuration"
      6. "Start services and verify"

    commands: |
      # Stop services
      docker-compose down

      # Restore database
      docker-compose up -d postgres
      docker exec -i awx_postgres psql -U awx awx < /backup/awx_database.sql

      # Restore projects
      docker run --rm -v awx_projects:/target -v /backup:/source \
          alpine tar xzf /source/projects.tar.gz -C /target

      # Start all services
      docker-compose up -d

  partial_restore:
    database_only: |
      docker exec -i awx_postgres psql -U awx awx < /backup/awx_database.sql
      docker-compose restart web task

    projects_only: |
      docker run --rm -v awx_projects:/target -v /backup:/source \
          alpine tar xzf /source/projects.tar.gz -C /target

# Clone AWX repository
git clone https://github.com/ansible/awx.git
cd awx

# Create inventory file
cat > installer/inventory << EOF
[all:vars]
docker_compose_dir=/opt/awx
host_port=80
host_port_ssl=443
docker_compose=true
create_preload_data=True
admin_user=admin
admin_password=password
secret_key=awxsecret
EOF

# Install AWX
cd installer
ansible-playbook -i inventory install.yml

# Clone AWX repository
git clone https://github.com/ansible/awx.git
cd awx

# Create inventory file
cat > installer/inventory << EOF
[all:vars]
docker_compose_dir=/opt/awx
host_port=80
host_port_ssl=443
docker_compose=true
create_preload_data=True
admin_user=admin
admin_password=password
secret_key=awxsecret
EOF

# Install AWX
cd installer
ansible-playbook -i inventory install.yml

# awx-deployment.yaml
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-demo
spec:
  service_type: nodeport
  nodeport_port: 30080
  admin_user: admin
  admin_password_secret: awx-admin-password

# awx-deployment.yaml
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-demo
spec:
  service_type: nodeport
  nodeport_port: 30080
  admin_user: admin
  admin_password_secret: awx-admin-password

# Organization structure example
organization:
  name: "Production Environment"
  description: "Production infrastructure automation"

  teams:
    - name: "Infrastructure Team"
      permissions: ["admin"]
      members: ["devops-lead", "senior-sre"]

    - name: "Development Team"
      permissions: ["execute", "read"]
      members: ["dev-user1", "dev-user2"]

  resources:
    projects: ["web-app-deployment", "database-management"]
    inventories: ["production-servers", "staging-environment"]
    credentials: ["aws-production", "ssh-keys"]

# Organization structure example
organization:
  name: "Production Environment"
  description: "Production infrastructure automation"

  teams:
    - name: "Infrastructure Team"
      permissions: ["admin"]
      members: ["devops-lead", "senior-sre"]

    - name: "Development Team"
      permissions: ["execute", "read"]
      members: ["dev-user1", "dev-user2"]

  resources:
    projects: ["web-app-deployment", "database-management"]
    inventories: ["production-servers", "staging-environment"]
    credentials: ["aws-production", "ssh-keys"]

# Advanced project configuration
project:
  name: "Multi-Cloud Infrastructure"
  scm_type: "git"
  scm_url: "https://github.com/company/ansible-playbooks.git"
  scm_branch: "main"
  scm_clean: true
  scm_delete_on_update: true
  scm_update_on_launch: true
  scm_update_cache_timeout: 300

  # Webhook integration
  webhook_service: "github"
  webhook_credential: "github-webhook-token"

  # Custom environment
  custom_virtualenv: "/var/lib/awx/venv/ansible-custom"

  # Execution environment
  execution_environment: "quay.io/ansible/creator-base:latest"

  playbooks:
    infrastructure:
      - "aws/ec2-provision.yml"
      - "aws/vpc-setup.yml"
      - "gcp/compute-deploy.yml"
      - "azure/vm-creation.yml"

    applications:
      - "apps/web-server-setup.yml"
      - "apps/database-configuration.yml"
      - "apps/load-balancer-config.yml"

    maintenance:
      - "maintenance/system-updates.yml"
      - "maintenance/log-rotation.yml"
      - "maintenance/backup-procedures.yml"

# Advanced project configuration
project:
  name: "Multi-Cloud Infrastructure"
  scm_type: "git"
  scm_url: "https://github.com/company/ansible-playbooks.git"
  scm_branch: "main"
  scm_clean: true
  scm_delete_on_update: true
  scm_update_on_launch: true
  scm_update_cache_timeout: 300

  # Webhook integration
  webhook_service: "github"
  webhook_credential: "github-webhook-token"

  # Custom environment
  custom_virtualenv: "/var/lib/awx/venv/ansible-custom"

  # Execution environment
  execution_environment: "quay.io/ansible/creator-base:latest"

  playbooks:
    infrastructure:
      - "aws/ec2-provision.yml"
      - "aws/vpc-setup.yml"
      - "gcp/compute-deploy.yml"
      - "azure/vm-creation.yml"

    applications:
      - "apps/web-server-setup.yml"
      - "apps/database-configuration.yml"
      - "apps/load-balancer-config.yml"

    maintenance:
      - "maintenance/system-updates.yml"
      - "maintenance/log-rotation.yml"
      - "maintenance/backup-procedures.yml"

# production-inventory.ini
[webservers]
web01.company.com ansible_host=10.0.1.10
web02.company.com ansible_host=10.0.1.11
web03.company.com ansible_host=10.0.1.12

[databases]
db01.company.com ansible_host=10.0.2.10
db02.company.com ansible_host=10.0.2.11

[loadbalancers]
lb01.company.com ansible_host=10.0.3.10

# Group variables
[webservers:vars]
http_port=80
https_port=443
app_user=webapp

[databases:vars]
db_port=5432
backup_schedule="0 2 * * *"

[all:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/var/lib/awx/.ssh/id_rsa
environment=production

# production-inventory.ini
[webservers]
web01.company.com ansible_host=10.0.1.10
web02.company.com ansible_host=10.0.1.11
web03.company.com ansible_host=10.0.1.12

[databases]
db01.company.com ansible_host=10.0.2.10
db02.company.com ansible_host=10.0.2.11

[loadbalancers]
lb01.company.com ansible_host=10.0.3.10

# Group variables
[webservers:vars]
http_port=80
https_port=443
app_user=webapp

[databases:vars]
db_port=5432
backup_schedule="0 2 * * *"

[all:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/var/lib/awx/.ssh/id_rsa
environment=production

# multi-cloud-inventory.yml
---
# AWS Configuration
aws_inventory:
  plugin: amazon.aws.aws_ec2
  regions:
    - us-east-1
    - us-west-2
    - eu-west-1

  # Advanced filtering
  filters:
    instance-state-name: running
    "tag:Environment": ["production", "staging"]
    "tag:Managed": "AWX"

  # Grouping strategies
  keyed_groups:
    # Group by environment
    - prefix: env
      key: tags.Environment | default('untagged')

    # Group by application
    - prefix: app
      key: tags.Application | default('unknown')

    # Group by instance type family
    - prefix: family
      key: instance_type.split('.')[0]

    # Group by availability zone
    - prefix: az
      key: placement.availability_zone

    # Group by VPC
    - prefix: vpc
      key: vpc_id

  # Host naming and variables
  hostnames:
    - tag:Name
    - private-ip-address
    - public-ip-address

  compose:
    ansible_host: public_ip_address | default(private_ip_address)
    ansible_user: >-
      'ec2-user' if platform.startswith('amzn') or platform.startswith('rhel')
      else 'ubuntu' if platform.startswith('ubuntu')
      else 'admin' if platform.startswith('debian')
      else 'centos' if platform.startswith('centos')
      else 'root'
    cloud_provider: "'aws'"
    region: placement.region
    cost_center: tags.CostCenter | default('unknown')
    backup_enabled: tags.BackupEnabled | default(false)

---
# GCP Configuration  
gcp_inventory:
  plugin: google.cloud.gcp_compute
  projects:
    - production-project-123
    - staging-project-456

  zones:
    - us-central1-a
    - us-central1-b
    - us-west1-a
    - europe-west1-b

  # Authentication
  auth_kind: serviceaccount
  service_account_file: /path/to/service-account.json

  # Filtering
  filters:
    - status = RUNNING
    - labels.managed = awx
    - labels.environment = (production OR staging)

  # Grouping
  keyed_groups:
    - prefix: gcp_env
      key: labels.environment | default('untagged')

    - prefix: gcp_app
      key: labels.application | default('unknown')

    - prefix: gcp_zone
      key: zone.split('/')[-1]

    - prefix: gcp_type
      key: machineType.split('/')[-1].split('-')[0]

  # Variables
  compose:
    ansible_host: networkInterfaces[0].accessConfigs[0].natIP | default(networkInterfaces[0].networkIP)
    ansible_user: "'ubuntu'"
    cloud_provider: "'gcp'"
    machine_type: machineType.split('/')[-1]
    zone_name: zone.split('/')[-1]
    project_id: "'{{ gcp_project }}'"

---
# Azure Configuration
azure_inventory:
  plugin: azure.azcollection.azure_rm

  # Subscription and authentication
  include_vm_resource_groups:
    - production-rg
    - staging-rg
    - development-rg

  # Conditional compilation based on tags
  conditional_groups:
    azure_prod: tags.environment == "production"
    azure_staging: tags.environment == "staging"
    azure_web: tags.role == "webserver"
    azure_db: tags.role == "database"
    azure_monitoring: tags.monitoring == "enabled"

  # Grouping strategies
  keyed_groups:
    - prefix: azure_env
      key: tags.environment | default('untagged')

    - prefix: azure_location
      key: location

    - prefix: azure_size
      key: properties.hardwareProfile.vmSize

    - prefix: azure_os
      key: properties.storageProfile.osDisk.osType

  # Host configuration
  hostnames:
    - public_ipv4_addresses
    - private_ipv4_addresses
    - name

  compose:
    ansible_host: public_ipv4_addresses[0] | default(private_ipv4_addresses[0])
    ansible_user: "'azureuser'"
    cloud_provider: "'azure'"
    vm_size: properties.hardwareProfile.vmSize
    os_type: properties.storageProfile.osDisk.osType
    resource_group: resourceGroup

# multi-cloud-inventory.yml
---
# AWS Configuration
aws_inventory:
  plugin: amazon.aws.aws_ec2
  regions:
    - us-east-1
    - us-west-2
    - eu-west-1

  # Advanced filtering
  filters:
    instance-state-name: running
    "tag:Environment": ["production", "staging"]
    "tag:Managed": "AWX"

  # Grouping strategies
  keyed_groups:
    # Group by environment
    - prefix: env
      key: tags.Environment | default('untagged')

    # Group by application
    - prefix: app
      key: tags.Application | default('unknown')

    # Group by instance type family
    - prefix: family
      key: instance_type.split('.')[0]

    # Group by availability zone
    - prefix: az
      key: placement.availability_zone

    # Group by VPC
    - prefix: vpc
      key: vpc_id

  # Host naming and variables
  hostnames:
    - tag:Name
    - private-ip-address
    - public-ip-address

  compose:
    ansible_host: public_ip_address | default(private_ip_address)
    ansible_user: >-
      'ec2-user' if platform.startswith('amzn') or platform.startswith('rhel')
      else 'ubuntu' if platform.startswith('ubuntu')
      else 'admin' if platform.startswith('debian')
      else 'centos' if platform.startswith('centos')
      else 'root'
    cloud_provider: "'aws'"
    region: placement.region
    cost_center: tags.CostCenter | default('unknown')
    backup_enabled: tags.BackupEnabled | default(false)

---
# GCP Configuration  
gcp_inventory:
  plugin: google.cloud.gcp_compute
  projects:
    - production-project-123
    - staging-project-456

  zones:
    - us-central1-a
    - us-central1-b
    - us-west1-a
    - europe-west1-b

  # Authentication
  auth_kind: serviceaccount
  service_account_file: /path/to/service-account.json

  # Filtering
  filters:
    - status = RUNNING
    - labels.managed = awx
    - labels.environment = (production OR staging)

  # Grouping
  keyed_groups:
    - prefix: gcp_env
      key: labels.environment | default('untagged')

    - prefix: gcp_app
      key: labels.application | default('unknown')

    - prefix: gcp_zone
      key: zone.split('/')[-1]

    - prefix: gcp_type
      key: machineType.split('/')[-1].split('-')[0]

  # Variables
  compose:
    ansible_host: networkInterfaces[0].accessConfigs[0].natIP | default(networkInterfaces[0].networkIP)
    ansible_user: "'ubuntu'"
    cloud_provider: "'gcp'"
    machine_type: machineType.split('/')[-1]
    zone_name: zone.split('/')[-1]
    project_id: "'{{ gcp_project }}'"

---
# Azure Configuration
azure_inventory:
  plugin: azure.azcollection.azure_rm

  # Subscription and authentication
  include_vm_resource_groups:
    - production-rg
    - staging-rg
    - development-rg

  # Conditional compilation based on tags
  conditional_groups:
    azure_prod: tags.environment == "production"
    azure_staging: tags.environment == "staging"
    azure_web: tags.role == "webserver"
    azure_db: tags.role == "database"
    azure_monitoring: tags.monitoring == "enabled"

  # Grouping strategies
  keyed_groups:
    - prefix: azure_env
      key: tags.environment | default('untagged')

    - prefix: azure_location
      key: location

    - prefix: azure_size
      key: properties.hardwareProfile.vmSize

    - prefix: azure_os
      key: properties.storageProfile.osDisk.osType

  # Host configuration
  hostnames:
    - public_ipv4_addresses
    - private_ipv4_addresses
    - name

  compose:
    ansible_host: public_ipv4_addresses[0] | default(private_ipv4_addresses[0])
    ansible_user: "'azureuser'"
    cloud_provider: "'azure'"
    vm_size: properties.hardwareProfile.vmSize
    os_type: properties.storageProfile.osDisk.osType
    resource_group: resourceGroup

# Smart inventory filters for different scenarios
smart_inventories:

  # Production web tier across all clouds
  production_web_tier:
    name: "Production Web Servers"
    description: "All production web servers across AWS, GCP, and Azure"
    filter: >
      (variables__cloud_provider="aws" and group_names__contains="env_production" and group_names__contains="app_web") or
      (variables__cloud_provider="gcp" and group_names__contains="gcp_env_production" and group_names__contains="gcp_app_web") or
      (variables__cloud_provider="azure" and group_names__contains="azure_env_production" and group_names__contains="azure_web")

    variables:
      deployment_tier: "web"
      monitoring_enabled: true
      backup_schedule: "daily"

  # High-performance compute instances
  compute_intensive:
    name: "High-Performance Compute"
    description: "Instances optimized for compute-intensive workloads"
    filter: >
      (variables__instance_type__startswith="c5" or 
       variables__instance_type__startswith="c6i" or
       variables__machine_type__startswith="c2-" or
       variables__machine_type__startswith="n2-highcpu" or
       variables__vm_size__startswith="F") and
      variables__status="running"

    variables:
      performance_tier: "high"
      monitoring_interval: 30
      cost_optimization: false

  # Multi-region disaster recovery
  disaster_recovery_targets:
    name: "Disaster Recovery Infrastructure"
    description: "Infrastructure designated for disaster recovery"
    filter: >
      variables__tags__DR="enabled" or
      variables__labels__disaster_recovery="true" or
      variables__backup_enabled=true

    variables:
      backup_retention: "30days"
      replication_enabled: true
      priority: "high"

  # Cost optimization candidates
  cost_optimization_targets:
    name: "Cost Optimization Candidates"
    description: "Resources that could benefit from cost optimization"
    filter: >
      (variables__instance_type__startswith="m5.large" or
       variables__instance_type__startswith="m5.xlarge") and
       variables__cpu_utilization__lt=20 and
       variables__age__gt=30

    variables:
      optimization_candidate: true
      recommended_action: "downsize"
      estimated_savings: "calculated"

  # Security compliance group
  compliance_required:
    name: "Compliance-Required Systems"
    description: "Systems requiring special security compliance"
    filter: >
      variables__tags__Compliance="PCI-DSS" or
      variables__tags__Compliance="HIPAA" or
      variables__tags__Compliance="SOC2" or
      variables__labels__compliance="required"

    variables:
      security_scan_frequency: "daily"
      patch_window: "emergency-only"
      audit_logging: "enhanced"
      encryption_required: true

# Smart inventory filters for different scenarios
smart_inventories:

  # Production web tier across all clouds
  production_web_tier:
    name: "Production Web Servers"
    description: "All production web servers across AWS, GCP, and Azure"
    filter: >
      (variables__cloud_provider="aws" and group_names__contains="env_production" and group_names__contains="app_web") or
      (variables__cloud_provider="gcp" and group_names__contains="gcp_env_production" and group_names__contains="gcp_app_web") or
      (variables__cloud_provider="azure" and group_names__contains="azure_env_production" and group_names__contains="azure_web")

    variables:
      deployment_tier: "web"
      monitoring_enabled: true
      backup_schedule: "daily"

  # High-performance compute instances
  compute_intensive:
    name: "High-Performance Compute"
    description: "Instances optimized for compute-intensive workloads"
    filter: >
      (variables__instance_type__startswith="c5" or 
       variables__instance_type__startswith="c6i" or
       variables__machine_type__startswith="c2-" or
       variables__machine_type__startswith="n2-highcpu" or
       variables__vm_size__startswith="F") and
      variables__status="running"

    variables:
      performance_tier: "high"
      monitoring_interval: 30
      cost_optimization: false

  # Multi-region disaster recovery
  disaster_recovery_targets:
    name: "Disaster Recovery Infrastructure"
    description: "Infrastructure designated for disaster recovery"
    filter: >
      variables__tags__DR="enabled" or
      variables__labels__disaster_recovery="true" or
      variables__backup_enabled=true

    variables:
      backup_retention: "30days"
      replication_enabled: true
      priority: "high"

  # Cost optimization candidates
  cost_optimization_targets:
    name: "Cost Optimization Candidates"
    description: "Resources that could benefit from cost optimization"
    filter: >
      (variables__instance_type__startswith="m5.large" or
       variables__instance_type__startswith="m5.xlarge") and
       variables__cpu_utilization__lt=20 and
       variables__age__gt=30

    variables:
      optimization_candidate: true
      recommended_action: "downsize"
      estimated_savings: "calculated"

  # Security compliance group
  compliance_required:
    name: "Compliance-Required Systems"
    description: "Systems requiring special security compliance"
    filter: >
      variables__tags__Compliance="PCI-DSS" or
      variables__tags__Compliance="HIPAA" or
      variables__tags__Compliance="SOC2" or
      variables__labels__compliance="required"

    variables:
      security_scan_frequency: "daily"
      patch_window: "emergency-only"
      audit_logging: "enhanced"
      encryption_required: true

#!/usr/bin/env python3
"""
Advanced Multi-Source Dynamic Inventory Script
Combines data from multiple sources including cloud providers, CMDBs, and monitoring systems
"""

import json
import sys
import argparse
import requests
import boto3
from google.cloud import compute_v1
from azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
import yaml
import os
from datetime import datetime, timedelta

class MultiSourceInventory:
    def __init__(self):
        self.inventory = {
            '_meta': {
                'hostvars': {}
            }
        }
        self.config = self.load_config()

    def load_config(self):
        """Load configuration from YAML file"""
        config_path = os.environ.get('INVENTORY_CONFIG', 'inventory_config.yml')
        try:
            with open(config_path, 'r') as f:
                return yaml.safe_load(f)
        except FileNotFoundError:
            return self.default_config()

    def default_config(self):
        """Default configuration if file not found"""
        return {
            'sources': {
                'aws': {'enabled': True, 'regions': ['us-east-1', 'us-west-2']},
                'gcp': {'enabled': True, 'projects': []},
                'azure': {'enabled': True, 'subscription_ids': []},
                'cmdb': {'enabled': False, 'url': '', 'token': ''},
                'monitoring': {'enabled': False, 'prometheus_url': ''}
            },
            'enrichment': {
                'add_monitoring_data': True,
                'add_cost_data': True,
                'add_security_scan_results': False
            },
            'filtering': {
                'exclude_stopped': True,
                'minimum_uptime_hours': 1,
                'include_tags': ['Managed=AWX']
            }
        }

    def get_aws_instances(self):
        """Fetch AWS EC2 instances"""
        if not self.config['sources']['aws']['enabled']:
            return

        for region in self.config['sources']['aws']['regions']:
            try:
                ec2 = boto3.client('ec2', region_name=region)

                # Build filters
                filters = [
                    {'Name': 'instance-state-name', 'Values': ['running']}
                ]

                for tag_filter in self.config['filtering']['include_tags']:
                    key, value = tag_filter.split('=')
                    filters.append({
                        'Name': f'tag:{key}',
                        'Values': [value]
                    })

                response = ec2.describe_instances(Filters=filters)

                for reservation in response['Reservations']:
                    for instance in reservation['Instances']:
                        self.process_aws_instance(instance, region)

            except Exception as e:
                print(f"Error fetching AWS instances in {region}: {e}", file=sys.stderr)

    def process_aws_instance(self, instance, region):
        """Process individual AWS instance"""
        instance_id = instance['InstanceId']

        # Extract tags
        tags = {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])}

        # Determine hostname
        hostname = (
            tags.get('Name') or
            instance.get('PublicIpAddress') or
            instance.get('PrivateIpAddress') or
            instance_id
        )

        # Build host variables
        hostvars = {
            'ansible_host': instance.get('PublicIpAddress') or instance.get('PrivateIpAddress'),
            'ansible_user': self.determine_ssh_user(instance.get('Platform', 'linux')),
            'instance_id': instance_id,
            'instance_type': instance['InstanceType'],
            'cloud_provider': 'aws',
            'region': region,
            'availability_zone': instance['Placement']['AvailabilityZone'],
            'vpc_id': instance['VpcId'],
            'subnet_id': instance['SubnetId'],
            'private_ip': instance.get('PrivateIpAddress'),
            'public_ip': instance.get('PublicIpAddress'),
            'launch_time': instance['LaunchTime'].isoformat(),
            'state': instance['State']['Name'],
            'tags': tags,
            'architecture': instance.get('Architecture', 'x86_64'),
            'hypervisor': instance.get('Hypervisor', 'xen'),
            'monitoring': instance.get('Monitoring', {}).get('State', 'disabled'),
            'security_groups': [sg['GroupName'] for sg in instance.get('SecurityGroups', [])]
        }

        # Add enrichment data
        if self.config['enrichment']['add_monitoring_data']:
            hostvars.update(self.get_monitoring_data(instance_id, 'aws'))

        if self.config['enrichment']['add_cost_data']:
            hostvars.update(self.get_cost_data(instance_id, 'aws'))

        # Store host variables
        self.inventory['_meta']['hostvars'][hostname] = hostvars

        # Add to groups
        self.add_to_groups(hostname, hostvars)

    def get_gcp_instances(self):
        """Fetch GCP Compute Engine instances"""
        if not self.config['sources']['gcp']['enabled']:
            return

        try:
            client = compute_v1.InstancesClient()

            for project in self.config['sources']['gcp']['projects']:
                # List all zones in project
                zones_client = compute_v1.ZonesClient()
                zones = zones_client.list(project=project)

                for zone in zones:
                    try:
                        instances = client.list(project=project, zone=zone.name)
                        for instance in instances:
                            if instance.status == 'RUNNING':
                                self.process_gcp_instance(instance, project, zone.name)
                    except Exception as e:
                        print(f"Error fetching GCP instances in {zone.name}: {e}", file=sys.stderr)

        except Exception as e:
            print(f"Error initializing GCP client: {e}", file=sys.stderr)

    def process_gcp_instance(self, instance, project, zone):
        """Process individual GCP instance"""
        name = instance.name

        # Extract labels (GCP's version of tags)
        labels = dict(instance.labels) if instance.labels else {}

        # Get network interfaces
        network_interface = instance.network_interfaces[0] if instance.network_interfaces else {}
        internal_ip = network_interface.network_i_p if network_interface else None
        external_ip = None

        if network_interface and network_interface.access_configs:
            external_ip = network_interface.access_configs[0].nat_i_p

        # Build host variables
        hostvars = {
            'ansible_host': external_ip or internal_ip,
            'ansible_user': 'ubuntu',  # or determine based on image
            'instance_name': name,
            'machine_type': instance.machine_type.split('/')[-1],
            'cloud_provider': 'gcp',
            'project': project,
            'zone': zone,
            'region': '-'.join(zone.split('-')[:-1]),
            'internal_ip': internal_ip,
            'external_ip': external_ip,
            'creation_timestamp': instance.creation_timestamp,
            'status': instance.status,
            'labels': labels,
            'self_link': instance.self_link,
            'can_ip_forward': instance.can_ip_forward,
            'scheduling': {
                'automatic_restart': instance.scheduling.automatic_restart,
                'on_host_maintenance': instance.scheduling.on_host_maintenance,
                'preemptible': instance.scheduling.preemptible
            }
        }

        # Add disk information
        if instance.disks:
            hostvars['disks'] = []
            for disk in instance.disks:
                disk_info = {
                    'device_name': disk.device_name,
                    'boot': disk.boot,
                    'auto_delete': disk.auto_delete,
                    'type': disk.type_,
                    'mode': disk.mode
                }
                hostvars['disks'].append(disk_info)

        # Store host variables
        self.inventory['_meta']['hostvars'][name] = hostvars

        # Add to groups
        self.add_to_groups(name, hostvars)

    def get_azure_instances(self):
        """Fetch Azure Virtual Machines"""
        if not self.config['sources']['azure']['enabled']:
            return

        try:
            credential = DefaultAzureCredential()

            for subscription_id in self.config['sources']['azure']['subscription_ids']:
                compute_client = ComputeManagementClient(credential, subscription_id)

                # Get all VMs in subscription
                vms = compute_client.virtual_machines.list_all()

                for vm in vms:
                    if vm.instance_view and vm.instance_view.statuses:
                        # Check if VM is running
                        power_state = next(
                            (status.display_status for status in vm.instance_view.statuses 
                             if status.code.startswith('PowerState/')), 
                            'Unknown'
                        )

                        if 'running' in power_state.lower():
                            self.process_azure_instance(vm, subscription_id)

        except Exception as e:
            print(f"Error fetching Azure instances: {e}", file=sys.stderr)

    def process_azure_instance(self, vm, subscription_id):
        """Process individual Azure instance"""
        name = vm.name

        # Extract tags
        tags = dict(vm.tags) if vm.tags else {}

        # Build host variables
        hostvars = {
            'ansible_host': None,  # Will be filled by network interface lookup
            'ansible_user': 'azureuser',
            'vm_name': name,
            'vm_size': vm.hardware_profile.vm_size,
            'cloud_provider': 'azure',
            'subscription_id': subscription_id,
            'resource_group': vm.id.split('/')[4],  # Extract from resource ID
            'location': vm.location,
            'vm_id': vm.vm_id,
            'tags': tags,
            'os_type': vm.storage_profile.os_disk.os_type.value if vm.storage_profile.os_disk.os_type else 'Unknown',
            'provisioning_state': vm.provisioning_state
        }

        # Store host variables
        self.inventory['_meta']['hostvars'][name] = hostvars

        # Add to groups
        self.add_to_groups(name, hostvars)

    def add_to_groups(self, hostname, hostvars):
        """Add host to appropriate groups based on its properties"""

        # Cloud provider group
        cloud_group = f"{hostvars['cloud_provider']}_instances"
        self.add_host_to_group(hostname, cloud_group)

        # Environment group (from tags/labels)
        env = (
            hostvars.get('tags', {}).get('Environment') or
            hostvars.get('tags', {}).get('environment') or
            hostvars.get('labels', {}).get('environment') or
            'untagged'
        )
        self.add_host_to_group(hostname, f"env_{env}")

        # Application group
        app = (
            hostvars.get('tags', {}).get('Application') or
            hostvars.get('tags', {}).get('application') or
            hostvars.get('labels', {}).get('application') or
            'unknown'
        )
        self.add_host_to_group(hostname, f"app_{app}")

        # Region group
        region = hostvars.get('region', 'unknown')
        self.add_host_to_group(hostname, f"region_{region}")

        # Instance type/size group
        instance_type = (
            hostvars.get('instance_type') or
            hostvars.get('machine_type') or
            hostvars.get('vm_size') or
            'unknown'
        )
        self.add_host_to_group(hostname, f"type_{instance_type}")

        # Add custom groups based on configuration
        self.add_custom_groups(hostname, hostvars)

    def add_host_to_group(self, hostname, group_name):
        """Add host to specified group"""
        if group_name not in self.inventory:
            self.inventory[group_name] = {'hosts': []}

        if hostname not in self.inventory[group_name]['hosts']:
            self.inventory[group_name]['hosts'].append(hostname)

    def add_custom_groups(self, hostname, hostvars):
        """Add hosts to custom groups based on complex logic"""

        # High availability group
        if any([
            hostvars.get('tags', {}).get('HighAvailability') == 'true',
            hostvars.get('labels', {}).get('high_availability') == 'true',
            'ha' in hostvars.get('instance_type', '').lower()
        ]):
            self.add_host_to_group(hostname, 'high_availability')

        # Monitoring-enabled group
        if any([
            hostvars.get('monitoring') == 'enabled',
            hostvars.get('tags', {}).get('Monitoring') == 'enabled',
            hostvars.get('labels', {}).get('monitoring') == 'enabled'
        ]):
            self.add_host_to_group(hostname, 'monitoring_enabled')

        # Cost-sensitive group
        cost_sensitive_types = ['t2.', 't3.', 'f1-micro', 'g1-small', 'Standard_B']
        if any(cs_type in hostvars.get('instance_type', '') or 
               cs_type in hostvars.get('machine_type', '') or
               cs_type in hostvars.get('vm_size', '') for cs_type in cost_sensitive_types):
            self.add_host_to_group(hostname, 'cost_optimized')

    def determine_ssh_user(self, platform):
        """Determine SSH user based on platform"""
        platform_users = {
            'amazon': 'ec2-user',
            'rhel': 'ec2-user',
            'centos': 'centos',
            'ubuntu': 'ubuntu',
            'debian': 'admin',
            'suse': 'ec2-user',
            'windows': 'Administrator'
        }

        for platform_key, user in platform_users.items():
            if platform_key in platform.lower():
                return user

        return 'root'  # Default fallback

    def get_monitoring_data(self, instance_id, cloud_provider):
        """Fetch monitoring data for instance"""
        if not self.config['enrichment']['add_monitoring_data']:
            return {}

        try:
            # Simulate monitoring data - replace with actual monitoring system calls
            monitoring_data = {
                'cpu_utilization_avg': 45.2,
                'memory_utilization_avg': 62.8,
                'disk_utilization_avg': 23.1,
                'network_in_bytes': 1024000,
                'network_out_bytes': 2048000,
                'last_monitoring_update': datetime.now().isoformat()
            }
            return monitoring_data
        except Exception:
            return {}

    def get_cost_data(self, instance_id, cloud_provider):
        """Fetch cost data for instance"""
        if not self.config['enrichment']['add_cost_data']:
            return {}

        try:
            # Simulate cost data - replace with actual cost management API calls
            cost_data = {
                'monthly_cost_estimate': 89.50,
                'daily_cost_average': 2.98,
                'cost_center': 'IT-Infrastructure',
                'cost_optimization_score': 7.2,
                'last_cost_update': datetime.now().isoformat()
            }
            return cost_data
        except Exception:
            return {}

    def run(self):
        """Main execution method"""
        # Fetch from all enabled sources
        self.get_aws_instances()
        self.get_gcp_instances()
        self.get_azure_instances()

        # Apply post-processing filters
        self.apply_filters()

        return self.inventory

    def apply_filters(self):
        """Apply post-processing filters"""
        # Remove hosts that don't meet minimum uptime
        min_uptime = self.config['filtering'].get('minimum_uptime_hours', 0)
        if min_uptime > 0:
            cutoff_time = datetime.now() - timedelta(hours=min_uptime)
            hosts_to_remove = []

            for hostname, hostvars in self.inventory['_meta']['hostvars'].items():
                launch_time_str = hostvars.get('launch_time') or hostvars.get('creation_timestamp')
                if launch_time_str:
                    try:
                        launch_time = datetime.fromisoformat(launch_time_str.replace('Z', '+00:00'))
                        if launch_time > cutoff_time:
                            hosts_to_remove.append(hostname)
                    except ValueError:
                        pass  # Skip if time parsing fails

            # Remove hosts from inventory
            for hostname in hosts_to_remove:
                del self.inventory['_meta']['hostvars'][hostname]

                # Remove from all groups
                for group_name, group_data in self.inventory.items():
                    if group_name != '_meta' and 'hosts' in group_data:
                        if hostname in group_data['hosts']:
                            group_data['hosts'].remove(hostname)

def main():
    """Main function"""
    parser = argparse.ArgumentParser(description='Multi-source dynamic inventory')
    parser.add_argument('--list', action='store_true', 
                       help='List all hosts (default behavior)')
    parser.add_argument('--host', metavar='HOST',
                       help='Get variables for specific host')

    args = parser.parse_args()

    inventory = MultiSourceInventory()

    if args.host:
        # Return variables for specific host
        result = inventory.run()
        host_vars = result['_meta']['hostvars'].get(args.host, {})
        print(json.dumps(host_vars, indent=2, default=str))
    else:
        # Return full inventory
        result = inventory.run()
        print(json.dumps(result, indent=2, default=str))

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Advanced Multi-Source Dynamic Inventory Script
Combines data from multiple sources including cloud providers, CMDBs, and monitoring systems
"""

import json
import sys
import argparse
import requests
import boto3
from google.cloud import compute_v1
from azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
import yaml
import os
from datetime import datetime, timedelta

class MultiSourceInventory:
    def __init__(self):
        self.inventory = {
            '_meta': {
                'hostvars': {}
            }
        }
        self.config = self.load_config()

    def load_config(self):
        """Load configuration from YAML file"""
        config_path = os.environ.get('INVENTORY_CONFIG', 'inventory_config.yml')
        try:
            with open(config_path, 'r') as f:
                return yaml.safe_load(f)
        except FileNotFoundError:
            return self.default_config()

    def default_config(self):
        """Default configuration if file not found"""
        return {
            'sources': {
                'aws': {'enabled': True, 'regions': ['us-east-1', 'us-west-2']},
                'gcp': {'enabled': True, 'projects': []},
                'azure': {'enabled': True, 'subscription_ids': []},
                'cmdb': {'enabled': False, 'url': '', 'token': ''},
                'monitoring': {'enabled': False, 'prometheus_url': ''}
            },
            'enrichment': {
                'add_monitoring_data': True,
                'add_cost_data': True,
                'add_security_scan_results': False
            },
            'filtering': {
                'exclude_stopped': True,
                'minimum_uptime_hours': 1,
                'include_tags': ['Managed=AWX']
            }
        }

    def get_aws_instances(self):
        """Fetch AWS EC2 instances"""
        if not self.config['sources']['aws']['enabled']:
            return

        for region in self.config['sources']['aws']['regions']:
            try:
                ec2 = boto3.client('ec2', region_name=region)

                # Build filters
                filters = [
                    {'Name': 'instance-state-name', 'Values': ['running']}
                ]

                for tag_filter in self.config['filtering']['include_tags']:
                    key, value = tag_filter.split('=')
                    filters.append({
                        'Name': f'tag:{key}',
                        'Values': [value]
                    })

                response = ec2.describe_instances(Filters=filters)

                for reservation in response['Reservations']:
                    for instance in reservation['Instances']:
                        self.process_aws_instance(instance, region)

            except Exception as e:
                print(f"Error fetching AWS instances in {region}: {e}", file=sys.stderr)

    def process_aws_instance(self, instance, region):
        """Process individual AWS instance"""
        instance_id = instance['InstanceId']

        # Extract tags
        tags = {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])}

        # Determine hostname
        hostname = (
            tags.get('Name') or
            instance.get('PublicIpAddress') or
            instance.get('PrivateIpAddress') or
            instance_id
        )

        # Build host variables
        hostvars = {
            'ansible_host': instance.get('PublicIpAddress') or instance.get('PrivateIpAddress'),
            'ansible_user': self.determine_ssh_user(instance.get('Platform', 'linux')),
            'instance_id': instance_id,
            'instance_type': instance['InstanceType'],
            'cloud_provider': 'aws',
            'region': region,
            'availability_zone': instance['Placement']['AvailabilityZone'],
            'vpc_id': instance['VpcId'],
            'subnet_id': instance['SubnetId'],
            'private_ip': instance.get('PrivateIpAddress'),
            'public_ip': instance.get('PublicIpAddress'),
            'launch_time': instance['LaunchTime'].isoformat(),
            'state': instance['State']['Name'],
            'tags': tags,
            'architecture': instance.get('Architecture', 'x86_64'),
            'hypervisor': instance.get('Hypervisor', 'xen'),
            'monitoring': instance.get('Monitoring', {}).get('State', 'disabled'),
            'security_groups': [sg['GroupName'] for sg in instance.get('SecurityGroups', [])]
        }

        # Add enrichment data
        if self.config['enrichment']['add_monitoring_data']:
            hostvars.update(self.get_monitoring_data(instance_id, 'aws'))

        if self.config['enrichment']['add_cost_data']:
            hostvars.update(self.get_cost_data(instance_id, 'aws'))

        # Store host variables
        self.inventory['_meta']['hostvars'][hostname] = hostvars

        # Add to groups
        self.add_to_groups(hostname, hostvars)

    def get_gcp_instances(self):
        """Fetch GCP Compute Engine instances"""
        if not self.config['sources']['gcp']['enabled']:
            return

        try:
            client = compute_v1.InstancesClient()

            for project in self.config['sources']['gcp']['projects']:
                # List all zones in project
                zones_client = compute_v1.ZonesClient()
                zones = zones_client.list(project=project)

                for zone in zones:
                    try:
                        instances = client.list(project=project, zone=zone.name)
                        for instance in instances:
                            if instance.status == 'RUNNING':
                                self.process_gcp_instance(instance, project, zone.name)
                    except Exception as e:
                        print(f"Error fetching GCP instances in {zone.name}: {e}", file=sys.stderr)

        except Exception as e:
            print(f"Error initializing GCP client: {e}", file=sys.stderr)

    def process_gcp_instance(self, instance, project, zone):
        """Process individual GCP instance"""
        name = instance.name

        # Extract labels (GCP's version of tags)
        labels = dict(instance.labels) if instance.labels else {}

        # Get network interfaces
        network_interface = instance.network_interfaces[0] if instance.network_interfaces else {}
        internal_ip = network_interface.network_i_p if network_interface else None
        external_ip = None

        if network_interface and network_interface.access_configs:
            external_ip = network_interface.access_configs[0].nat_i_p

        # Build host variables
        hostvars = {
            'ansible_host': external_ip or internal_ip,
            'ansible_user': 'ubuntu',  # or determine based on image
            'instance_name': name,
            'machine_type': instance.machine_type.split('/')[-1],
            'cloud_provider': 'gcp',
            'project': project,
            'zone': zone,
            'region': '-'.join(zone.split('-')[:-1]),
            'internal_ip': internal_ip,
            'external_ip': external_ip,
            'creation_timestamp': instance.creation_timestamp,
            'status': instance.status,
            'labels': labels,
            'self_link': instance.self_link,
            'can_ip_forward': instance.can_ip_forward,
            'scheduling': {
                'automatic_restart': instance.scheduling.automatic_restart,
                'on_host_maintenance': instance.scheduling.on_host_maintenance,
                'preemptible': instance.scheduling.preemptible
            }
        }

        # Add disk information
        if instance.disks:
            hostvars['disks'] = []
            for disk in instance.disks:
                disk_info = {
                    'device_name': disk.device_name,
                    'boot': disk.boot,
                    'auto_delete': disk.auto_delete,
                    'type': disk.type_,
                    'mode': disk.mode
                }
                hostvars['disks'].append(disk_info)

        # Store host variables
        self.inventory['_meta']['hostvars'][name] = hostvars

        # Add to groups
        self.add_to_groups(name, hostvars)

    def get_azure_instances(self):
        """Fetch Azure Virtual Machines"""
        if not self.config['sources']['azure']['enabled']:
            return

        try:
            credential = DefaultAzureCredential()

            for subscription_id in self.config['sources']['azure']['subscription_ids']:
                compute_client = ComputeManagementClient(credential, subscription_id)

                # Get all VMs in subscription
                vms = compute_client.virtual_machines.list_all()

                for vm in vms:
                    if vm.instance_view and vm.instance_view.statuses:
                        # Check if VM is running
                        power_state = next(
                            (status.display_status for status in vm.instance_view.statuses 
                             if status.code.startswith('PowerState/')), 
                            'Unknown'
                        )

                        if 'running' in power_state.lower():
                            self.process_azure_instance(vm, subscription_id)

        except Exception as e:
            print(f"Error fetching Azure instances: {e}", file=sys.stderr)

    def process_azure_instance(self, vm, subscription_id):
        """Process individual Azure instance"""
        name = vm.name

        # Extract tags
        tags = dict(vm.tags) if vm.tags else {}

        # Build host variables
        hostvars = {
            'ansible_host': None,  # Will be filled by network interface lookup
            'ansible_user': 'azureuser',
            'vm_name': name,
            'vm_size': vm.hardware_profile.vm_size,
            'cloud_provider': 'azure',
            'subscription_id': subscription_id,
            'resource_group': vm.id.split('/')[4],  # Extract from resource ID
            'location': vm.location,
            'vm_id': vm.vm_id,
            'tags': tags,
            'os_type': vm.storage_profile.os_disk.os_type.value if vm.storage_profile.os_disk.os_type else 'Unknown',
            'provisioning_state': vm.provisioning_state
        }

        # Store host variables
        self.inventory['_meta']['hostvars'][name] = hostvars

        # Add to groups
        self.add_to_groups(name, hostvars)

    def add_to_groups(self, hostname, hostvars):
        """Add host to appropriate groups based on its properties"""

        # Cloud provider group
        cloud_group = f"{hostvars['cloud_provider']}_instances"
        self.add_host_to_group(hostname, cloud_group)

        # Environment group (from tags/labels)
        env = (
            hostvars.get('tags', {}).get('Environment') or
            hostvars.get('tags', {}).get('environment') or
            hostvars.get('labels', {}).get('environment') or
            'untagged'
        )
        self.add_host_to_group(hostname, f"env_{env}")

        # Application group
        app = (
            hostvars.get('tags', {}).get('Application') or
            hostvars.get('tags', {}).get('application') or
            hostvars.get('labels', {}).get('application') or
            'unknown'
        )
        self.add_host_to_group(hostname, f"app_{app}")

        # Region group
        region = hostvars.get('region', 'unknown')
        self.add_host_to_group(hostname, f"region_{region}")

        # Instance type/size group
        instance_type = (
            hostvars.get('instance_type') or
            hostvars.get('machine_type') or
            hostvars.get('vm_size') or
            'unknown'
        )
        self.add_host_to_group(hostname, f"type_{instance_type}")

        # Add custom groups based on configuration
        self.add_custom_groups(hostname, hostvars)

    def add_host_to_group(self, hostname, group_name):
        """Add host to specified group"""
        if group_name not in self.inventory:
            self.inventory[group_name] = {'hosts': []}

        if hostname not in self.inventory[group_name]['hosts']:
            self.inventory[group_name]['hosts'].append(hostname)

    def add_custom_groups(self, hostname, hostvars):
        """Add hosts to custom groups based on complex logic"""

        # High availability group
        if any([
            hostvars.get('tags', {}).get('HighAvailability') == 'true',
            hostvars.get('labels', {}).get('high_availability') == 'true',
            'ha' in hostvars.get('instance_type', '').lower()
        ]):
            self.add_host_to_group(hostname, 'high_availability')

        # Monitoring-enabled group
        if any([
            hostvars.get('monitoring') == 'enabled',
            hostvars.get('tags', {}).get('Monitoring') == 'enabled',
            hostvars.get('labels', {}).get('monitoring') == 'enabled'
        ]):
            self.add_host_to_group(hostname, 'monitoring_enabled')

        # Cost-sensitive group
        cost_sensitive_types = ['t2.', 't3.', 'f1-micro', 'g1-small', 'Standard_B']
        if any(cs_type in hostvars.get('instance_type', '') or 
               cs_type in hostvars.get('machine_type', '') or
               cs_type in hostvars.get('vm_size', '') for cs_type in cost_sensitive_types):
            self.add_host_to_group(hostname, 'cost_optimized')

    def determine_ssh_user(self, platform):
        """Determine SSH user based on platform"""
        platform_users = {
            'amazon': 'ec2-user',
            'rhel': 'ec2-user',
            'centos': 'centos',
            'ubuntu': 'ubuntu',
            'debian': 'admin',
            'suse': 'ec2-user',
            'windows': 'Administrator'
        }

        for platform_key, user in platform_users.items():
            if platform_key in platform.lower():
                return user

        return 'root'  # Default fallback

    def get_monitoring_data(self, instance_id, cloud_provider):
        """Fetch monitoring data for instance"""
        if not self.config['enrichment']['add_monitoring_data']:
            return {}

        try:
            # Simulate monitoring data - replace with actual monitoring system calls
            monitoring_data = {
                'cpu_utilization_avg': 45.2,
                'memory_utilization_avg': 62.8,
                'disk_utilization_avg': 23.1,
                'network_in_bytes': 1024000,
                'network_out_bytes': 2048000,
                'last_monitoring_update': datetime.now().isoformat()
            }
            return monitoring_data
        except Exception:
            return {}

    def get_cost_data(self, instance_id, cloud_provider):
        """Fetch cost data for instance"""
        if not self.config['enrichment']['add_cost_data']:
            return {}

        try:
            # Simulate cost data - replace with actual cost management API calls
            cost_data = {
                'monthly_cost_estimate': 89.50,
                'daily_cost_average': 2.98,
                'cost_center': 'IT-Infrastructure',
                'cost_optimization_score': 7.2,
                'last_cost_update': datetime.now().isoformat()
            }
            return cost_data
        except Exception:
            return {}

    def run(self):
        """Main execution method"""
        # Fetch from all enabled sources
        self.get_aws_instances()
        self.get_gcp_instances()
        self.get_azure_instances()

        # Apply post-processing filters
        self.apply_filters()

        return self.inventory

    def apply_filters(self):
        """Apply post-processing filters"""
        # Remove hosts that don't meet minimum uptime
        min_uptime = self.config['filtering'].get('minimum_uptime_hours', 0)
        if min_uptime > 0:
            cutoff_time = datetime.now() - timedelta(hours=min_uptime)
            hosts_to_remove = []

            for hostname, hostvars in self.inventory['_meta']['hostvars'].items():
                launch_time_str = hostvars.get('launch_time') or hostvars.get('creation_timestamp')
                if launch_time_str:
                    try:
                        launch_time = datetime.fromisoformat(launch_time_str.replace('Z', '+00:00'))
                        if launch_time > cutoff_time:
                            hosts_to_remove.append(hostname)
                    except ValueError:
                        pass  # Skip if time parsing fails

            # Remove hosts from inventory
            for hostname in hosts_to_remove:
                del self.inventory['_meta']['hostvars'][hostname]

                # Remove from all groups
                for group_name, group_data in self.inventory.items():
                    if group_name != '_meta' and 'hosts' in group_data:
                        if hostname in group_data['hosts']:
                            group_data['hosts'].remove(hostname)

def main():
    """Main function"""
    parser = argparse.ArgumentParser(description='Multi-source dynamic inventory')
    parser.add_argument('--list', action='store_true', 
                       help='List all hosts (default behavior)')
    parser.add_argument('--host', metavar='HOST',
                       help='Get variables for specific host')

    args = parser.parse_args()

    inventory = MultiSourceInventory()

    if args.host:
        # Return variables for specific host
        result = inventory.run()
        host_vars = result['_meta']['hostvars'].get(args.host, {})
        print(json.dumps(host_vars, indent=2, default=str))
    else:
        # Return full inventory
        result = inventory.run()
        print(json.dumps(result, indent=2, default=str))

if __name__ == '__main__':
    main()