Déploiement d’AWX sur un cluster Kind avec Docker Compose

Ce guide explique comment déployer AWX, une interface Web pour Ansible Tower, en utilisant Kind (Kubernetes in Docker) et Docker Compose. Nous allons utiliser un fichier Docker Compose pour orchestrer le déploiement et exécuter AWX à l’aide de l’AWX Operator.

Arborescence des fichiers

Voici l’arborescence des fichiers utilisée pour ce projet :

/awx-kind-setup
|-- docker-compose.yml
|-- kind-config
|-- scripts
    |-- setup-awx.sh

Étape 1 : Fichier Docker Compose

Le fichier docker-compose.yml configure deux services :

  1. kind : Un conteneur Kind pour le cluster Kubernetes.
  2. setup-script : Un conteneur qui exécute un script pour configurer le cluster et installer AWX.

Créez un fichier nommé docker-compose.yml avec le contenu suivant :

version: '3.8'
services:
  kind:
    image: kindest/node:v1.24.0
    container_name: awx-kind-cluster
    privileged: true
    command: ["sh", "-c", "sleep infinity"]
    volumes:
      - ./kind-config:/root/.kube/kind-config
    ports:
      - "6443:6443"

  setup-script:
    image: bitnami/kubectl:latest
    container_name: awx-setup
    user: root
    network_mode: host
    depends_on:
      - kind
    volumes:
      - ./scripts:/scripts
      - ./kind-config:/root/.kube/kind-config
      - /var/run/docker.sock:/var/run/docker.sock
    entrypoint: ["/scripts/setup-awx.sh"]

Étape 2 : Fichier Kind Config

Le fichier de configuration Kind définit les paramètres du cluster, y compris les mappages de ports pour s’assurer que AWX est accessible via le port 80 de l’hôte.

Créez un fichier nommé kind-config avec le contenu suivant :

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    extraPortMappings:
      - containerPort: 30080
        hostPort: 80
        protocol: TCP
  - role: worker

Étape 3 : Script de configuration de AWX

Le script setup-awx.sh gère l’installation et la configuration d’AWX sur le cluster Kubernetes. Ce script s’exécute dans le conteneur setup-script après que le cluster Kind a été démarré.

Créez un fichier nommé setup-awx.sh dans le répertoire scripts avec le contenu suivant :

#!/bin/bash

# Correction du problème d'apt : recréer le répertoire et réinitialiser le cache
echo "Réinitialisation du cache apt..."
mkdir -p /var/lib/apt/lists/partial
chmod 755 /var/lib/apt/lists/partial
rm -rf /var/lib/apt/lists/*

# Vérifier si apt-get est disponible et initialiser si nécessaire
if ! command -v apt-get &> /dev/null; then
    echo "apt-get n'est pas disponible dans ce conteneur."
else
    echo "Mise à jour de la liste des paquets et installation des dépendances nécessaires..."
    apt-get update && apt-get install -y curl apt-transport-https ca-certificates lsb-release gnupg
fi

# Ajouter la clé publique Docker et configurer le dépôt
echo "Ajout de la clé publique Docker..."
mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

# Ajouter le dépôt Docker officiel pour Debian Bullseye
echo "Ajout du dépôt Docker pour Debian Bullseye..."
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

# Mettre à jour la liste des paquets et installer Docker CLI
echo "Mise à jour de la liste des paquets et installation de Docker CLI..."
apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Installer curl si ce n'est pas déjà présent
if ! command -v curl &> /dev/null; then
    echo "curl n'est pas installé. Installation de curl..."
    apt-get update && apt-get install -y curl
    echo "curl a été installé avec succès."
else
    echo "curl est déjà installé."
fi

# Vérifier si Kind est installé, sinon l'installer
if ! command -v kind &> /dev/null; then
    echo "Kind n'est pas installé. Installation de Kind..."
    curl -Lo /usr/local/bin/kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
    chmod +x /usr/local/bin/kind
    echo "Kind a été installé avec succès."
else
    echo "Kind est déjà installé."
fi

# Créer un cluster Kind avec le fichier de configuration spécifié
kind create cluster --config=/root/.kube/kind-config

echo "Vérification de la disponibilité du cluster Kubernetes..."
until kubectl get nodes &>/dev/null; do
  echo "Le cluster Kubernetes n'est pas encore prêt. Attente de 10 secondes..."
  sleep 10
done
echo "Le cluster Kubernetes est prêt."

# Configurer le contexte du namespace pour AWX
echo "Configuration du contexte de namespace pour AWX..."
kubectl config set-context --current --namespace=awx

# Télécharger et configurer l'AWX Operator
echo "Téléchargement et configuration de l'AWX Operator..."
cat <<EOF > kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
  - github.com/ansible/awx-operator/config/default?ref=2.7.2
  - awx-demo.yml
images:
  - name: quay.io/ansible/awx-operator
    newTag: 2.7.2
namespace: awx
EOF

# Appliquer la configuration de Kustomize
kubectl apply -k .

# Créer le fichier AWX CR pour déployer l'instance AWX
echo "Création du fichier de configuration AWX CR..."
cat <<EOF > awx-demo.yml
apiVersion: awx.ansible.com/v1beta1
kind: AWX
metadata:
  name: awx-demo
spec:
  service_type: nodeport
  nodeport_port: 30080
EOF

# Déployer l'instance AWX
echo "Déploiement de l'instance AWX..."
kubectl apply -k .

echo "Déploiement d'AWX terminé. Vous pouvez accéder à AWX à l'adresse http://localhost"

Étape 4 : Exécution

Pour lancer le processus, exécutez la commande suivante dans le répertoire contenant le fichier docker-compose.yml :

docker-compose up

Ce processus démarre les conteneurs définis dans le fichier Docker Compose, crée le cluster Kind, installe l’AWX Operator et déploie l’instance AWX.

Accéder à l’interface d’AWX et récupérer le mot de passe admin

Une fois le déploiement d’AWX terminé, vous pouvez accéder à l’interface web d’AWX en ouvrant votre navigateur et en allant à l’adresse suivante :

http://localhost

L’interface d’AWX devrait s’afficher, vous demandant de vous connecter.

Pour obtenir le mot de passe initial du compte admin, vous devez utiliser la commande kubectl suivante. Cette commande lit les logs du pod de l’AWX Operator pour extraire le mot de passe généré automatiquement :

kubectl get secret awx-demo-admin-password -o jsonpath="{.data.password}" -n awx | base64 --decode
  • Explication :
    • awx-demo-admin-password est le secret généré par l’AWX Operator qui contient le mot de passe admin.
    • base64 --decode décode le mot de passe qui est stocké au format base64.

Cette commande vous retournera le mot de passe admin que vous pourrez utiliser pour vous connecter à l’interface web d’AWX.

Conclusion

Avec cette configuration, vous avez déployé avec succès AWX sur un cluster Kubernetes Kind à l’aide de Docker Compose et de scripts automatisés. Cette méthode fournit une solution modulaire et facile à reproduire pour le déploiement et les tests d’AWX.

Étiquettes

Publications similaires