AKS kümesine esnek düğüm ekleme (önizleme)

Important

AKS önizleme özellikleri self servis ve kabul temelinde kullanılabilir. Önizlemeler "olduğu gibi" ve "mevcut olduğu şekilde" sağlanmakta olup, hizmet seviyesi anlaşmalarına ve sınırlı garantilere dahil edilmemektedir. AKS önizlemeleri, müşteri desteği ekibi tarafından maksimum çaba gösterilerek kısmen ele alınmaktadır. Bu nedenle, bu özellikler üretim kullanımı için tasarlanmamıştır. Daha fazla bilgi için aşağıdaki destek makalelerine bakın:

Azure Kubernetes Service (AKS) kümesini, ağ yapılandırmasını, esnek düğüm havuzunu, ana bilgisayarı ve kimliği hazırladıktan sonra ana bilgisayarı bootstrap edin ve hedef havuza bağlayın.

Bu makalede şunları yapacaksınız:

  • Flex node sürümünü indirin ve doğrulayın.
  • Güncel havuz verilerini almak için ana bilgisayarı seçili Azure kimliğini kullanarak başlatın.
  • Kubernetes Node, Azure Machine, ağ durumu ve aracı hizmetini doğrulayın.
  • İş yükü yerleşimini, Kubernetes geri çağrılarını ve düğümler arası bağlantıyı doğrulayın.

Bu makaledeki yönetim komutlarını gerekli araçlara ve ağ erişimine sahip Linux uyumlu bir Bash ortamında çalıştırın. Bu makale, bu ortamdan Bash ortamınız olarak söz eder. Kümeye katılan ayrı makine flex node ana bilgisayarıdır; komutları orada yalnızca bir adım bunu açıkça belirtirse çalıştırın.

Özel bir AKS kümesi için, bir Bash ortamından çözümlenebilen ve özel API sunucusuna ulaşabilen tüm kubectl komutları çalıştırın. Bash ortamınız gerekli Azure ve konak erişimine sahip olduğunda Azure CLI, artefakt indirme, SSH ve SCP komutlarını çalıştırabilirsiniz. Flex düğüm ana bilgisayar ağı da özel API uç noktasını çözümleyebilmeli ve ona erişebilmelidir.

Başlamadan önce

  • AKS'de ağ yapılandırmasını tamamlayın ve esnek bir düğüm havuzu oluşturun.
  • Esnek düğüm ana bilgisayarını ve kimliğini hazırlama işlemini tamamlayın.
  • Bash ortamınıza Azure CLI'yi, jq uzantısını, curl sürümünden en fazla bir alt sürüm farklı olan bir AKS_VERSION sürümünü, scp, sha256sum, kubectl, bir OpenSSH istemcisini ve aks-preview yükleyin.
  • Yönetilen kimlik veya hizmet sorumlusu için, seçilen esnek düğüm havuzuna ait önyükleme verilerini alabilen bir Azure hesabı kullanın.
  • Bash ortamınızın onaylanan SSH yönetim yolu üzerinden esnek düğüm konağına ulaşadığından emin olun.
  • Esnek düğüm ana bilgisayarının, havuz önyükleme verilerinde döndürülen yayın ve önyükleme yapıtı uç noktalarına, Azure Resource Manager’a, Microsoft Entra ID’ye ve seçilen AKS API uç noktasına HTTPS üzerinden erişebildiğinden emin olun.

Note

Paylaşılan ortam dosyasında kimlik bilgilerini, sertifikaları, özel anahtarları, erişim belirteçlerini, önyükleme verilerini veya kubeconfig içeriğini depolamayın.

Dağıtım ortamını yükleme

Yeni bir Bash oturumu başlatın, ortam dosyasını tanımlayın ve yükleyin. <deployment-name> öğesini önceki makalelerde kullanılan dağıtım etiketiyle değiştirin.

export FLEXNODE_DEPLOYMENT="<deployment-name>"
export FLEXNODE_ENV_FILE="${HOME}/.config/aks-flexnode/${FLEXNODE_DEPLOYMENT}.env"
test -s "${FLEXNODE_ENV_FILE}"
source "${FLEXNODE_ENV_FILE}"
export KUBECONFIG="${FLEXNODE_KUBECONFIG}"
install -d -m 0700 "${WORK_DIR:?Load the deployment environment first.}"

Ortam dosyası, bu makalenin okuduğu paylaşılan dağıtım değerlerini sağlar; bu makalenin indirmeleri ve oluşturulan dosyaları depoladığı Bash ortamınızdaki dizini de dahil olmak üzere WORK_DIR. Varsayılan olarak, WORK_DIR~/.local/share/aksflexnode/<deployment-name>olarak kabul edilir. Makale, ihtiyaç duyduğu diğer değişkenleri türetir. Ortam dosyasını henüz oluşturmadıysanız önce Esnek düğüm dağıtımınızı planlama işlemini tamamlayın. Komut kabuğu bir hata bildirirse bu adımdan sonra devam etmeyin.

Etkin aboneliği ayarlayın ve Azure, Kubernetes ve konak hedeflerini görüntüleyin:

az account set --subscription "${SUBSCRIPTION_ID}"

az aks show \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${CLUSTER_NAME}" \
    --query "{Cluster:name,ResourceId:id,ApiServer:(privateFqdn || fqdn)}" \
    --output table

kubectl cluster-info

printf 'Recorded flex host: %s\n' "${FLEX_HOST_NAME}"
ssh -i "${SSH_PRIVATE_KEY_PATH}" "${FLEX_HOST_SSH_TARGET}" hostname

ResourceId değerinin AKS_RESOURCE_ID ile eşleştiğini, Kubernetes denetim düzlemi ana bilgisayar adının ApiServer ile eşleştiğini ve SSH komutunun FLEX_HOST_NAME döndürdüğünü doğrulayın. Herhangi bir hedef eşleşmiyorsa, dosyaları aktarmadan veya çalıştırmadan önce ortam dosyasını, kubeconfig'i veya SSH hedefini durdurun ve düzeltin.

flex node sürümünü indirin ve doğrulayın

  1. Ana bilgisayar mimarisini belirleyin ve eşleşen sürüm arşivini seçin.

    HOST_ARCH="$(ssh \
    -i "${SSH_PRIVATE_KEY_PATH}" \
    "${FLEX_HOST_SSH_TARGET}" \
    uname -m)"
export HOST_ARCH

case "${HOST_ARCH}" in
    x86_64) export AGENT_ARCH="amd64" ;;
    aarch64|arm64) export AGENT_ARCH="arm64" ;;
    *)
        printf 'Unsupported host architecture: %s\n' "${HOST_ARCH}" >&2
        false
        ;;
esac

export AGENT_ARCHIVE="aks-flex-node-linux-${AGENT_ARCH}.tar.gz"
printf 'Selected release archive: %s\n' "${AGENT_ARCHIVE}"

  2. Seçili sürümden arşiv ve sağlama toplamı bildirimini indirin.

    curl --fail --location --silent --show-error \
    --proto '=https' \
    --tlsv1.2 \
    "https://github.com/Azure/AKSFlexNode/releases/download/${AKS_FLEX_NODE_VERSION}/${AGENT_ARCHIVE}" \
    --output "${WORK_DIR}/${AGENT_ARCHIVE}"

curl --fail --location --silent --show-error \
    --proto '=https' \
    --tlsv1.2 \
    "https://github.com/Azure/AKSFlexNode/releases/download/${AKS_FLEX_NODE_VERSION}/checksums.txt" \
    --output "${WORK_DIR}/checksums.txt"

  3. Arşiv için tam olarak bir sağlama toplamı girdisi seçin ve dosyayı doğrulayın.

    AGENT_CHECKSUM_ENTRY="$(awk \
    -v file="${AGENT_ARCHIVE}" \
    '$2 == file {print}' \
    "${WORK_DIR}/checksums.txt")"
export AGENT_CHECKSUM_ENTRY

test "$(printf '%s\n' "${AGENT_CHECKSUM_ENTRY}" |
    sed '/^$/d' |
    wc -l)" -eq 1

(
    cd "${WORK_DIR:?Load the deployment environment first.}"
    printf '%s\n' "${AGENT_CHECKSUM_ENTRY}" |
        sha256sum --check --strict -
)

export AGENT_SHA256="${AGENT_CHECKSUM_ENTRY%% *}"
test -n "${AGENT_SHA256}"

    Sağlama toplamı komutu arşivin OK olduğunu bildirmedikçe devam etmeyin.

  4. Aynı sürüm etiketine ait bootstrap betiğini indirin ve Bash sözdizimini doğrulayın.

    curl --fail --location --silent --show-error \
    --proto '=https' \
    --tlsv1.2 \
    "https://raw.githubusercontent.com/Azure/AKSFlexNode/${AKS_FLEX_NODE_VERSION}/scripts/bootstrap.sh" \
    --output "${WORK_DIR}/bootstrap.sh"

chmod 0700 "${WORK_DIR}/bootstrap.sh"
bash -n "${WORK_DIR}/bootstrap.sh"

    Sürüm şu anda bu betik için ayrı bir sağlama toplamı yayımlamaz. Bir kabuğa bağlamadan indirin, doğrulanmış aracı arşiviyle eşleşen bir sürümde tutun ve söz dizimi denetimi başarısız olursa durdurun.

Mevcut havuz önyükleme verilerini al

Yönetilen kimlik ve hizmet sorumlusu kimliği akışları, Bash ortamınızda elde ettiğiniz bootstrap verilerini kullanır. Azure Arc yönetilen kimliğini seçtiyseniz bu bölümü atlayın. Arc bootstrap komutu Arc makine kimliği aracılığıyla yeni verileri alır.

Yönetilen kimlik veya hizmet ilkesi için, verileri dosyaları konağa aktarmadan hemen önce alın. Yanıt, bir saat sonra süresi dolan bir bootstrap belirteci içerir. Yanıtı yazdırmayın veya notlarda depolamayın.

az aks nodepool get-bootstrap-data \
    --resource-group "${RESOURCE_GROUP}" \
    --cluster-name "${CLUSTER_NAME}" \
    --name "${FLEX_POOL_NAME}" \
    --output json \
    > "${WORK_DIR}/base-config.json"

chmod 0600 "${WORK_DIR}/base-config.json"
test -s "${WORK_DIR}/base-config.json"

${WORK_DIR}/base-config.json varsa ve boş değilse devam edin. Aktarımı ve ana bilgisayar başlatmasını bir saat içinde tamamlayın. Belirtecin süresi dolarsa komutunu yeniden çalıştırın ve eski dosyayı değiştirin.

Dosyaları aktarın ve ana bilgisayarı hazırlayın

  1. Gizli olmayan bir ana bilgisayar devir dosyası oluşturun.

    {
    printf 'export AGENT_ARCHIVE=%q\n' "${AGENT_ARCHIVE}"
    printf 'export AGENT_SHA256=%q\n' "${AGENT_SHA256}"
    printf 'export AKS_FLEX_NODE_VERSION=%q\n' "${AKS_FLEX_NODE_VERSION}"
    printf 'export AKS_RESOURCE_ID=%q\n' "${AKS_RESOURCE_ID}"
    printf 'export FLEX_POOL_NAME=%q\n' "${FLEX_POOL_NAME}"
    printf 'export FLEX_HOST_PRIVATE_IP=%q\n' "${FLEX_HOST_PRIVATE_IP}"
    printf 'export HOST_IDENTITY_CLIENT_ID=%q\n' "${HOST_IDENTITY_CLIENT_ID:-}"
    printf 'export SP_TENANT_ID=%q\n' "${SP_TENANT_ID:-}"
    printf 'export SP_CLIENT_ID=%q\n' "${SP_CLIENT_ID:-}"
} > "${WORK_DIR}/host-bootstrap.env"

chmod 0600 "${WORK_DIR}/host-bootstrap.env"

  2. Doğrulanmış sürüm dosyalarını ve devir dosyasını ana bilgisayara kopyalayın.

    scp -i "${SSH_PRIVATE_KEY_PATH}" \
    "${WORK_DIR}/${AGENT_ARCHIVE}" \
    "${WORK_DIR}/bootstrap.sh" \
    "${WORK_DIR}/host-bootstrap.env" \
    "${FLEX_HOST_SSH_TARGET}:/tmp/"

  3. Yönetilen kimlik veya hizmet sorumlusu için korumalı önyükleme verilerini de kopyalayın:

    scp -i "${SSH_PRIVATE_KEY_PATH}" \
    "${WORK_DIR}/base-config.json" \
    "${FLEX_HOST_SSH_TARGET}:/tmp/"

  4. Ana bilgisayara bağlanın ve bir root kabuğu açın:

    ssh -i "${SSH_PRIVATE_KEY_PATH}" "${FLEX_HOST_SSH_TARGET}"
sudo -i

  5. Güvenli olmayan iletim değerlerini yükleyin ve aktarılan dosyaları doğrulayın:

    source /tmp/host-bootstrap.env
chmod 0600 "/tmp/${AGENT_ARCHIVE}" /tmp/host-bootstrap.env
chmod 0700 /tmp/bootstrap.sh
bash -n /tmp/bootstrap.sh
printf '%s  %s\n' \
    "${AGENT_SHA256}" \
    "/tmp/${AGENT_ARCHIVE}" |
    sha256sum --check --strict -

    Sağlama toplamı komutu arşivin OK olduğunu bildirdiğinde devam edin. Sağlama toplamı veya betik söz dizimi denetimi başarısız olursa durdurun.

  6. Yönetilen kimlik veya hizmet sorumlusu için bootstrap verilerini yükleyin:

    install -d -o root -g root -m 0700 /etc/aks-flex-node
install -o root -g root -m 0600 \
    /tmp/base-config.json \
    /etc/aks-flex-node/base-config.json
test -s /etc/aks-flex-node/base-config.json

Ana bilgisayarı önyükle

Yalnızca önceki makalede yapılandırılan kimlikle eşleşen bölümü tamamlayın.

Bu bölümü yalnızca, önceki makalede doğrulandığı üzere Arc makine kaynağı SSH ana bilgisayarıyla eşleştikten, himdsd etkin olduktan, HIMDS doğrulaması ilgili AKS kaynağı için HTTP 200 döndürdükten ve AKS kapsamındaki rol ataması mevcut olduktan sonra kullanın. Bu yol, Arc makine kimliği aracılığıyla yeni önyükleme verilerini alır ve Bash ortamınızdaki base-config.json dosyasını kullanmaz.

CONFIG_OVERRIDES="$(jq -cn \
    --arg nodeIP "${FLEX_HOST_PRIVATE_IP}" \
    '{node:{kubelet:{nodeIP:$nodeIP}}}')"
export CONFIG_OVERRIDES

bash /tmp/bootstrap.sh \
    --auth arc \
    --fetch-bootstrap-data \
    --cluster-resource-id "${AKS_RESOURCE_ID}" \
    --agent-pool-name "${FLEX_POOL_NAME}" \
    --agent-url "file:///tmp/${AGENT_ARCHIVE}" \
    --agent-sha256 "${AGENT_SHA256}" \
    --config-overrides "${CONFIG_OVERRIDES}"

Çıktıda Arc preflight: OK bildirildiğinde, makine kaydı tamamlandığında ve bootstrap betiği flex node agent hizmetinin başlatıldığını bildirdiğinde devam edin. Bootstrap verileri alamıyorsa Arc bağlantısını, himdsd, AKS kapsamındaki rol atamasını ve konağın Azure Resource Manager'a erişimini doğrulayın.

Geçici sürüm dosyalarını kaldırma

Bootstrap işlemi başarıyla tamamlandıktan sonra geçici betiği, arşivi ve devir dosyasını ana makineden kaldırın:

rm -f \
    "/tmp/${AGENT_ARCHIVE}" \
    /tmp/bootstrap.sh \
    /tmp/base-config.json \
    /tmp/host-bootstrap.env
exit
exit

İlki exit kök kabuğu bırakır. İkincisi SSH oturumunu kapatır ve Bash ortamınıza döner.

Bash ortamınızdaki kopyaları kaldırın:

rm -f \
    "${WORK_DIR:?Load the deployment environment first.}/${AGENT_ARCHIVE}" \
    "${WORK_DIR}/bootstrap.sh" \
    "${WORK_DIR}/base-config.json" \
    "${WORK_DIR}/host-bootstrap.env" \
    "${WORK_DIR}/checksums.txt"

Ana bilgisayar bağlı kaldığı sürece /etc/aks-flex-node ve hizmet sorumlusu kimlik bilgisini koruyun. Çalışan ajan, düğüm ve Azure makine uzlaştırması için bu yapılandırmayı kullanır.

Kubernetes düğümünü doğrulama

Düğüm adını paylaşılan ortamda kaydedilen Linux ana bilgisayar adı olarak ayarlayın. İlk olarak, Node nesnesinin oluşturulmasını bekleyin ve ardından hazır olmasını bekleyin:

export FLEX_NODE_NAME="$(printf '%s' "${FLEX_HOST_NAME}" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')"

kubectl wait \
    --for=create \
    "node/${FLEX_NODE_NAME}" \
    --timeout=5m

kubectl wait \
    --for=condition=Ready \
    "node/${FLEX_NODE_NAME}" \
    --timeout=10m

kubectl get node "${FLEX_NODE_NAME}" -o wide

Düğüm Ready olduğunda devam edin. Düğüm oluşturulmazsa veya hazır hâle gelmezse bootstrap işlemini yeniden denemeden önce bootstrap çıktısını, API bağlantısını ve aracı hizmetini doğrulayın.

Azure Makinesi kaynağını doğrulama

  1. Hedef esnek düğüm havuzundaki Makineleri listeleyin.

    az aks machine list \
    --resource-group "${RESOURCE_GROUP}" \
    --cluster-name "${CLUSTER_NAME}" \
    --nodepool-name "${FLEX_POOL_NAME}" \
    --query "[].{name:name,state:properties.provisioningState,nodeName:properties.kubernetes.nodeName,version:properties.kubernetes.currentOrchestratorVersion}" \
    --output table

  2. Hazırlanan Kubernetes düğümünü kaydeden Makineyi bulun:

    FLEX_MACHINE_NAME="$(az aks machine list \
    --resource-group "${RESOURCE_GROUP}" \
    --cluster-name "${CLUSTER_NAME}" \
    --nodepool-name "${FLEX_POOL_NAME}" \
    --query "[?properties.kubernetes.nodeName=='${FLEX_NODE_NAME}'].name | [0]" \
    --output tsv)"
export FLEX_MACHINE_NAME

printf 'Machine: %s\n' "${FLEX_MACHINE_NAME}"

    Komut tam olarak bir makine adı döndürdüğünde devam edin.

  3. Bu Makineyi göster:

    az aks machine show \
    --resource-group "${RESOURCE_GROUP}" \
    --cluster-name "${CLUSTER_NAME}" \
    --nodepool-name "${FLEX_POOL_NAME}" \
    --machine-name "${FLEX_MACHINE_NAME}" \
    --output yaml

    Makine mevcutsa, FLEX_NODE_NAME öğesine başvuruyorsa ve başarılı bir sağlama durumu bildiriyorsa devam edin. Yaşam döngüsü işlemleri için Makine adını kaydedin:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Esnek düğüm ağını doğrulama

  1. Flex site'ı, pod CIDR’sini ve WireGuard açık anahtarını görüntüleyin.

    kubectl get node "${FLEX_NODE_NAME}" \
    -L net.unbounded-cloud.io/site \
    -o wide

kubectl get node "${FLEX_NODE_NAME}" \
    -o jsonpath='{.metadata.name}{" site="}{.metadata.labels.net\.unbounded-cloud\.io/site}{" podCIDR="}{.spec.podCIDR}{" wg="}{.metadata.annotations.net\.unbounded-cloud\.io/wg-pubkey}{"\n"}'

  2. Siteler ve ilgili Unbounded-Net ağ kaynaklarını doğrulayın.

    kubectl get \
    sites,sitenodeslices,gatewaypools,sitegatewaypoolassignments,gatewaypoolpeerings \
    -o wide

  3. Esnek düğüme atanmış Unbounded-Net podlarını görüntüleyin.

    kubectl get pods --all-namespaces \
    --field-selector "spec.nodeName=${FLEX_NODE_NAME}" \
    -o wide

Şu durumlar dışında iş yükü doğrulamasına devam etmeyin:

  • Düğüm Ready şeklindedir.
  • Site, ağ oluşturma makalesinde yapılandırılan Unbounded-Net flex sitesidir.
  • Pod CIDR’si planlanan FLEX_POD_CIDR aralığına aittir.
  • WireGuard ortak anahtarı doldurulur.
  • cluster-flex-private-l3 SitePeering, flex-site ve cluster Sitelerine atıfta bulunur.
  • Düğümde döndürülen her Unbounded-Net podu Running durumundadır.
  • Genel WireGuard topolojisi için beklenen ağ geçidi havuzu eşlemesi mevcut.

Flex düğüm aracısını doğrulayın

Hizmetin etkin hale gelmesi için bir dakika kadar bekleyin. Olmazsa hizmet durumunu ve son günlük kayıtlarını görüntüleyin:

ssh -i "${SSH_PRIVATE_KEY_PATH}" "${FLEX_HOST_SSH_TARGET}" \
    'set -euo pipefail
     for attempt in {1..12}; do
         if sudo systemctl is-active --quiet aks-flex-node-agent; then
             sudo systemctl show aks-flex-node-agent \
                 -p ActiveState \
                 -p SubState \
                 -p Result \
                 -p NRestarts
             exit 0
         fi
         sleep 5
     done

     sudo systemctl show aks-flex-node-agent \
         -p ActiveState \
         -p SubState \
         -p Result \
         -p NRestarts
     sudo journalctl -u aks-flex-node-agent --no-pager -n 80
     exit 1'

Çıktı SubState=running, Result=success ve ActiveState=active içerdiğinde devam edin.

Aracı kaynakları listeleyemediğinden MachineOperation tekrar tekrar yeniden başlatılırsa Ağı yapılandırma ve AKS'de esnek düğüm havuzu oluşturma bölümünde geçici esnek daemon RBAC adımına dönün, rolün ve bağlamanın mevcut olduğunu doğrulayın ve aracıyı yeniden başlatın:

ssh -i "${SSH_PRIVATE_KEY_PATH}" "${FLEX_HOST_SSH_TARGET}" \
    'sudo systemctl restart aks-flex-node-agent'

İş yükü yerleşimini ve bağlantısını doğrulama

Doğrulama iş yükü oluşturma

Ayrılmış bir ad alanı oluşturun. Bu ad alanı zaten varsa, yeniden denemeden önce önceki doğrulama çalıştırmasını temizleyin.

export VALIDATION_NAMESPACE="flex-node-validation"

if kubectl get namespace "${VALIDATION_NAMESPACE}" >/dev/null 2>&1; then
    printf 'Validation namespace already exists: %s\n' \
        "${VALIDATION_NAMESPACE}" >&2
    false
fi

kubectl create namespace "${VALIDATION_NAMESPACE}"
kubectl label namespace "${VALIDATION_NAMESPACE}" \
    app.kubernetes.io/managed-by=flex-node-article

Kubernetes zamanlayıcısının esnek düğüme yerleştirdiğini bir HTTP sunucusu oluşturun ve bunu bir ClusterIP Hizmeti aracılığıyla kullanıma sunun:

kubectl --namespace "${VALIDATION_NAMESPACE}" run flex-http-server \
    --image=busybox:1.36 \
    --restart=Never \
    --labels app=flex-http \
    --overrides="{\"spec\":{\"nodeSelector\":{\"kubernetes.io/hostname\":\"${FLEX_NODE_NAME}\"},\"tolerations\":[{\"operator\":\"Exists\"}]}}" \
    --command -- sh -c \
    'mkdir -p /www; echo flex-network-ok >/www/index.html; exec httpd -f -p 8080 -h /www'

kubectl --namespace "${VALIDATION_NAMESPACE}" wait \
    --for=condition=Ready \
    pod/flex-http-server \
    --timeout=3m

kubectl --namespace "${VALIDATION_NAMESPACE}" expose pod flex-http-server \
    --name=flex-http-service \
    --port=8080 \
    --target-port=8080

Geri çağrıları ve yerel hizmet bağlantısını doğrulayın

Kubernetes API sunucusu geri çağırma yolunu kullanarak günlükleri ve komut yürütmeyi denetleyin:

kubectl --namespace "${VALIDATION_NAMESPACE}" logs flex-http-server --tail=5
kubectl --namespace "${VALIDATION_NAMESPACE}" exec flex-http-server -- \
    sh -c 'printf "exec-callback-ok\n"'

ClusterIP'yi alın ve esnek düğüm iş yükünden hizmet isteyin:

SERVICE_IP="$(kubectl --namespace "${VALIDATION_NAMESPACE}" \
    get service flex-http-service \
    --output jsonpath='{.spec.clusterIP}')"
export SERVICE_IP

kubectl --namespace "${VALIDATION_NAMESPACE}" exec flex-http-server -- \
    wget -qO- "http://${SERVICE_IP}:8080"

Beklenen yanıt:

flex-network-ok

Bağlantı noktası yönlendirmesini doğrulayın

Geçerli terminalde, Kubernetes API sunucusu aracılığıyla yerel bir bağlantı noktasını iletin. Bu komut, daha önce yüklediğiniz dağıtım ortamını ve kubeconfig'i kullanır:

kubectl --namespace "${VALIDATION_NAMESPACE}" \
    port-forward pod/flex-http-server 18080:8080

İkinci bir terminalde iletilen uç noktayı isteyin:

curl -fsS http://127.0.0.1:18080

Beklenen yanıt şekildedir: flex-network-ok. Denetimden sonraki ilk terminalde Ctrl+C tuşlarına basın.

AKS tarafından yönetilen düğümden bağlantıyı doğrulama

Aks tarafından yönetilen hazır bir sistem düğümü bulun:

SYSTEM_NODE="$(kubectl get nodes \
    --selector agentpool=systempool \
    --output json |
    jq -r '
        .items[]
        | select(any(.status.conditions[];
            .type == "Ready" and .status == "True"))
        | .metadata.name
    ' |
    head -n 1)"
export SYSTEM_NODE

test -n "${SYSTEM_NODE}"
printf 'Managed-node test target: %s\n' "${SYSTEM_NODE}"

Bu düğümde bir istemci podunu çalıştırın ve beklenen yanıtı denetleyin:

kubectl --namespace "${VALIDATION_NAMESPACE}" run system-http-client \
    --image=busybox:1.36 \
    --restart=Never \
    --overrides="{\"spec\":{\"nodeSelector\":{\"kubernetes.io/hostname\":\"${SYSTEM_NODE}\"}}}" \
    --command -- sh -c \
    "test \"\$(wget -qO- http://${SERVICE_IP}:8080)\" = flex-network-ok"

kubectl --namespace "${VALIDATION_NAMESPACE}" wait \
    --for=jsonpath='{.status.phase}'=Succeeded \
    pod/system-http-client \
    --timeout=3m

kubectl --namespace "${VALIDATION_NAMESPACE}" \
    get pod flex-http-server system-http-client -o wide

Ready durumundaki bir Kubernetes düğümü, düğümün kaydedildiğini gösterir. İş yükü ağını, geri çağırma işlemlerini veya Azure yaşam döngüsü işlemlerini tek başına kanıtlamaz.

Doğrulama iş yükünü temizleme

Yalnızca bu makalede oluşturduğunuz geçici kaynakları kaldırın.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Sonraki adım

Ardından, ekli esnek düğümü yönetin, güncelleştirin, yükseltin veya kaldırın.

  • Son güncelleştirme: