Erstellen der Azure AKS-Infrastruktur

In diesem Artikel stellen Sie die wichtigsten Azure-Ressourcen bereit, die für eine produktionsfähige AKS-Bereitstellung erforderlich sind. In diesem Artikel wird der Azure-Zugriff überprüft, eine Ressourcengruppe erstellt, eine Azure Container Registry (ACR) eingerichtet, ein Basis-AKS-Cluster bereitgestellt, optional ein zusätzlicher Knotenpool für Benutzerworkloads hinzugefügt und der Clusterberechtigung zum Abrufen von ACR gewährt. Alle Befehle basieren auf parametrisierten Umgebungsvariablen, sodass der Workflow in allen Regionen und Abonnements wiederholbar bleibt.

Voraussetzungen

Sie benötigen die folgenden Tools und den Kontozugriff, bevor Sie das Handbuch ausführen. Stellen Sie sicher, dass Sie mit az login bei Azure authentifiziert sind und über ausreichende Berechtigungen verfügen, um Ressourcengruppen, Container Registries und AKS-Cluster zu erstellen.

  • Azure-Abonnement mit Kontingent für die ausgewählte Region
  • Azure CLI (az) mit Besitzer- oder Mitwirkendenrechten
  • kubectl für den Clusterzugriff lokal konfiguriert
  • jq (optional) zum Analysieren der JSON-Ausgabe während der Überprüfung

Führen Sie die folgenden Befehle aus, um zu bestätigen, dass Sie über alle erforderlichen CLI-Tools und Azure-Zugriff verfügen:

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)"

Einrichten der Umgebung

Hier definieren Sie alle Umgebungsvariablen, die während der Bereitstellungsschritte verwendet werden. Der HASH Zeitstempel sorgt dafür, dass Ressourcennamen bei wiederholten Ausführungen einzigartig bleiben. Standardwerte für Cluster und Registrierung zielen auf einen minimalen Proof-of-Concept-Footprint ab, aber Sie können sie bei Bedarf anpassen.

Die folgenden Befehle richten Azure-Bereichs-, AKS-Größen- und ACR-Benennungskonventionen für die Bereitstellungssequenz unabhängig von nachgelagerten Workloads ein.

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}"

Überprüfen von Umgebungsvariablenwerten

Überprüfen Sie die effektive Konfiguration, bevor Sie Ressourcen erstellen. Führen Sie den Block nach allen Anpassungen erneut aus, um sicherzustellen, dass die aktiven Werte für das Zielabonnement und die Zielregion korrekt sind.

Verwenden Sie die folgenden Befehle, um die aktiven Parameter einzugeben, um die Benennung, die Größe und die Wahl der Region zu überprüfen.

: "${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

Steps

Führen Sie jeden Schritt sequenziell aus. Jeder Unterabschnitt enthält Zweck, Befehle und eine Zusammenfassung, um die erwarteten Ergebnisse zu bestätigen.

Überprüfen des Azure-Abonnementkontexts

Überprüfen Sie das aktive Azure-Abonnement, und stellen Sie sicher, dass die für AKS- und ACR-Vorgänge erforderlichen Ressourcenanbieter registriert sind.

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

Erstellen einer Ressourcengruppe

Stellen Sie eine dedizierte Ressourcengruppe bereit, um den AKS-Cluster, die Registrierung und die unterstützende Infrastruktur für Ihre Workloads zu isolieren.

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

Bereitstellen der Azure-Containerregistrierung

Erstellen Sie eine Azure Container-Registrierung zum Speichern von Containerimages und authentifizieren Sie den lokalen Docker-Daemon, um Images zu pushen.

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

Erstellen des AKS-Clusters

Stellen Sie den AKS-Cluster bereit, um Ihre Workloads zu hosten. Schützen Sie sich vor dem Erneuten Verwenden eines vorhandenen Clusternamens, indem Sie vor der Erstellung überprüfen.

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

Hinzufügen eines optionalen Benutzerknotenpools

Stellen Sie auf Anfrage einen zusätzlichen Knotenpool bereit. Der Befehl zum Hinzufügen wird asynchron ausgeführt, um CLI-Timeouts zu vermeiden. Der Wartebefehl verfolgt den Fortschritt von Azure. Das Skript überprüft zunächst, ob der Pool bereits vorhanden ist, um Doppelte Namensfehler zu vermeiden.

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

Abrufen von Clusteranmeldeinformationen

Integrieren Sie die AKS kubeconfig in den lokalen Kontext und stellen Sie sicher, dass alle Knoten erreichbar sind.

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

Fügen Sie ACR an das AKS-Cluster an

Erteilen Sie der AKS-Clusterberechtigung, um Images aus dem bereitgestellten ACR abzurufen, damit zukünftige Bereitstellungen auf Ihre Containerimages zugreifen können.

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

Verifizierung

Vergewissern Sie sich, dass der AKS-Cluster vorhanden ist und auf grundlegende kubectl Abfragen antwortet, bevor Sie mit den nachgeschalteten Bereitstellungsschritten fortfahren. Stellen Sie zunächst sicher, dass der AKS-Cluster vorhanden ist.

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

Wenn der AKS-Cluster erstellt wurde, wird folgendes angezeigt:

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

Überprüfen Sie als Nächstes, dass kubectl ordnungsgemäß konfiguriert ist:

kubectl cluster-info

Dieser Befehl gibt den Status des aktuellen Clusters aus, z. B.:

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

Stellen Sie abschließend sicher, dass sowohl System- als auch Benutzerknoten verfügbar sind:

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

Dadurch wird eine Anzahl von Knoten ausgegeben, z. B.:

      1 system
      1 user

Zusammenfassung: Überprüft, dass der AKS-Cluster vorhanden, fehlerfrei und erreichbar über Kubectl im aktuellen Kontext ist.

Zusammenfassung

Die Ressourcengruppe, die Container-Registry, der AKS-Cluster, der optionale Knotenpool und die Registry-Anbindung werden validiert, sodass der Cluster für alle containerisierten Workloads bereit ist.

Nächste Schritte

  • Fahren Sie mit docs/OpenWebSearch_On_AKS.md fort, um KMCP und den MCP-Server bereitzustellen
  • Konfigurieren von Rollenzuweisungen oder Netzwerkrichtlinien speziell für Ihren Sicherheitsstatus
  • Integrieren von Azure Monitor oder Log Analytics zur betrieblichen Sichtbarkeit
  • Ausführen von Bereinigungsbefehlen für die Infrastruktur nach der Experimentierphase zur Kostenverwaltung
  • Zuletzt aktualisiert um