AWX permet de gérer de manière centralisée les playbooks Ansible, les inventaires, les secrets et les tâches planifiées depuis une interface web. Il est facile d'installer AWX sur le système Linux Ubuntu 20.04|18.04 (Bionic Beaver).

À partir de la version 18.0 de AWX, la méthode d'installation recommandée est celle de l'opérateur AWX. Comme la méthode d'installation par l'opérateur nécessite un cluster Kubernetes, nous allons effectuer une installation Kubernetes à un seul nœud sur Ubuntu Linux en utilisant k3s.

Ubuntu 20.04|22.04 LTS Server Au minimum 8 GB RAM Au moins 4 vcpus 40 GB d'espace disque

$ sudo apt update && sudo apt -y upgrade
$ [ -f /var/run/reboot-required ] && sudo reboot -f

Nous allons déployer un nœud unique de Kubernetes en utilisant l'outil K3s.

K3s est une distribution Kubernetes certifiée conçue pour les charges de travail de production dans des environnements sans surveillance et avec des ressources limitées.

L'avantage de K3s est que vous pouvez ajouter d'autres nœuds de travail à un stade ultérieur si nécessaire.

K3s fournit un script d'installation qui est un moyen pratique de l'installer en tant que service sur les systèmes basés sur systemd ou openrc.

Pour installer K3s sur notre système Ubuntu :

$ curl -sfL https://get.k3s.io | sudo bash -
$ sudo chmod 644 /etc/rancher/k3s/k3s.yaml

L'étape suivante consiste à valider notre installation de K3s en utilisant la commande kubectl qui a été installée et configurée par le script d'installation.

$ kubectl get nodes
NAME        STATUS   ROLES                  AGE   VERSION
awx   Ready    control-plane,master   2m53s   v1.24.3+k3s1

Nous pouvons également confirmer la version de Kubernetes déployée à l'aide de la commande suivante :

$ kubectl version --short
Client Version: v1.24.3+k3s1
Server Version: v1.24.3+k3s1

Le service K3s sera configuré pour redémarrer automatiquement après le redémarrage des nœuds ou si le processus s'arrête ou est tué.

Cet opérateur Kubernetes doit être déployé dans le cluster Kubernetes, qui dans notre cas est alimenté par K3s.

L'opérateur que nous allons déployer peut gérer une ou plusieurs instances AWX dans n'importe quel espace de noms.

Installez les outils git et make :

$ sudo apt update
$ sudo apt install git build-essential

Cloner le code de déploiement de l'opérateur :

$ git clone https://github.com/ansible/awx-operator.git
Cloning into 'awx-operator'...
remote: Enumerating objects: 6306, done.
remote: Counting objects: 100% (315/315), done.
remote: Compressing objects: 100% (189/189), done.
remote: Total 6306 (delta 160), reused 236 (delta 115), pack-reused 5991
Receiving objects: 100% (6306/6306), 1.54 MiB | 19.74 MiB/s, done.
Resolving deltas: 100% (3598/3598), done.

Créer un espace de nom où l'opérateur sera déployé.

$ kubectl create ns awx

Passez au répertoire awx-operator :

$ cd awx-operator/

Sauvegardez la dernière version de l'opérateur AWX en tant que variable RELEASE_TAG puis effectuez un checkout sur la branche en utilisant git.

$ sudo apt install curl jq
RELEASE_TAG=`curl -s https://api.github.com/repos/ansible/awx-operator/releases/latest | grep tag_name | cut -d '"' -f 4`
$ echo $RELEASE_TAG
$ git checkout $RELEASE_TAG

Déployez AWX Operator dans votre cluster :

$ export NAMESPACE=awx
$ make deploy

Sortie de commande :

...
namespace/awx configured
customresourcedefinition.apiextensions.k8s.io/awxbackups.awx.ansible.com created
customresourcedefinition.apiextensions.k8s.io/awxrestores.awx.ansible.com created
customresourcedefinition.apiextensions.k8s.io/awxs.awx.ansible.com created
serviceaccount/awx-operator-controller-manager created
role.rbac.authorization.k8s.io/awx-operator-awx-manager-role created
role.rbac.authorization.k8s.io/awx-operator-leader-election-role created
clusterrole.rbac.authorization.k8s.io/awx-operator-metrics-reader created
clusterrole.rbac.authorization.k8s.io/awx-operator-proxy-role created
rolebinding.rbac.authorization.k8s.io/awx-operator-awx-manager-rolebinding created
rolebinding.rbac.authorization.k8s.io/awx-operator-leader-election-rolebinding created
clusterrolebinding.rbac.authorization.k8s.io/awx-operator-proxy-rolebinding created
configmap/awx-operator-awx-manager-config created
service/awx-operator-controller-manager-metrics-service created
deployment.apps/awx-operator-controller-manager created

Attendez quelques minutes et awx-operator devrait fonctionner

$ kubectl get pods -n awx
NAME                                               READY   STATUS    RESTARTS   AGE
awx-operator-controller-manager-49d246bedf-r46h6   2/2     Running   0          40s

Créer un PVC pour la persistance de données

$ cat <<EOF | kubectl create -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: static-data-pvc
  namespace: awx
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: local-path
  resources:
    requests:
      storage: 10Gi
EOF

Le PVC ne sera pas lié tant que le pod qui l'utilise ne sera pas créé

$ kubectl get pvc -n awx
NAME                     STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   AGE
static-data-pvc          Pending   

Créons maintenant le fichier de déploiement AWX avec des informations de base

$ nano awx-deploy.yml
...
---
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx
spec:
  service_type: nodeport
  projects_persistence: true
  projects_storage_access_mode: ReadWriteOnce
  web_extra_volume_mounts: |
    - name: static-data
      mountPath: /var/lib/projects
  extra_volumes: |
    - name: static-data
      persistentVolumeClaim:
        claimName: static-data-pvc

Nous avons défini le nom de la ressource awx et le type de service comme nodeport pour nous permettre d'accéder à AWX à partir de l'adresse IP du nœud et du port donné.

Nous avons également ajouté un montage PV supplémentaire sur le pod du serveur web.

On applique notre manifest de configuration

$ kubectl apply -f awx-deploy.yml
awx.awx.ansible.com/awx created

Attendez quelques minutes puis vérifiez le déploiement de l'instance AWX :

$ kubectl get pods -n awx -l "app.kubernetes.io/managed-by=awx-operator"
NAME                   READY   STATUS    RESTARTS   AGE
awx-postgres-0         1/1     Running   0          82s
awx-6c4y754h43-scefd   4/4     Running   0          68s

Vous pouvez suivre le processus d'installation dans les journaux de l'opérateur

$ kubectl logs -f deployments/awx-operator-controller-manager -c awx-manager

Le pod awx-xxx-yyy aura quatre conteneurs, à savoir :

• redis
• awx-web
• awx-task
• awx-ee

Vous devrez fournir le nom du conteneur après le pod

$ kubectl -n awx  logs deploy/awx -c redis
$ kubectl -n awx  logs deploy/awx -c awx-web
$ kubectl -n awx  logs deploy/awx -c awx-task
$ kubectl -n awx  logs deploy/awx -c awx-e

Voici comment accéder au shell de chaque conteneur :

$ kubectl exec -ti deploy/awx  -c  awx-task -- /bin/bash
$ kubectl exec -ti deploy/awx  -c  awx-web -- /bin/bash
$ kubectl exec -ti deploy/awx  -c  awx-ee -- /bin/bash
$ kubectl exec -ti deploy/awx  -c  redis -- /bin/bash

Lister tous les services disponibles et vérifier awx-service Nodeport

$ kubectl get svc -l "app.kubernetes.io/managed-by=awx-operator" -n awx
NAME           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
awx-postgres   ClusterIP   None            <none>        5432/TCP       4h20m
awx-service    NodePort    10.43.229.192   <none>        80:30080/TCP   4h19m

Nous pouvons voir que le type de service est défini sur NodePort.

Pour accéder à notre service depuis l'extérieur du cluster Kubernetes en utilisant l'adresse IP du nœud k3s et en donnant le port du nœud.

Dans notre cas, on utilisera l'adresse IP du serveur : http://10.75.168.45:30080

Le nom d'utilisateur de la connexion est admin

Pour obtenir le mot de passe de l'utilisateur admin en décodant le secret avec la valeur du mot de passe :

$ kubectl get secret awx-admin-password -o jsonpath="{.data.password}" | base64 --decode  
pMadDyIodXcHvin5NIb9LVvkcQwAbcgB

Même resultat, mais mieux présenté :

$ kubectl get secret awx-admin-password -o go-template='{{range $k,$v := .data}}{{printf "%s: " $k}}{{if not $v}}{{$v}}{{else}}{{$v | base64decode}}{{end}}{{"\n"}}{{end}}'

Nous voici connecté à l'interface AWX.

Vérifier l'état du Pod PostgreSQL :

$ kubectl get pods -l "app.kubernetes.io/managed-by=awx-operator"
NAME                   READY   STATUS             RESTARTS   AGE
awx-postgres-0         0/1     CrashLoopBackOff   4          2m38s
awx-66c64f8d67-qvfk9   3/4     ImagePullBackOff   0          2m27s

Vérifiez les journaux du Pod :

$ kubectl logs awx-postgres-0
mkdir: cannot create directory ‘/var/lib/postgresql/data’: Permission denied

Cela signifie que le pod Postgres ne peut pas écrire dans le répertoire du volume persistant dans /var/lib/rancher/k3s/storage/ :

# ls -lh /var/lib/rancher/k3s/storage/ | grep awx-postgres-0
total 0
drwx------ 3 root root      4.0K Jul 29 08:53 pvc-cc5e5d1a-5a48-4f7a-b44e-8404af7ed6a1_awx_postgres-awx-postgres-0

Définir le mode de répertoire à 777

$ chmod -R 777  /var/lib/rancher/k3s/storage/*

Pour relancer le déploiement, il nous suffira de supprimer les pods lié à l'opérateur AWX

$ kubectl delete pods -l "app.kubernetes.io/managed-by=awx-operator"
pod "awx-66c64f8d67-qvfk9" deleted
pod "awx-postgres-0" deleted

On vérifie.

# kubectl get pods -l "app.kubernetes.io/managed-by=awx-operator"
NAME                   READY   STATUS             RESTARTS   AGE
awx-postgres-0         1/1     Running            0          42s
awx-66c64f8d67-4qmh5   4/4     Running            0          42s

https://github.com/ansible/awx

https://docs.ansible.com/ansible-tower/latest/html/userguide/projects.html