Integrating AAP with External Systems

The Integration That Changed Our Workflow

Before AAP integration: A developer pushes code → GitLab CI builds → Manual Slack message → Someone remembers to run deployment playbook → 30 minutes later, deployed → Manual ServiceNow ticket creation → Email notifications → Fragmented process.

After integration: Developer pushes code → GitLab webhook triggers AAP → Automated deployment → ServiceNow ticket auto-created → Slack notification with deployment status → Prometheus monitors health → PagerDuty alerts if issues → Complete end-to-end automation in 5 minutes.

Integration count: 7 systems working as one. Time to deploy: 30 minutes → 5 minutes. Human errors: 15 per month → 1 per month.

This article teaches you how to integrate Ansible Automation Platform with your entire technology ecosystem.

What You'll Learn

• ServiceNow integration (CMDB, ITSM, incident automation)

• GitLab/GitHub CI/CD integration

• Monitoring tools (Prometheus, Grafana, Datadog)

• ChatOps with Slack and Microsoft Teams

• Ticketing systems (Jira, ServiceNow)

• Secret management (HashiCorp Vault, CyberArk)

• RESTful API patterns for custom integrations

Architecture: Integrated Ecosystem

Step 2: Create ServiceNow Incident Playbook

---
- name: Create ServiceNow incident
  hosts: localhost
  gather_facts: false
  
  vars:
    snow_instance: "{{ servicenow_host }}"
    snow_user: "{{ servicenow_username }}"
    snow_password: "{{ servicenow_password }}"
  
  tasks:
    - name: Create incident
      servicenow.itsm.incident:
        instance:
          host: "{{ snow_instance }}"
          username: "{{ snow_user }}"
          password: "{{ snow_password }}"
        
        state: new
        short_description: "{{ incident_title }}"
        description: |
          Alert: {{ alert_name }}
          Severity: {{ severity }}
          Affected Host: {{ target_host }}
          Time: {{ ansible_date_time.iso8601 }}
        
        impact: "{{ impact | default('medium') }}"
        urgency: "{{ urgency | default('medium') }}"
        caller: ansible_automation
        assignment_group: Infrastructure Team
        category: Infrastructure
        subcategory: Server
      
      register: incident

    - name: Output incident number
      ansible.builtin.debug:
        msg: "Created incident: {{ incident.record.number }}"

Step 3: Auto-Remediation with Ticket Update

---
- name: Auto-remediate and update ServiceNow
  hosts: "{{ target_host }}"
  
  tasks:
    - name: Restart service
      ansible.builtin.systemd:
        name: "{{ service_name }}"
        state: restarted
      register: restart_result
    
    - name: Update ServiceNow incident - Success
      servicenow.itsm.incident:
        instance: "{{ snow_connection }}"
        number: "{{ incident_number }}"
        state: resolved
        close_code: "Solved (Permanently)"
        close_notes: |
          Auto-remediation successful:
          - Service {{ service_name }} restarted
          - Status: {{ restart_result.status }}
          - Timestamp: {{ ansible_date_time.iso8601 }}
      when: restart_result is succeeded
      delegate_to: localhost
    
    - name: Update ServiceNow incident - Failure
      servicenow.itsm.incident:
        instance: "{{ snow_connection }}"
        number: "{{ incident_number }}"
        state: in_progress
        work_notes: |
          Auto-remediation failed:
          - Service {{ service_name }} restart failed
          - Error: {{ restart_result.msg }}
          - Escalating to on-call engineer
        assignment_group: Senior Infrastructure Team
      when: restart_result is failed
      delegate_to: localhost

Step 4: Event-Driven ServiceNow Integration

---
- name: ServiceNow event-driven automation
  hosts: all
  
  sources:
    - name: servicenow_incidents
      servicenow.eda.incidents:
        instance: mycompany.service-now.com
        username: "{{ servicenow_user }}"
        password: "{{ servicenow_password }}"
        assignment_group: Infrastructure Team
        poll_interval: 60
  
  rules:
    - name: Auto-assign infrastructure incidents
      condition: >
        event.category == "Infrastructure" and
        event.state == "New"
      
      action:
        run_job_template:
          name: "Infrastructure Triage"
          extra_vars:
            incident_number: "{{ event.number }}"
            affected_ci: "{{ event.cmdb_ci }}"

ServiceNow CMDB Sync

---
- name: Sync inventory to ServiceNow CMDB
  hosts: all_servers
  gather_facts: true
  
  tasks:
    - name: Update configuration item in CMDB
      servicenow.itsm.configuration_item:
        instance: "{{ snow_connection }}"
        sys_class_name: cmdb_ci_server
        name: "{{ inventory_hostname }}"
        
        data:
          ip_address: "{{ ansible_default_ipv4.address }}"
          os: "{{ ansible_distribution }} {{ ansible_distribution_version }}"
          cpu_count: "{{ ansible_processor_vcpus }}"
          ram: "{{ ansible_memtotal_mb }} MB"
          disk_space: "{{ ansible_mounts | map(attribute='size_total') | sum }}"
          serial_number: "{{ ansible_product_serial }}"
          install_status: "Installed"
          operational_status: "Operational"
          managed_by: "Ansible Automation Platform"
          last_discovered: "{{ ansible_date_time.iso8601 }}"
      
      delegate_to: localhost

GitLab CI/CD Integration

Use Case: Deployment Pipeline

GitLab Pipeline → AAP Job Template → Automated Deployment

Step 1: GitLab Webhook Configuration

# In GitLab: Settings > Webhooks
---
URL: https://aap-controller.example.com/api/v2/job_templates/42/github/
Secret Token: "{{ webhook_secret }}"
Trigger: Push events, Tag events
SSL Verification: Enabled

Step 2: AAP Job Template with GitLab Integration

# Job Template: Deploy Application
---
name: Deploy Application from GitLab
job_type: run
inventory: Production Servers
project: GitLab - Web App
playbook: deploy.yml

webhook_service: gitlab
webhook_credential: GitLab Webhook Token

extra_vars:
  deploy_branch: "{{ webhook_payload.ref | regex_replace('refs/heads/', '') }}"
  commit_sha: "{{ webhook_payload.checkout_sha }}"
  commit_author: "{{ webhook_payload.user_username }}"
  commit_message: "{{ webhook_payload.commits[0].message }}"

Step 3: Deployment Playbook with GitLab Context

---
- name: Deploy application from GitLab
  hosts: web_servers
  
  vars:
    app_repo: "{{ webhook_payload.project.git_http_url }}"
    app_version: "{{ deploy_branch }}"
    deployment_id: "{{ commit_sha[:8] }}"
  
  tasks:
    - name: Clone application code
      ansible.builtin.git:
        repo: "{{ app_repo }}"
        dest: "/opt/webapp"
        version: "{{ deploy_branch }}"
        force: true
    
    - name: Install dependencies
      ansible.builtin.command:
        cmd: npm install --production
        chdir: /opt/webapp
    
    - name: Restart application
      ansible.builtin.systemd:
        name: webapp
        state: restarted
    
    - name: Update GitLab commit status
      ansible.builtin.uri:
        url: "{{ webhook_payload.project.web_url }}/-/api/v4/projects/{{ webhook_payload.project_id }}/statuses/{{ commit_sha }}"
        method: POST
        headers:
          PRIVATE-TOKEN: "{{ gitlab_api_token }}"
        body_format: json
        body:
          state: success
          description: "Deployed successfully by AAP"
          name: "ansible-deployment"
      delegate_to: localhost

Step 4: GitLab CI/CD Pipeline with AAP

# .gitlab-ci.yml
---
stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - npm install
    - npm run build

test:
  stage: test
  script:
    - npm run test

deploy_production:
  stage: deploy
  only:
    - main
  script:
    - |
      curl -X POST \
        https://aap-controller.example.com/api/v2/job_templates/42/launch/ \
        -H "Authorization: Bearer $AAP_API_TOKEN" \
        -H "Content-Type: application/json" \
        -d '{
          "extra_vars": {
            "deploy_environment": "production",
            "git_commit": "'$CI_COMMIT_SHA'",
            "git_branch": "'$CI_COMMIT_BRANCH'",
            "gitlab_user": "'$GITLAB_USER_LOGIN'"
          }
        }'

Slack Integration (ChatOps)

Use Case: Deploy Applications via Slack

Slack Command → AAP Workflow → Deployment → Status in Slack

Step 1: Create Slack App

# In Slack: api.slack.com > Create App
---
App Name: Ansible Automation
Workspace: YourWorkspace

Features:
  - Slash Commands: /deploy, /provision, /rollback
  - Incoming Webhooks: For notifications
  - Interactive Components: For approval buttons

Permissions:
  - commands
  - chat:write
  - chat:write.public

Step 2: AAP Slack Notification Playbook

---
- name: Send Slack notification
  hosts: localhost
  
  tasks:
    - name: Post deployment notification
      ansible.builtin.uri:
        url: "{{ slack_webhook_url }}"
        method: POST
        body_format: json
        body:
          channel: "#deployments"
          username: "Ansible AAP"
          icon_emoji: ":ansible:"
          attachments:
            - color: "{{ 'good' if deployment_status == 'success' else 'danger' }}"
              title: "Deployment {{ deployment_status | upper }}"
              fields:
                - title: "Environment"
                  value: "{{ environment }}"
                  short: true
                - title: "Application"
                  value: "{{ application_name }}"
                  short: true
                - title: "Version"
                  value: "{{ app_version }}"
                  short: true
                - title: "Duration"
                  value: "{{ deployment_duration }}s"
                  short: true
                - title: "Deployed By"
                  value: "{{ ansible_user }}"
                  short: true
              footer: "Ansible Automation Platform"
              footer_icon: "https://www.ansible.com/favicon.ico"
              ts: "{{ ansible_date_time.epoch }}"

Step 3: Slack Slash Command Handler

# Flask app to handle Slack commands and trigger AAP
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

AAP_URL = "https://aap-controller.example.com"
AAP_TOKEN = "your-aap-token"

@app.route('/slack/deploy', methods=['POST'])
def slack_deploy():
    # Parse Slack command
    command_text = request.form.get('text')  # e.g., "webapp production v2.1.0"
    user_name = request.form.get('user_name')
    
    parts = command_text.split()
    app_name = parts[0]
    environment = parts[1]
    version = parts[2] if len(parts) > 2 else 'latest'
    
    # Trigger AAP job template
    job_launch_url = f"{AAP_URL}/api/v2/job_templates/42/launch/"
    headers = {
        "Authorization": f"Bearer {AAP_TOKEN}",
        "Content-Type": "application/json"
    }
    payload = {
        "extra_vars": {
            "application_name": app_name,
            "environment": environment,
            "app_version": version,
            "deployed_by": user_name
        }
    }
    
    response = requests.post(job_launch_url, headers=headers, json=payload)
    job_data = response.json()
    
    # Respond to Slack
    return jsonify({
        "response_type": "in_channel",
        "text": f":rocket: Deploying {app_name} {version} to {environment}...",
        "attachments": [{
            "text": f"Job #{job_data['id']} started by {user_name}",
            "color": "good"
        }]
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Step 4: Workflow Approval via Slack

---
- name: Request approval via Slack
  hosts: localhost
  
  tasks:
    - name: Send approval request
      ansible.builtin.uri:
        url: "{{ slack_webhook_url }}"
        method: POST
        body_format: json
        body:
          channel: "#approvals"
          text: "Deployment approval required"
          attachments:
            - text: "Deploy {{ application_name }} {{ version }} to production?"
              fallback: "Deployment approval"
              callback_id: "deploy_approval"
              color: "warning"
              actions:
                - name: "approve"
                  text: "Approve"
                  type: "button"
                  value: "approve"
                  style: "primary"
                - name: "deny"
                  text: "Deny"
                  type: "button"
                  value: "deny"
                  style: "danger"
      register: slack_response
    
    # Pause workflow until approval received
    - name: Wait for approval
      ansible.builtin.pause:
        prompt: "Waiting for Slack approval..."
      # In production, use AAP workflow approval node

Prometheus / Grafana Integration

Use Case: Alert-Driven Automation

Prometheus Alert → Event-Driven Ansible → Auto-Remediation → Grafana Annotation

Step 1: Prometheus AlertManager Configuration

# alertmanager.yml
---
route:
  group_by: ['alertname', 'cluster']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 1h
  receiver: 'ansible-eda'

receivers:
  - name: 'ansible-eda'
    webhook_configs:
      - url: 'http://eda-controller.example.com:5000/prometheus'
        send_resolved: true

Step 2: Event-Driven Ansible Rulebook

---
- name: Prometheus-driven automation
  hosts: all
  
  sources:
    - name: prometheus_alerts
      prometheus.eda.webhook:
        host: 0.0.0.0
        port: 5000
  
  rules:
    - name: High disk usage remediation
      condition: >
        event.alert.labels.alertname == "HighDiskUsage" and
        event.alert.labels.severity == "warning" and
        event.alert.status == "firing"
      
      action:
        run_job_template:
          name: "Clean Up Disk Space"
          extra_vars:
            target_host: "{{ event.alert.labels.instance }}"
            filesystem: "{{ event.alert.labels.mountpoint }}"

Step 3: Add Grafana Annotations from AAP

---
- name: Add Grafana annotation
  hosts: localhost
  
  tasks:
    - name: Create deployment annotation
      ansible.builtin.uri:
        url: "{{ grafana_url }}/api/annotations"
        method: POST
        headers:
          Authorization: "Bearer {{ grafana_api_key }}"
          Content-Type: "application/json"
        body_format: json
        body:
          dashboardId: 1
          time: "{{ ansible_date_time.epoch }}000"  # milliseconds
          timeEnd: "{{ (ansible_date_time.epoch | int + 300) }}000"
          tags:
            - deployment
            - "{{ environment }}"
          text: "Deployed {{ application_name }} {{ version }}"
      status_code: 200

HashiCorp Vault Integration

Dynamic Secrets Retrieval

---
- name: Retrieve secrets from Vault
  hosts: web_servers
  
  tasks:
    - name: Get database credentials from Vault
      ansible.builtin.set_fact:
        db_credentials: "{{ lookup('community.hashi_vault.vault_kv2_get', 
                              'database/production/credentials',
                              url='https://vault.example.com',
                              auth_method='token',
                              token=vault_token) }}"
    
    - name: Configure application with dynamic secrets
      ansible.builtin.template:
        src: app-config.j2
        dest: /etc/webapp/config.yml
      vars:
        db_host: "{{ db_credentials.host }}"
        db_user: "{{ db_credentials.username }}"
        db_password: "{{ db_credentials.password }}"

Microsoft Teams Integration

---
- name: Post to Microsoft Teams
  hosts: localhost
  
  tasks:
    - name: Send deployment notification
      ansible.builtin.uri:
        url: "{{ teams_webhook_url }}"
        method: POST
        body_format: json
        body:
          "@type": "MessageCard"
          "@context": "https://schema.org/extensions"
          summary: "Deployment Notification"
          themeColor: "{{ '0078D4' if deployment_status == 'success' else 'D13438' }}"
          title: "Deployment {{ deployment_status | upper }}"
          sections:
            - activityTitle: "{{ application_name }}"
              activitySubtitle: "Version {{ app_version }}"
              facts:
                - name: "Environment"
                  value: "{{ environment }}"
                - name: "Duration"
                  value: "{{ deployment_duration }}s"
                - name: "Deployed By"
                  value: "{{ ansible_user }}"
          potentialAction:
            - "@type": "OpenUri"
              name: "View Logs"
              targets:
                - os: "default"
                  uri: "{{ aap_job_url }}"

RESTful API Integration Pattern

Generic API Integration Template

---
- name: Generic API integration
  hosts: localhost
  
  tasks:
    - name: Authenticate and get token
      ansible.builtin.uri:
        url: "{{ api_base_url }}/auth/login"
        method: POST
        body_format: json
        body:
          username: "{{ api_username }}"
          password: "{{ api_password }}"
      register: auth_response
    
    - name: Set authentication token
      ansible.builtin.set_fact:
        api_token: "{{ auth_response.json.token }}"
    
    - name: Make authenticated API call
      ansible.builtin.uri:
        url: "{{ api_base_url }}/resource"
        method: POST
        headers:
          Authorization: "Bearer {{ api_token }}"
          Content-Type: "application/json"
        body_format: json
        body:
          key: value
      register: api_result
    
    - name: Handle API response
      ansible.builtin.debug:
        msg: "Result: {{ api_result.json }}"

Best Practices

1. Use Webhooks for Real-Time Integration

# Faster than polling
Webhook (push): ~1 second latency
Polling (pull): 30-60 seconds latency

2. Implement Retry Logic

- name: API call with retry
  ansible.builtin.uri:
    url: "{{ external_api }}"
    method: POST
    body: "{{ data }}"
  retries: 3
  delay: 5
  register: result
  until: result.status == 200

3. Secure API Credentials

# Use AAP credential types
# Never hardcode tokens/passwords in playbooks
# Rotate credentials regularly

4. Monitor Integration Health

# Track integration metrics:
- API call success rate
- Response times
- Error rates
- Retry counts

Key Takeaways

✅ ServiceNow for ITSM, CMDB sync, incident automation ✅ GitLab/GitHub for CI/CD pipeline integration ✅ Slack/Teams for ChatOps and notifications ✅ Prometheus for alert-driven automation ✅ Vault/CyberArk for dynamic secrets ✅ RESTful APIs for custom integrations ✅ Webhooks for real-time event processing

What's Next

The final article covers AAP production best practices and enterprise deployment patterns - high availability, disaster recovery, security hardening, and scaling to thousands of managed nodes.

---

Next Article: AAP Production Best Practices and Enterprise Deployment →

---

Part of the Ansible Automation Platform 101 Series