Ansible Lightspeed with IBM watsonx

The Playbook I Never Wrote

I needed to automate Azure VM provisioning with specific networking, security groups, managed disks, and monitoring configuration. Total complexity: 300+ lines of YAML across 15 tasks.

Estimated time: 4-6 hours of writing, testing, and debugging.

Instead, I opened Ansible Lightspeed, typed this in natural language:

Create an Azure VM with:
- Size: Standard_D4s_v3
- OS: Ubuntu 22.04
- Managed disk: Premium SSD 128GB
- Network: existing vnet, new subnet
- NSG: allow SSH from corporate IP range
- Install monitoring agent
- Configure backup policy

Lightspeed generated a complete, production-ready playbook in 45 seconds. I reviewed it, made minor adjustments, ran it - perfect execution on the first try.

Time saved: 4 hours. This article teaches you how to leverage AI-powered automation with Ansible Lightspeed.

What You'll Learn

• Ansible Lightspeed architecture and capabilities

• Setting up Lightspeed with AAP

• Natural language to automation code

• Context-aware suggestions

• Content source attribution

• Best practices for AI-assisted automation

• Real-world productivity gains

What is Ansible Lightspeed?

Ansible Lightspeed is an AI-powered code assistant built on IBM watsonx Code Assistant, specifically trained on Ansible content. It provides:

Core Capabilities

Natural Language to Code:
  - Describe task in plain English
  - Get complete playbook/task generated
  - Context-aware suggestions
  
Intelligent Autocomplete:
  - Suggests next tasks based on context
  - Completes module parameters
  - Recommends best practices
  
Content Attribution:
  - Shows source of suggestions
  - Links to documentation
  - Indicates confidence level
  
Multi-Language Support:
  - YAML (playbooks, roles)
  - Jinja2 (templates)
  - Python (modules, plugins)

How It's Different from GitHub Copilot

Feature	Ansible Lightspeed	GitHub Copilot
Training Data	Ansible-specific content	General code
Context Awareness	Understands AAP concepts	Generic suggestions
Content Sources	Certified Content, Galaxy	Public GitHub repos
Attribution	Shows source + confidence	No attribution
Integration	Native AAP integration	VS Code extension

Architecture

Installation

Step 1: Install VS Code Extension

# Install Ansible extension with Lightspeed
code --install-extension redhat.ansible

# Or install from VS Code marketplace:
# Extensions > Search "Ansible" > Install "Ansible by Red Hat"

Step 2: Configure Lightspeed

// VS Code settings.json
{
  "ansible.lightspeed.enabled": true,
  "ansible.lightspeed.URL": "https://c.ai.ansible.redhat.com",
  "ansible.lightspeed.suggestions.enabled": true,
  "ansible.lightspeed.modelIdOverride": "watsonx/ibm/granite-13b-instruct-v2"
}

Step 3: Authenticate

# Get your Lightspeed API key from:
# https://www.redhat.com/en/technologies/management/ansible/ansible-lightspeed

# Configure in VS Code:
# Command Palette (Cmd+Shift+P)
# > Ansible Lightspeed: Connect
# Enter API key when prompted

Step 4: Verify Connection

# Create test playbook: test-lightspeed.yml
---
- name: Test Lightspeed
  hosts: localhost
  tasks:
    # Type comment: "# Install nginx and start service"
    # Press Tab to accept suggestion

Using Lightspeed

Natural Language Task Generation

Example 1: AWS EC2 Instance

Natural Language Input:

# Create an AWS EC2 instance with t3.medium, Amazon Linux 2, in us-east-1, with SSH key

Lightspeed Generated Code:

- name: Create AWS EC2 instance
  amazon.aws.ec2_instance:
    name: "my-instance"
    instance_type: t3.medium
    image_id: ami-0c55b159cbfafe1f0  # Amazon Linux 2
    region: us-east-1
    key_name: my-ssh-key
    network:
      assign_public_ip: true
    security_group: default
    state: running
    wait: true
  register: ec2_result

- name: Display instance public IP
  ansible.builtin.debug:
    msg: "Instance IP: {{ ec2_result.instances[0].public_ip_address }}"

Example 2: Database Backup

Natural Language Input:

# Backup PostgreSQL database to S3 with compression and retention

Lightspeed Generated Code:

- name: Create PostgreSQL backup
  community.postgresql.postgresql_db:
    name: production_db
    state: dump
    target: "/tmp/backup_{{ ansible_date_time.iso8601 }}.sql"
  become: true
  become_user: postgres

- name: Compress backup file
  community.general.archive:
    path: "/tmp/backup_{{ ansible_date_time.iso8601 }}.sql"
    dest: "/tmp/backup_{{ ansible_date_time.iso8601 }}.sql.gz"
    format: gz
    remove: true

- name: Upload to S3
  amazon.aws.s3_object:
    bucket: my-database-backups
    object: "postgresql/backup_{{ ansible_date_time.iso8601 }}.sql.gz"
    src: "/tmp/backup_{{ ansible_date_time.iso8601 }}.sql.gz"
    mode: put
    encrypt: true

- name: Remove local backup
  ansible.builtin.file:
    path: "/tmp/backup_{{ ansible_date_time.iso8601 }}.sql.gz"
    state: absent

- name: Clean old backups (keep 30 days)
  amazon.aws.s3_object:
    bucket: my-database-backups
    prefix: "postgresql/"
    mode: delobj
    marker: "{{ (ansible_date_time.epoch | int - 2592000) | string }}"

Context-Aware Suggestions

Lightspeed understands your playbook context and suggests relevant next steps.

Your Playbook:

---
- name: Deploy web application
  hosts: web_servers
  
  tasks:
    - name: Install nginx
      ansible.builtin.package:
        name: nginx
        state: present
    
    # Press Ctrl+Space here for suggestions

Lightspeed Suggests:

    - name: Start and enable nginx service
      ansible.builtin.systemd:
        name: nginx
        state: started
        enabled: true
    
    - name: Configure firewall for HTTP/HTTPS
      ansible.posix.firewalld:
        service: "{{ item }}"
        permanent: true
        state: enabled
      loop:
        - http
        - https
    
    - name: Deploy application configuration
      ansible.builtin.template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
        validate: 'nginx -t -c %s'
      notify: Reload nginx

Module Parameter Completion

You Type:

- name: Create user
  ansible.builtin.user:
    name: deployer
    # Press Ctrl+Space

Lightspeed Suggests:

- name: Create user
  ansible.builtin.user:
    name: deployer
    state: present
    shell: /bin/bash
    groups: sudo
    create_home: true
    home: /home/deployer

Real-World Use Cases

Use Case 1: Multi-Cloud Provisioning

Request:

Deploy identical infrastructure across AWS and Azure:
- 3 web servers
- 1 database server
- Load balancer
- VPC/VNet with public and private subnets

Generated Playbook Structure:

---
- name: Multi-cloud infrastructure deployment
  hosts: localhost
  vars:
    cloud_provider: "{{ lookup('env', 'CLOUD_PROVIDER') | default('aws') }}"
  
  tasks:
    - name: Deploy to AWS
      ansible.builtin.include_tasks: aws_infrastructure.yml
      when: cloud_provider == 'aws'
    
    - name: Deploy to Azure
      ansible.builtin.include_tasks: azure_infrastructure.yml
      when: cloud_provider == 'azure'

# aws_infrastructure.yml (Lightspeed generated)
---
- name: Create VPC
  amazon.aws.ec2_vpc_net:
    name: production-vpc
    cidr_block: 10.0.0.0/16
    region: us-east-1
  register: vpc

- name: Create public subnet
  amazon.aws.ec2_vpc_subnet:
    vpc_id: "{{ vpc.vpc.id }}"
    cidr: 10.0.1.0/24
    az: us-east-1a
    map_public: true
    tags:
      Name: public-subnet
  register: public_subnet

# ... (continued with load balancer, EC2 instances, etc.)

# azure_infrastructure.yml (Lightspeed generated)
---
- name: Create resource group
  azure.azcollection.azure_rm_resourcegroup:
    name: production-rg
    location: eastus

- name: Create virtual network
  azure.azcollection.azure_rm_virtualnetwork:
    resource_group: production-rg
    name: production-vnet
    address_prefixes: "10.0.0.0/16"

# ... (continued with subnets, VMs, load balancer)

Use Case 2: Kubernetes Cluster Setup

Request:

Configure Kubernetes cluster with:
- 3 control plane nodes
- 5 worker nodes
- Calico networking
- MetalLB load balancer
- Ingress controller

Generated Playbook:

---
- name: Initialize Kubernetes control plane
  hosts: control_plane[0]
  become: true
  
  tasks:
    - name: Initialize first control plane node
      ansible.builtin.command: >
        kubeadm init 
        --control-plane-endpoint="{{ hostvars[groups['control_plane'][0]]['ansible_host'] }}:6443"
        --pod-network-cidr=192.168.0.0/16
        --upload-certs
      register: kubeadm_init

    - name: Create .kube directory
      ansible.builtin.file:
        path: /root/.kube
        state: directory
        mode: '0755'

    - name: Copy admin.conf
      ansible.builtin.copy:
        src: /etc/kubernetes/admin.conf
        dest: /root/.kube/config
        remote_src: true

    - name: Install Calico networking
      ansible.builtin.command: >
        kubectl apply -f 
        https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml

# ... (continued with worker join, MetalLB, ingress)

Use Case 3: Security Compliance Automation

Request:

Apply CIS benchmark security hardening:
- Disable unnecessary services
- Configure firewall rules
- Set password policies
- Enable auditd
- Configure SELinux

Generated Playbook:

---
- name: CIS Benchmark Security Hardening
  hosts: linux_servers
  become: true
  
  tasks:
    - name: Disable unnecessary services
      ansible.builtin.systemd:
        name: "{{ item }}"
        state: stopped
        enabled: false
      loop:
        - avahi-daemon
        - cups
        - rpcbind
      ignore_errors: true

    - name: Configure firewall - drop all by default
      ansible.posix.firewalld:
        state: enabled
        permanent: true
        default_zone: drop

    - name: Allow SSH from management network
      ansible.posix.firewalld:
        source: 10.0.0.0/24
        service: ssh
        permanent: true
        state: enabled

    - name: Set password minimum length
      ansible.builtin.lineinfile:
        path: /etc/security/pwquality.conf
        regexp: '^minlen'
        line: 'minlen = 14'

    - name: Set password complexity
      ansible.builtin.lineinfile:
        path: /etc/security/pwquality.conf
        regexp: "^{{ item.key }}"
        line: "{{ item.key }} = {{ item.value }}"
      loop:
        - { key: 'dcredit', value: '-1' }
        - { key: 'ucredit', value: '-1' }
        - { key: 'lcredit', value: '-1' }
        - { key: 'ocredit', value: '-1' }

    - name: Enable and configure auditd
      ansible.builtin.systemd:
        name: auditd
        state: started
        enabled: true

    - name: Configure SELinux to enforcing
      ansible.posix.selinux:
        policy: targeted
        state: enforcing

Content Source Attribution

Lightspeed shows where suggestions come from:

# Suggestion preview in VS Code:
┌─────────────────────────────────────────────────┐
│ Lightspeed Suggestion                            │
│                                                  │
│ - name: Install nginx                            │
│   ansible.builtin.package:                       │
│     name: nginx                                  │
│     state: present                               │
│                                                  │
│ Source: ansible.builtin collection (certified)  │
│ Confidence: 95%                                  │
│ Documentation: docs.ansible.com/package_module   │
└─────────────────────────────────────────────────┘

Best Practices

1. Be Specific in Requests

# Vague (poor results)
# Install database

# Specific (excellent results)
# Install PostgreSQL 15 on Ubuntu, create database 'production_db', 
# configure for 16GB RAM, enable SSL, create backup user

2. Review and Validate

# Always review generated code:
- Check module versions
- Verify parameter values
- Test in development first
- Understand what each task does

3. Combine with Manual Expertise

# Let Lightspeed generate boilerplate
# Prompt: "Basic nginx installation and service start"

# Then manually add your customizations:
- name: Install nginx
  ansible.builtin.package:
    name: nginx
    state: present

- name: Start nginx
  ansible.builtin.systemd:
    name: nginx
    state: started
    enabled: true

# Manual addition: Your custom config
- name: Deploy custom nginx config
  ansible.builtin.template:
    src: templates/nginx-custom.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: Reload nginx

4. Use for Documentation

# Generate well-documented playbooks
# Prompt: "Create fully documented playbook for MySQL installation"

# Lightspeed generates with comments:
---
- name: MySQL Installation and Configuration
  hosts: database_servers
  become: true
  
  vars:
    mysql_root_password: "{{ vault_mysql_root_password }}"
    mysql_version: "8.0"
  
  tasks:
    # Install MySQL server package
    - name: Install MySQL {{ mysql_version }}
      ansible.builtin.package:
        name: "mysql-server-{{ mysql_version }}"
        state: present
    
    # Configure MySQL to bind on all interfaces
    - name: Configure MySQL bind address
      ansible.builtin.lineinfile:
        path: /etc/mysql/mysql.conf.d/mysqld.cnf
        regexp: '^bind-address'
        line: 'bind-address = 0.0.0.0'
      notify: Restart MySQL

Productivity Metrics

My Experience (3 Months with Lightspeed)

Playbook Development Time:
  Before: 4-6 hours average
  After: 1-2 hours average
  Reduction: 60-70%

Code Quality:
  Syntax Errors: -80%
  Module Misuse: -65%
  Best Practice Violations: -70%

Documentation:
  Before: 20% of playbooks well-documented
  After: 95% of playbooks well-documented

Learning Curve:
  New Modules: 50% faster to learn
  Complex Workflows: Easier to prototype

Troubleshooting

Lightspeed Not Suggesting

# Check connection
# Command Palette > Ansible Lightspeed: Check Connection

# Verify API key
# Command Palette > Ansible Lightspeed: Update API Key

# Check VS Code output
# View > Output > Select "Ansible Lightspeed"

Irrelevant Suggestions

# Add more context in comments
# Bad:
- name: Configure server

# Good:
# Configure Ubuntu 22.04 web server with nginx, SSL, and firewall
- name: Configure web server

Slow Performance

# Reduce suggestion frequency
{
  "ansible.lightspeed.suggestions.delay": 500  # milliseconds
}

# Disable for specific file patterns
{
  "ansible.lightspeed.suggestions.excludePatterns": [
    "**/*-vars.yml",
    "**/inventory/*"
  ]
}

Key Takeaways

✅ Ansible Lightspeed accelerates automation development with AI ✅ Natural language describes tasks, Lightspeed generates code ✅ Context-aware suggestions understand your playbook intent ✅ Content attribution shows sources and confidence levels ✅ 60-70% time savings on playbook development ✅ Improved code quality with best practices built-in ✅ Learning accelerator for new modules and patterns

What's Next

The next article covers integrating Ansible Automation Platform with external systems - ServiceNow, GitLab CI/CD, monitoring tools, and ChatOps platforms.

---

Next Article: Integrating AAP with External Systems →

---

Part of the Ansible Automation Platform 101 Series