🛠️ Automation Tools & Workflow Identification

# ACI Python Workflow
import requests
import json

# ACI API Details
apic_url = "https://apic.example.com"
username = "admin"
password = "password"

# Step 1: Authentication
login_url = f"{apic_url}/api/aaaLogin.json"
credentials = {
    "aaaUser": {
        "attributes": {
            "name": username,
            "pwd": password
        }
    }
}

session = requests.Session()
response = session.post(login_url, json=credentials, verify=False)
token = response.cookies.get('APIC-cookie')

# Step 2: Create Tenant
tenant_url = f"{apic_url}/api/node/mo/uni.json"
tenant_data = {
    "fvTenant": {
        "attributes": {
            "name": "Production_Tenant"
        }
    }
}
response = session.post(tenant_url, json=tenant_data, verify=False)
print(f"Tenant created: {response.status_code}")

# WORKFLOW IDENTIFIED:
# 1. Authenticate to APIC
# 2. Create new tenant in ACI fabric
# 3. Configure tenant-specific policies

# Meraki Python Workflow
import meraki

# API Key
API_KEY = "your_api_key_here"
dashboard = meraki.DashboardAPI(API_KEY)

# Step 1: Get all organizations
orgs = dashboard.organizations.getOrganizations()
org_id = orgs[0]['id']

# Step 2: Get all networks in organization
networks = dashboard.organizations.getOrganizationNetworks(org_id)

#Step 3: Create a new network
new_network = dashboard.organizations.createOrganizationNetwork(
    org_id,
    name="Branch_Office_5",
    productTypes=["appliance", "switch", "wireless"]
)

# Step 4: Configure SSID
dashboard.wireless.updateNetworkWirelessSsid(
    new_network['id'],
    number=0,
    name="Corp-WiFi",
    enabled=True,
    authMode="psk",
    psk="SecurePassword123"
)

print(f"Network created: {new_network['name']}")

# WORKFLOW IDENTIFIED:
# 1. Retrieve organization details
# 2. List existing networks
# 3. Create new branch network
# 4. Configure wireless SSID

# DNA Center Python Workflow
import requests
from requests.auth import HTTPBasicAuth

# DNA Center Details
DNAC_URL = "https://dnac.example.com"
USERNAME = "admin"
PASSWORD = "password"

# Step 1: Get Authentication Token
auth_url = f"{DNAC_URL}/dna/system/api/v1/auth/token"
response = requests.post(
    auth_url,
    auth=HTTPBasicAuth(USERNAME, PASSWORD),
    headers={"Content-Type": "application/json"},
    verify=False
)
token = response.json()['Token']

headers = {
    "X-Auth-Token": token,
    "Content-Type": "application/json"
}

# Step 2: Get all network devices
devices_url = f"{DNAC_URL}/dna/intent/api/v1/network-device"
response = requests.get(devices_url, headers=headers, verify=False)
devices = response.json()['response']

print(f"Found {len(devices)} devices")

# Step 3: Get device by hostname
for device in devices:
    if device['hostname'] == 'ROUTER-01':
        device_id = device['id']
        print(f"Device ID: {device_id}")

# WORKFLOW IDENTIFIED:
# 1. Authenticate to DNA Center
# 2. Retrieve network device inventory
# 3. Filter devices by specific criteria
# 4. Extract device details for further operations

# RESTCONF Python Workflow
import requests
from requests.auth import HTTPBasicAuth

# Device Details
DEVICE_IP = "192.168.1.1"
USERNAME = "admin"
PASSWORD = "cisco"

headers = {
    "Accept": "application/yang-data+json",
    "Content-Type": "application/yang-data+json"
}

# Step 1: Get interface configuration
url = f"https://{DEVICE_IP}/restconf/data/ietf-interfaces:interfaces"
response = requests.get(
    url,
    auth=HTTPBasicAuth(USERNAME, PASSWORD),
    headers=headers,
    verify=False
)

interfaces = response.json()
print(f"Retrieved {len(interfaces['ietf-interfaces:interfaces']['interface'])} interfaces")

# Step 2: Update interface configuration
interface_data = {
    "ietf-interfaces:interface": {
        "name": "GigabitEthernet1",
        "description": "WAN Link - Updated via RESTCONF",
        "enabled": True
    }
}

url = f"https://{DEVICE_IP}/restconf/data/ietf-interfaces:interfaces/interface=GigabitEthernet1"
response = requests.patch(
    url,
    json=interface_data,
    auth=HTTPBasicAuth(USERNAME, PASSWORD),
    headers=headers,
    verify=False
)

print(f"Interface updated: {response.status_code}")

# WORKFLOW IDENTIFIED:
# 1. Connect to device via RESTCONF
# 2. Retrieve current interface configuration
# 3. Update specific interface attributes
# 4. Verify configuration change

---
- name: Package Management Workflow
  hosts: webservers
  become: yes
  
  tasks:
    # Install multiple packages
    - name: Install Apache and PHP
      apt:
        name:
          - apache2
          - php
          - php-mysql
        state: present
        update_cache: yes
    
    # Update specific package
    - name: Ensure Git is latest version
      apt:
        name: git
        state: latest
    
    # Remove unwanted package
    - name: Remove telnet
      apt:
        name: telnet
        state: absent

# WORKFLOW IDENTIFIED:
# 1. Install multiple packages (apache2, php, php-mysql)
# 2. Update existing package to latest version (git)
# 3. Remove security risk package (telnet)
# 4. Update package cache before installing

---
- name: User Management Workflow
  hosts: all
  become: yes
  
  tasks:
    # Create new user with specific settings
    - name: Create application user
      user:
        name: appuser
        comment: "Application Service Account"
        uid: 5000
        group: appgroup
        groups: docker,sudo
        shell: /bin/bash
        create_home: yes
        state: present
    
    # Add SSH key for user
    - name: Add SSH key for appuser
      authorized_key:
        user: appuser
        key: "{{ lookup('file', 'files/appuser_key.pub') }}"
        state: present
    
    # Modify existing user
    - name: Update user shell
      user:
        name: devuser
        shell: /bin/zsh
    
    # Remove user
    - name: Remove temporary user
      user:
        name: tempuser
        state: absent
        remove: yes

# WORKFLOW IDENTIFIED:
# 1. Create new user with UID, groups, and home directory
# 2. Configure SSH key authentication
# 3. Modify existing user properties
# 4. Remove user and associated files

---
- name: Service Configuration Workflow
  hosts: webservers
  become: yes
  
  tasks:
    # Copy configuration file
    - name: Deploy Nginx configuration
      copy:
        src: files/nginx.conf
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: '0644'
        backup: yes
      notify: Restart Nginx
    
    # Use template for dynamic config
    - name: Deploy Apache vhost from template
      template:
        src: templates/vhost.conf.j2
        dest: /etc/apache2/sites-available/{{ domain }}.conf
        owner: root
        group: root
        mode: '0644'
      vars:
        domain: example.com
        doc_root: /var/www/example
    
    # Modify configuration file
    - name: Set max_connections in MySQL
      lineinfile:
        path: /etc/mysql/my.cnf
        regexp: '^max_connections'
        line: 'max_connections = 500'
        backup: yes
      notify: Restart MySQL
  
  handlers:
    - name: Restart Nginx
      service:
        name: nginx
        state: restarted
    
    - name: Restart MySQL
      service:
        name: mysql
        state: restarted

# WORKFLOW IDENTIFIED:
# 1. Deploy static configuration files
# 2. Generate configuration from templates
# 3. Modify existing configuration values
# 4. Trigger service restart when config changes

---
- name: Service Lifecycle Workflow
  hosts: all
  become: yes
  
  tasks:
    # Start service
    - name: Start Apache service
      service:
        name: apache2
        state: started
    
    # Stop service
    - name: Stop old application service
      service:
        name: legacy-app
        state: stopped
    
    # Restart service
    - name: Restart Nginx after config change
      service:
        name: nginx
        state: restarted
    
    # Reload service (graceful restart)
    - name: Reload Apache configuration
      service:
        name: apache2
        state: reloaded
    
    # Enable service at boot
    - name: Enable Docker service
      service:
        name: docker
        enabled: yes
        state: started
    
    # Disable service at boot
    - name: Disable unnecessary service
      service:
        name: bluetooth
        enabled: no
        state: stopped

# WORKFLOW IDENTIFIED:
# 1. Start services that should be running
# 2. Stop services that should not be running
# 3. Restart services after configuration changes
# 4. Enable/disable services at system boot
# 5. Use reload for graceful restarts

---
- name: Complete Web Server Deployment
  hosts: webservers
  become: yes
  
  tasks:
    # 1. PACKAGE MANAGEMENT
    - name: Install required packages
      apt:
        name:
          - nginx
          - php-fpm
          - git
        state: present
        update_cache: yes
    
    # 2. USER MANAGEMENT
    - name: Create web application user
      user:
        name: webapp
        comment: "Web Application User"
        shell: /bin/bash
        create_home: yes
    
    - name: Add webapp user to www-data group
      user:
        name: webapp
        groups: www-data
        append: yes
    
    # 3. SERVICE CONFIGURATION
    - name: Deploy Nginx configuration
      template:
        src: templates/nginx-site.conf.j2
        dest: /etc/nginx/sites-available/webapp.conf
        owner: root
        group: root
        mode: '0644'
      notify: Reload Nginx
    
    - name: Enable Nginx site
      file:
        src: /etc/nginx/sites-available/webapp.conf
        dest: /etc/nginx/sites-enabled/webapp.conf
        state: link
      notify: Reload Nginx
    
    # 4. SERVICE START/STOP
    - name: Ensure Nginx is running and enabled
      service:
        name: nginx
        state: started
        enabled: yes
    
    - name: Ensure PHP-FPM is running
      service:
        name: php7.4-fpm
        state: started
        enabled: yes
  
  handlers:
    - name: Reload Nginx
      service:
        name: nginx
        state: reloaded

# COMPLETE WORKFLOW IDENTIFIED:
# 1. Install web server packages (nginx, php-fpm, git)
# 2. Create dedicated application user and add to groups
# 3. Deploy configuration files from templates
# 4. Enable site and create symlinks
# 5. Start and enable services at boot
# 6. Define handlers for graceful service reloads