AnsibleByExample

Ansible AAP Containerized Install on RHEL — Guide

Advancedansibleenterprisecontainerizationansible automation platform

2024-01-017By Luca Berton

Lesson 1 of 14 in AAP and AWX

Ansible Automation Platform and AWX — full curriculum

View path overview →

Introduction

Since September 2023, Red Hat offers a containerized version of the Ansible Automation Platform (AAP). This deployment model runs the automation controller, automation hub, and Event-Driven Ansible controller as containers on Red Hat Enterprise Linux (RHEL) using Podman — without requiring Kubernetes. This article covers the architecture, benefits, setup process, troubleshooting, and how it compares to the traditional RPM-based installation.

Containerized Ansible Automation Platform Update 2024

Architecture Overview

The containerized AAP runs each component as an isolated Podman container:

┌─────────────────────────────────────────┐
│           RHEL Host (x86_64/ARM64)       │
│                                          │
│  ┌──────────────┐  ┌─────────────────┐  │
│  │  Automation   │  │  Automation     │  │
│  │  Controller   │  │  Hub            │  │
│  │  (Port 443)   │  │  (Port 444)     │  │
│  └──────────────┘  └─────────────────┘  │
│                                          │
│  ┌──────────────┐  ┌─────────────────┐  │
│  │  Event-Driven │  │  PostgreSQL     │  │
│  │  Ansible      │  │  Database       │  │
│  │  (Port 445)   │  │  (Port 5432)    │  │
│  └──────────────┘  └─────────────────┘  │
│                                          │
│           Podman (rootless)              │
└─────────────────────────────────────────┘

Components

Component	Default Port	Purpose
Automation Controller	443	Job execution, workflow orchestration, RBAC
Automation Hub	444	Collection hosting, content management
Event-Driven Ansible (EDA)	445	Event-driven automation, rulebooks
PostgreSQL	5432	Shared database backend
Redis	6379	Cache and message broker

Why Containerized?

Problems with Traditional RPM Installation

The RPM-based installation had growing complexity:

Multiple interdependent RPM packages across components
System-level Python dependency conflicts
Complex upgrade procedures affecting the entire OS
Difficulty isolating component failures

Benefits of Containerization

1. Simplified Installation

The installer uses an Ansible playbook that pulls container images and configures Podman:

# One command to install
ansible-playbook -i inventory containerized_installer.yml

2. Component Isolation

Each service runs in its own container with isolated dependencies. A bug in the automation hub cannot crash the controller.

3. Rootless Security by Default

Podman runs containers without root privileges, reducing the attack surface:

# Containers run as non-root user
podman ps --format "{{.User}} {{.Names}}"
# 1000 automation-controller
# 1000 automation-hub
# 1000 automation-eda

4. Lighter Footprint

No need for a full Kubernetes cluster. A single RHEL host can run the entire platform.

5. Independent Upgrades

Update individual components without affecting others:

# Update just the controller
podman pull registry.redhat.io/aap/controller-rhel9:latest
podman stop automation-controller
podman start automation-controller

6. Multi-Architecture Support

Supports both x86_64 and ARM64 (aarch64) on RHEL 9+.

Prerequisites

System Requirements

Resource	Minimum	Recommended
CPU	4 cores	8+ cores
RAM	16 GB	32 GB
Disk	40 GB	100 GB SSD
OS	RHEL 9.2+	RHEL 9.4+

Software Requirements

Red Hat subscription with AAP entitlement
Podman 4.x+ (included with RHEL 9)
Python 3.9+ on the installer host
Ansible Core 2.15+ on the installer host

# Verify prerequisites
podman --version
python3 --version
ansible --version

Setup Guide

Step 1: Download the Installer

Visit the Red Hat Portal Downloads section and download the containerized installer bundle:

# Extract the bundle
tar xzf ansible-automation-platform-containerized-setup-bundle-*.tar.gz
cd ansible-automation-platform-containerized-setup-bundle-*/

Step 2: Configure the Inventory

Edit the inventory file to match your environment:

[automationcontroller]
controller.example.com

[automationhub]
hub.example.com

[automationeda]
eda.example.com

[database]
db.example.com

[all:vars]
# Admin credentials
admin_password='SecureAdminP@ss!'
pg_host='db.example.com'
pg_port=5432
pg_database='aap'
pg_username='aap'
pg_password='SecureDBP@ss!'

# Registry credentials
registry_url='registry.redhat.io'
registry_username='your-rh-username'
registry_password='your-rh-password'

# License
controller_license_file='/path/to/manifest.zip'

Single-Host Installation

For a simpler setup where everything runs on one host:

[automationcontroller]
localhost ansible_connection=local

[automationhub]
localhost ansible_connection=local

[automationeda]
localhost ansible_connection=local

[database]
localhost ansible_connection=local

[all:vars]
admin_password='SecureAdminP@ss!'
pg_host='localhost'
pg_port=5432
pg_database='aap'
pg_username='aap'
pg_password='SecureDBP@ss!'
registry_url='registry.redhat.io'
registry_username='your-rh-username'
registry_password='your-rh-password'

Step 3: Set Environment Variables

export ANSIBLE_COLLECTIONS_PATH="./collections"

Step 4: Run the Installer

ansible-playbook -i inventory containerized_installer.yml \
  -e "container_runtime=podman"

For verbose output:

ansible-playbook -i inventory containerized_installer.yml -vvv

Step 5: Verify Installation

# Check running containers
podman ps

# Expected output:
# CONTAINER ID  IMAGE                                    STATUS   PORTS
# abc123        aap/controller-rhel9:latest             Up       0.0.0.0:443->443/tcp
# def456        aap/hub-rhel9:latest                    Up       0.0.0.0:444->444/tcp
# ghi789        aap/eda-controller-rhel9:latest         Up       0.0.0.0:445->445/tcp
# jkl012        postgresql:15                            Up       0.0.0.0:5432->5432/tcp

Access the services:

Controller: https://your-host:443
Hub: https://your-host:444
EDA: https://your-host:445

New Features in Containerized AAP

License Application at Install Time

Apply your AAP license during installation (no manual step in the UI):

# In inventory vars
controller_license_file='/path/to/manifest.zip'

Configuration as Code (Pre-Seeding)

Pre-seed the automation controller with organizations, projects, and job templates:

# config-as-code/controller_config.yml
controller_organizations:
  - name: Production
    description: "Production automation"
  - name: Development
    description: "Dev/test automation"

controller_projects:
  - name: Infrastructure Playbooks
    organization: Production
    scm_type: git
    scm_url: "https://github.com/org/infra-playbooks.git"

# In inventory vars
controller_config_file='/path/to/config-as-code/controller_config.yml'

Containerized vs RPM-Based Installation

Aspect	Containerized	RPM-Based
Isolation	Full container isolation	Shared OS libraries
Security	Rootless Podman	Root-level services
Upgrades	Per-component	Full system upgrade
Footprint	Lighter (no K8s needed)	Heavier OS footprint
Kubernetes	Not required	Not required
Architecture	x86_64, ARM64	x86_64 only (varies)
Complexity	Lower	Higher
Maturity	Tech Preview → GA 2024	Mature, years in production

Troubleshooting

Container Fails to Start

# Check container logs
podman logs automation-controller

# Check systemd service
systemctl --user status automation-controller

# Check Podman events
podman events --filter event=die --since 1h

Database Connection Issues

# Test database connectivity from controller container
podman exec automation-controller pg_isready -h db.example.com -p 5432

# Check database logs
podman logs automation-db

Port Conflicts

# Check if ports are in use
ss -tlnp | grep -E '443|444|445|5432'

# Modify ports in inventory
controller_port=8443
hub_port=8444
eda_port=8445

Registry Authentication Failures

# Login to registry manually
podman login registry.redhat.io

# Verify image pull
podman pull registry.redhat.io/aap/controller-rhel9:latest

Resource Constraints

# Check container resource usage
podman stats --no-stream

# Increase memory limits if needed (in systemd unit)
# MemoryMax=8G

Managing the Platform

Starting and Stopping

# Stop all AAP containers
podman stop automation-controller automation-hub automation-eda automation-db

# Start all
podman start automation-db automation-controller automation-hub automation-eda

# Restart a single component
podman restart automation-controller

Backups

# Database backup
podman exec automation-db pg_dump -U aap aap > backup-$(date +%Y%m%d).sql

# Container volume backup
podman volume export aap_data > aap_data_backup.tar

Logs

# Follow controller logs
podman logs -f automation-controller

# All container logs
for c in automation-controller automation-hub automation-eda automation-db; do
  echo "=== $c ==="
  podman logs --tail 20 "$c"
done

Links

Red Hat Blog: Announcing Containerized AAP
AAP Installation Guide
Containerized AAP Update 2024

Conclusion

The containerized Ansible Automation Platform simplifies installation, improves security through rootless Podman, and enables independent component upgrades — all without requiring Kubernetes. For new deployments, the containerized approach is the recommended path forward. Download the installer from the Red Hat Portal, configure your inventory, and run the playbook to get started.