Créer une infrastructure Azure AKS

Dans cet article, vous approvisionnez les principales ressources Azure requises pour un déploiement AKS prêt pour la production. Cet article valide l’accès Azure, crée un groupe de ressources, établit un Registre de conteneurs Azure (ACR), déploie un cluster AKS de base, ajoute éventuellement un pool de nœuds supplémentaire pour les charges de travail utilisateur et accorde l’autorisation de cluster d’extraire à partir d’ACR. Toutes les commandes s’appuient sur des variables d’environnement paramétrables afin que le flux de travail reste reproductible entre les régions et les abonnements.

Prerequisites

Vous avez besoin des outils et de l’accès au compte suivants avant d’exécuter le guide. Vérifiez que vous êtes authentifié auprès d’Azure az login et disposez des autorisations suffisantes pour créer des groupes de ressources, des registres de conteneurs et des clusters AKS.

Abonnement Azure avec quota pour la région sélectionnée
Azure CLI (az) avec des droits propriétaires ou contributeurs
kubectl configuré localement pour l’accès au cluster
jq (facultatif) pour analyser la sortie JSON lors de la vérification

Exécutez les commandes suivantes pour confirmer que vous disposez de tous les outils CLI nécessaires et de l’accès Azure :

command -v az >/dev/null || echo "Azure CLI missing"
command -v kubectl >/dev/null || echo "kubectl missing"
command -v jq >/dev/null || echo "jq missing (optional)"

Configurer l’environnement

Ici, vous définissez toutes les variables d’environnement utilisées tout au long des étapes d’approvisionnement. L’horodatage HASH conserve les noms de ressources uniques pendant les exécutions répétées. Les valeurs par défaut du cluster et du registre ciblent une empreinte minimale de preuve de concept, mais vous pouvez les ajuster selon les besoins.

Les commandes suivantes établissent l’étendue Azure, le dimensionnement AKS et les conventions d’affectation de noms ACR pour la séquence d’approvisionnement, quelles que soient les charges de travail en aval.

export HASH="${HASH:-$(date -u +"%y%m%d%H%M")}"  # YYMMDDHHMM stamp

# Azure scope and regional placement
export LOCATION="${LOCATION:-eastus2}"
export SUBSCRIPTION_ID="${SUBSCRIPTION_ID:-$(az account show --query id -o tsv)}"
export RESOURCE_GROUP="${RESOURCE_GROUP:-rg_aks_${HASH}}"

# AKS cluster naming and version control
# Hyphen required because AKS cluster names cannot include underscores
export AKS_CLUSTER_NAME="${AKS_CLUSTER_NAME:-aks-openwebsearch-${HASH}}"
export AKS_VERSION="${AKS_VERSION:-}"  # Optional Kubernetes version override

# Node pool sizing
export AKS_SYSTEM_NODE_COUNT="${AKS_SYSTEM_NODE_COUNT:-1}"
export AKS_USER_NODE_COUNT="${AKS_USER_NODE_COUNT:-1}"
export AKS_NODE_VM_SIZE="${AKS_NODE_VM_SIZE:-Standard_D4s_v5}"
export AKS_SYSTEM_NODEPOOL_NAME="${AKS_SYSTEM_NODEPOOL_NAME:-system}"
export AKS_USER_NODEPOOL_NAME="${AKS_USER_NODEPOOL_NAME:-user}"

# ACR configuration
export ACR_NAME="${ACR_NAME:-acrwebsearch${HASH}}"
export ACR_LOGIN_SERVER="${ACR_LOGIN_SERVER:-${ACR_NAME}.azurecr.io}"

Vérifier les valeurs des variables d’environnement

Passez en revue la configuration effective avant de créer des ressources. Réexécutez le bloc après les ajustements pour vous assurer que les valeurs actives sont correctes pour l’abonnement et la région cibles.

Utilisez les commandes suivantes pour épingler les paramètres actifs afin de valider les choix d’affectation de noms, de dimensionnement et régionaux.

: "${HASH:=$(date -u +"%y%m%d%H%M")}"  # Ensure HASH exists

VARS=(
  HASH
  LOCATION
  SUBSCRIPTION_ID
  RESOURCE_GROUP
  AKS_CLUSTER_NAME
  AKS_VERSION
  AKS_SYSTEM_NODE_COUNT
  AKS_USER_NODE_COUNT
  AKS_NODE_VM_SIZE
  AKS_SYSTEM_NODEPOOL_NAME
  AKS_USER_NODEPOOL_NAME
  ACR_NAME
  ACR_LOGIN_SERVER
)
for v in "${VARS[@]}"; do
  printf "%s=%s\n" "$v" "${!v}"
done

Étapes

Exécutez chaque étape de manière séquentielle. Chaque sous-section comprend des objectifs, des commandes et un résumé pour confirmer les résultats attendus.

Vérifier le contexte de l’abonnement Azure

Vérifiez l’abonnement Azure actif et vérifiez que les fournisseurs de ressources requis pour les opérations AKS et ACR sont inscrits.

az account show --query id -o tsv
az provider register --namespace Microsoft.ContainerService
az provider register --namespace Microsoft.ContainerRegistry

Créer un groupe de ressources

Provisionnez un groupe de ressources dédié pour isoler le cluster AKS, le registre et l’infrastructure de support de vos charges de travail.

az group create \
  --name "${RESOURCE_GROUP}" \
  --location "${LOCATION}" \
  --output table

Provisionner le registre de conteneurs Azure

Créez un Registre de conteneurs Azure pour stocker des images conteneur et authentifier le démon Docker local pour envoyer (push) des images.

az acr create \
  --name "${ACR_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --location "${LOCATION}" \
  --sku Basic \
  --output table
az acr login --name "${ACR_NAME}"

Créer le cluster AKS

Déployez le cluster AKS pour héberger vos charges de travail. Veillez à ne pas réutiliser un nom de cluster existant en vérifiant avant la création.

if az aks show \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" >/dev/null 2>&1; then
  echo "AKS cluster ${AKS_CLUSTER_NAME} already exists in ${RESOURCE_GROUP}";
  echo "Skip creation or provide a new AKS_CLUSTER_NAME.";
else
  az aks create \
    --name "${AKS_CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --location "${LOCATION}" \
    --generate-ssh-keys \
    --node-count "${AKS_SYSTEM_NODE_COUNT}" \
    --nodepool-name "${AKS_SYSTEM_NODEPOOL_NAME}" \
    --node-vm-size "${AKS_NODE_VM_SIZE}" \
    ${AKS_VERSION:+--kubernetes-version "${AKS_VERSION}"} \
    --output table
fi

Ajouter un pool de nœuds utilisateur facultatif

Provisionnez un pool de nœuds supplémentaire lorsqu’il est demandé. La commande add s’exécute de manière asynchrone pour éviter les délais d’expiration de l’interface CLI ; la commande d’attente suit la progression d’Azure. Le script vérifie d’abord si le pool existe déjà pour empêcher les erreurs de nom en double.

if [ "${AKS_USER_NODE_COUNT}" -gt 0 ]; then
  if az aks nodepool show \
    --cluster-name "${AKS_CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${AKS_USER_NODEPOOL_NAME}" >/dev/null 2>&1; then
    echo "Node pool ${AKS_USER_NODEPOOL_NAME} already exists; skipping add.";
  else
    az aks nodepool add \
      --cluster-name "${AKS_CLUSTER_NAME}" \
      --resource-group "${RESOURCE_GROUP}" \
      --name "${AKS_USER_NODEPOOL_NAME}" \
      --node-count "${AKS_USER_NODE_COUNT}" \
      --node-vm-size "${AKS_NODE_VM_SIZE}" \
      --no-wait
    az aks nodepool wait \
      --cluster-name "${AKS_CLUSTER_NAME}" \
      --resource-group "${RESOURCE_GROUP}" \
      --name "${AKS_USER_NODEPOOL_NAME}" \
      --created
  fi
fi

Récupérer les informations d’identification du cluster

Fusionnez akS kubeconfig dans le contexte local et vérifiez que tous les nœuds sont accessibles.

az aks get-credentials \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --overwrite-existing
kubectl get nodes -o wide

Attacher ACR au cluster AKS

Accordez au cluster AKS l'autorisation d'extraire les images de l’ACR provisionné pour que les déploiements futurs puissent accéder à vos images de conteneur.

az aks update \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --attach-acr "${ACR_NAME}" \
  --output table

Vérification

Vérifiez que le cluster AKS existe et répond aux requêtes de base kubectl avant de passer aux étapes de déploiement en aval. Commencez par vérifier que le cluster AKS existe.

if ! az aks show \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --query "{name:name,provisioningState:provisioningState,location:location}" \
  --output table; then
  echo "AKS cluster '${AKS_CLUSTER_NAME}' not found in resource group '${RESOURCE_GROUP}'."
else
  echo "AKS cluster '${AKS_CLUSTER_NAME}' exists in resource group '${RESOURCE_GROUP}'."
fi

Si le cluster AKS a été créé, vous verrez quelque chose comme suit :

AKS cluster ${AKS_CLUSTER_NAME} exists in resource group ${RESOURCE_GROUP}.

Ensuite, vérifiez qu’elle kubectl est correctement configurée :

kubectl cluster-info

Cette commande génère l’état du cluster actuel, comme suit :

Kubernetes control plane is running at ...
CoreDNS is running at https://...
Metrics-server is running at https://...

Enfin, vérifiez qu’il existe à la fois des nœuds système et utilisateur disponibles :

kubectl get nodes -o jsonpath='{range .items[*]}{.metadata.labels.agentpool}{"\n"}{end}' |
  sort |
  uniq -c

Cela génère un nombre de nœuds, comme suit :

      1 system
      1 user

Résumé : Validé que le cluster AKS est présent, sain et accessible via kubectl dans le contexte actuel.

Résumé

Le groupe de ressources, le registre de conteneurs, le cluster AKS, le pool de nœuds facultatif et l'attachement du registre sont validés, laissant le cluster prêt pour toutes les charges de travail conteneurisées.

Étapes suivantes

docs/OpenWebSearch_On_AKS.md Continuer à déployer KMCP et le serveur MCP
Configurer des attributions de rôles ou des stratégies réseau spécifiques à votre posture de sécurité
Intégrer Azure Monitor ou Log Analytics pour une visibilité opérationnelle
Exécuter des commandes de nettoyage d’infrastructure après l’expérimentation pour gérer les coûts

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2025-12-10