In 30 Minuten zur eigenen AWX-Instanz - lokal und sicher

Schluss mit Kommandozeile: Mit AWX verwaltest du deine Ansible-Tasks zentral, übersichtlich und komplett im Browser. AWX ist eine Weboberfläche für Ansible, die dir einiges an Tipparbeit ersparen kann. Ob Playbooks planen, Nutzerrechte vergeben oder komplexe Workflows bauen – ideal für lokale Tests, Demos oder Pilotierungen.

Ubuntu 24.04 stellt dafür die perfekte Basis bereit: aktuelle Software, stabil laufendes System und gute Unterstützung für Container wie Docker oder Kubernetes. In diesem How-To zeige ich dir, wie du AWX unter Ubuntu 24.04 schnell ans Laufen bekommst – Schritt für Schritt und ohne viel Aufwand.

Voraussetzungen

Für die Installation und den Betrieb werden folgende Voraussetzungen benötigt:

• Ubuntu/Debian-basierte Linux-Distribution (mind. 4 vCPUs, 8 GB RAM, 20 GB SSD)
• Root-/sudo-Rechte
• Grundkenntnisse mit der Shell
• Internetverbindung

Hinweis: Beim Einrichten einer virtuellen Maschine sollte ein CPU-Typ mit AES-Unterstützung (z. B. x86-64-v2-AES) ausgewählt werden, da PostgreSQL ansonsten nicht lauffähig ist.

Installation

1. Systemvorbereitung

Zunächst wird die Paketliste auf den neuesten Stand gebracht und alle erforderlichen Programme werden installiert.

sudo apt update
sudo apt install -y git curl docker.io make nginx openssl

Im Anschluss wird ein dediziertes Benutzerkonto namens awx erstellt, unter dem der AWX-Dienst zukünftig ausgeführt wird.

sudo adduser --disabled-password --gecos "AWX Dienstkonto" awx

Dieses Benutzerkonto erhält zusätzlich die Mitgliedschaft in der Docker-Gruppe, um die Ausführung von Containern zu ermöglichen.

sudo usermod -aG docker awx

2. Installation Kubernetes (Minikube)

Zuerst wird Minikube heruntergeladen und im Verzeichnis /usr/local/bin installiert.

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube && rm minikube-linux-amd64
sudo chown root:root /usr/local/bin/minikube

Anschließend erfolgt die Installation des Kubernetes-Befehlszeilenwerkzeugs kubectl.

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo mv kubectl /usr/local/bin/
sudo chown root:root /usr/local/bin/kubectl && sudo chmod 755 /usr/local/bin/kubectl

3. Installation von AWX

Als Nächstes wird in das Benutzerkonto awx gewechselt.

sudo su - awx

Minikube wird mit den passenden Ressourcen gestartet.

minikube start --driver=docker --memory=6144 --cpus=4

Der AWX-Operator in der Version 2.19.1 wird aus dem offiziellen GitHub-Repository geklont.

git clone -b 2.19.1 https://github.com/ansible/awx-operator.git
cd awx-operator

Der Operator wird anschließend im Namespace awx installiert.

kubectl create ns awx || true
kubectl config set-context --current --namespace=awx
kubectl apply -k config/default
kubectl rollout status deployment awx-operator-controller-manager

Nun wird die Datei awx-deploy.yaml mit der gewünschten AWX-Konfiguration erstellt.

cat <<EOF > awx-deploy.yaml
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx
spec:
  service_type: nodeport
  ingress_type: none
  extra_settings:
    - setting: CSRF_TRUSTED_ORIGINS
      value:
        - https://awx.local
    - setting: UI_NEXT
      value: false
EOF

Hinweis: Wer das neue UI auch auswählen und testen möchte, muss der Wert von UI_NEXT auf true setzen.

Deployment starten.

kubectl apply -f awx-deploy.yaml

Den Status der AWX-Services awx-web und awx-task prüfen.

kubectl rollout status deployment awx-web
kubectl rollout status deployment awx-task

Hinweis: Der Prozess kann abhängig von den verfügbaren Ressourcen des Hosts einige Zeit in Anspruch nehmen und unter Umständen bis zu 10 Minuten dauern.

Anschließend das AWX-Admin-Passwort, das AWX-Listen-Port und die AWX-Server-IP auslesen und notieren. Diese Informationen werden für die Einrichtung des Reverse-Proxys benötigt.

# AWX-Server-IP:
minikube ip

# AWX-Listen-Port:
kubectl get svc awx-service -o=jsonpath='{.spec.ports[0].nodePort}'

# AWX-Admin-Passwort:
kubectl get secret awx-admin-password -o jsonpath="{.data.password}" | base64 --decode

4. Einrichtung des NGINX-Reverse-Proxys

Zunächst wird zurück in ein Benutzerkonto mit sudo-Rechten gewechselt.

exit

Generiere ein selbst signiertes Zertifikat für den FQDN awx.local.

sudo mkdir -p /etc/nginx/ssl
sudo openssl req -x509 -nodes -days 365 \
  -subj "/CN=awx.local" \
  -newkey rsa:2048 \
  -keyout /etc/nginx/ssl/awx.key \
  -out /etc/nginx/ssl/awx.crt

Erstelle eine Reverse-Proxy-Konfiguration, damit über die Adresse https://awx.local zugegriffen werden kann und ersetze [AWX-Server-IP] und [AWX-Liste-PORT] mit den zuvor notierten Werten.

sudo tee /etc/nginx/sites-available/awx > /dev/null <<EOF
server {
    listen 80;
    server_name awx.local;
    return 301 https://\$host\$request_uri;
}

server {
    listen 443 ssl;
    server_name awx.local;

    ssl_certificate     /etc/nginx/ssl/awx.crt;
    ssl_certificate_key /etc/nginx/ssl/awx.key;

    location / {
        proxy_pass http://[AWX-Server-IP]:[AWX-Listen-Port];
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
EOF

Aktiviere die Konfiguration und starte NGINX anschließend neu.

sudo ln -sf /etc/nginx/sites-available/awx /etc/nginx/sites-enabled/awx
sudo nginx -t && sudo systemctl reload nginx

5. Einrichtung eines systemd-Dienstes für Minikube

Erstelle eine systemd-Dienstdatei für den automatischen Start von Minikube.

sudo tee /etc/systemd/system/minikube.service > /dev/null <<EOF
[Unit]
Description=Start Minikube at boot
After=docker.service
Requires=docker.service

[Service]
Type=oneshot
ExecStart=/usr/local/bin/minikube start --driver=docker --memory=6144 --cpus=4
RemainAfterExit=yes
User=awx
Environment=HOME=/home/awx
WorkingDirectory=/home/awx

[Install]
WantedBy=multi-user.target

EOF

Aktiviere den soeben erstellten Dienst.

sudo systemctl daemon-reexec
sudo systemctl daemon-reload
sudo systemctl enable minikube.service

Starte abschließend den Server neu und prüfe, ob der Dienst läuft.

sudo systemctl status minikube.service

6. AWX im Browser aufrufen

Füge awx.local zur /etc/hosts Datei hinzu. Ersetze [HOST-IP] durch die IP-Adresse des Hosts, auf dem AWS installiert wurde.

echo "[HOST-IP]    awx.local" | sudo tee -a /etc/hosts

Öffne einen Webbrowser und gehe zu https://aws.local. Die Anmeldung erfolgt mit Benutzernamen admin und dem zuvor notierten Passwort.

Hinweis: Da das Zertifikat selbstsigniert ist, zeigt dein Browser eine Warnung an – diese kann ignoriert werden, da es sich um eine lokale Testumgebung handelt.

Überwachung & Debugging

Falls AWX oder Minikube nach einem Neustart nicht erreichbar sind, können folgende Befehle helfen.

• Status überprüfen: sudo -u awx minikube status und sudo -u awx kubectl get pods -A
• Protokolle einsehen: sudo journalctl -u minikube.service

Fazit

AWX bietet eine zentrale Weboberfläche für die Verwaltung von Ansible-Playbooks und -Aufgaben. Die Ersteinrichtung ist zwar vergleichsweise aufwendig, ermöglicht jedoch langfristig eine effizientere Verwaltung, insbesondere in Teams.

Quellen

• https://www.howtoforge.de/anleitung/ansible-awx-leitfaden-grundverwendung-und-konfiguration/
• https://computingforgeeks.com/how-to-install-ansible-awx-on-ubuntu-linux/
• https://www.linuxtechi.com/install-ansible-awx-on-ubuntu/