Tworzenie infrastruktury usługi Azure AKS

W tym artykule konfigurujesz podstawowe zasoby platformy Azure wymagane do wdrożenia klastra AKS przygotowanego do produkcyjnego użycia. W tym artykule weryfikuje się dostęp do platformy Azure, zakłada grupę zasobów, zakłada Azure Container Registry (ACR), wdraża klaster bazowy AKS, opcjonalnie dodaje dodatkową pulę węzłów dla obciążeń użytkowników i przyznaje klastrowi uprawnienia do pobierania z ACR. Wszystkie polecenia bazują na sparametryzowanych zmiennych środowiskowych, dzięki czemu przepływ pracy pozostaje powtarzalny w różnych regionach i subskrypcjach.

Wymagania wstępne

Przed uruchomieniem przewodnika potrzebne są następujące narzędzia i dostęp do konta. Upewnij się, że jesteś uwierzytelniony w Azure przy użyciu az login i posiadasz wystarczające uprawnienia do tworzenia grup zasobów, rejestrów kontenerów i klastrów AKS.

Subskrypcja platformy Azure z limitem przydziału dla wybranego regionu
Azure CLI (az) z uprawnieniami Właściciela lub Współautora
narzędzie kubectl skonfigurowane lokalnie na potrzeby dostępu do klastra
jq (opcjonalnie) do analizowania danych wyjściowych JSON podczas weryfikacji

Uruchom następujące polecenia, aby potwierdzić, że masz wszystkie niezbędne narzędzia interfejsu wiersza polecenia i dostęp do platformy 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)"

Konfigurowanie środowiska

W tym miejscu zdefiniujesz wszystkie zmienne środowiskowe używane w ramach kroków aprowizacji. Znacznik HASH czasu zapewnia unikatowe nazwy zasobów podczas powtarzających się operacji. Wartości domyślne klastra i rejestru są przeznaczone dla minimalnego śladu weryfikacji koncepcji, ale można je dostosować zgodnie z potrzebami.

Następujące polecenia określają zakres platformy Azure, ustalanie rozmiaru usługi AKS i konwencje nazewnictwa usługi ACR dla sekwencji aprowizacji niezależnie od obciążeń podrzędnych.

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

Weryfikowanie wartości zmiennych środowiskowych

Przed utworzeniem zasobów przejrzyj obowiązującą konfigurację. Uruchom ponownie blok po wszelkich korektach, aby upewnić się, że aktywne wartości są poprawne dla subskrypcji docelowej i regionu.

Użyj następujących poleceń, aby wyświetlić aktywne parametry w celu zweryfikowania nazw, rozmiarów i wyborów regionalnych.

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

Wykonaj każdy krok sekwencyjnie. Każda podsekcja zawiera przeznaczenie, polecenia i podsumowanie w celu potwierdzenia oczekiwanych wyników.

Sprawdzanie kontekstu subskrypcji platformy Azure

Zweryfikuj aktywną subskrypcję platformy Azure i upewnij się, że dostawcy zasobów wymagani dla operacji usługi AKS i usługi ACR są zarejestrowani.

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

Tworzenie grupy zasobów

Przydziel dedykowaną grupę zasobów w celu odizolowania klastra AKS, rejestru i infrastruktury pomocniczej dla obciążeń roboczych.

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

Skonfiguruj Azure Container Registry

Utwórz usługę Azure Container Registry do przechowywania obrazów kontenerów i uwierzytelnij lokalnego demona platformy Docker w celu wypychania obrazów.

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

Utwórz klaster AKS

Wdróż klaster usługi AKS do hostowania obciążeń. Unikaj ponownego użycia istniejącej nazwy klastra, sprawdzając przed utworzeniem.

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

Dodawanie opcjonalnej puli węzłów użytkownika

Udostępnij dodatkową pulę węzłów na żądanie. Polecenie dodawania jest uruchamiane asynchronicznie, aby uniknąć przekroczenia limitu czasu CLI; polecenie wait śledzi postęp Azure. Skrypt najpierw sprawdza, czy pula już istnieje, aby zapobiec błędom zduplikowanych nazw.

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

Pobieranie poświadczeń klastra

Połącz plik kubeconfig usługi AKS do kontekstu lokalnego i sprawdź, czy wszystkie węzły są dostępne.

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

Dołącz ACR do klastra AKS

Udziel klastrowi usługi AKS uprawnienia do pobierania obrazów z aprowizowanego rejestru ACR, aby przyszłe wdrożenia mogły uzyskiwać dostęp do obrazów kontenerów.

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

Verification

Przed kontynuowaniem dalszych kroków wdrażania upewnij się, że klaster usługi AKS istnieje i odpowiada na podstawowe kubectl zapytania. Zacznij od upewnienia się, że klaster usługi AKS istnieje.

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

Jeśli klaster usługi AKS został utworzony, zobaczysz coś takiego jak:

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

Następnie sprawdź, czy kubectl poprawnie skonfigurowano:

kubectl cluster-info

To polecenie wyświetli stan bieżącego klastra, coś w rodzaju:

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

Na koniec upewnij się, że są dostępne węzły systemowe i węzły użytkownika:

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

Spowoduje to wyliczenie liczby węzłów, takich jak:

      1 system
      1 user

Podsumowanie: Zweryfikowano, że klaster AKS jest obecny, w dobrej kondycji i dostępny przez kubectl w bieżącym kontekście.

Podsumowanie

Grupa zasobów, rejestr kontenerów, klaster AKS, opcjonalna pula węzłów oraz załącznik rejestru są weryfikowane, dzięki czemu klaster jest gotowy do obsługi wszystkich konteneryzowanych zadań.

Dalsze kroki

docs/OpenWebSearch_On_AKS.md Przejdź do wdrożenia narzędzia KMCP i serwera MCP
Konfiguruj przypisania ról lub zasady sieci dostosowane do stanu zabezpieczeń.
Integrowanie usługi Azure Monitor lub Log Analytics w celu uzyskania widoczności operacyjnej
Uruchamiaj polecenia do oczyszczania infrastruktury po eksperymentowaniu, aby zarządzać kosztami

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2025-12-11