Připojení flexibilního uzlu ke clusteru AKS (Preview)

Important

Funkce AKS ve verzi Preview jsou k dispozici na bázi samoobsluhy a dobrovolného přihlášení. Ukázky jsou poskytovány "tak, jak jsou" a "dle dostupnosti" a jsou vyloučeny ze smluv o úrovni služeb a z omezené záruky. Předběžné verze AKS jsou částečně pokryty zákaznickou podporou podle možností. Proto tyto funkce nejsou určené pro produkční použití. Další informace najdete v následujících článcích podpory:

Jakmile připravíte cluster služby Azure Kubernetes Service (AKS), síťové prostředí, flexibilní fond uzlů, hostitele a identitu, proveďte inicializaci hostitele a připojte ho k cílovému fondu.

V tomto článku se dozvíte:

  • Stáhněte a ověřte uvolnění flexibilního uzlu.
  • Inicializujte hostitele pomocí jeho vybrané identity Azure, aby načetl aktuální data fondu.
  • Ověřte uzel Kubernetes, počítač Azure, stav sítě a službu agenta.
  • Ověřte umístění úloh, zpětná volání Kubernetes a připojení mezi uzly.

Příkazy pro správu v tomto článku spusťte v prostředí Bash kompatibilním s Linuxem, které má požadované nástroje a síťový přístup. Tento článek označuje toto prostředí jako prostředí Bash. Samostatný počítač, který se připojuje ke clusteru, je hostitel uzlu Flex; příkazy tam spouštějte jen tehdy, když vás k tomu některý krok výslovně vyzve.

V případě privátního clusteru AKS spusťte každý kubectl příkaz z prostředí Bash, které dokáže přeložit a spojit se se serverem privátního rozhraní API. Příkazy Azure CLI, příkazy pro stahování artefaktů a příkazy SSH a SCP můžete spouštět z prostředí Bash, pokud má vaše prostředí Bash požadovaný přístup k Azure a hostiteli. Hostitelská síť flex node musí také přeložit a spojit se s koncovým bodem privátního rozhraní API.

Než začnete

  • Dokončete konfiguraci sítě a vytvořte fond flexibilních uzlů v AKS.
  • Dokončete přípravu hostitele a identity flexibilního uzlu.
  • Nainstalujte si do svého prostředí Bash Azure CLI, rozšíření aks-preview, verzi kubectl, která se od AKS_VERSION liší nejvýše o jednu podverzi, jq, curl, sha256sum, klienta OpenSSH a scp.
  • Pro spravovanou identitu nebo instanční objekt služby použijte účet Azure, který může načíst spouštěcí data pro vybraný flex fond uzlů.
  • Ujistěte se, že se vaše prostředí Bash může spojit s hostitelem flexibilního uzlu přes schválenou cestu správy SSH.
  • Ujistěte se, že hostitel uzlu typu Flex má přes protokol HTTPS přístup ke koncovým bodům artefaktů pro vydání a bootstrap, které jsou vráceny v bootstrap datech fondu, ke službě Azure Resource Manager, Microsoft Entra ID a k vybranému koncovému bodu rozhraní AKS API.

Note

Neukládejte přihlašovací údaje, certifikáty, privátní klíče, přístupové tokeny, data bootstrap ani obsah kubeconfig v souboru sdíleného prostředí.

Načtení prostředí nasazení

Spusťte novou relaci Bash, určete soubor prostředí a načtěte jej. Nahraďte <deployment-name> popiskem nasazení použitým v předchozích článcích.

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

Soubor prostředí poskytuje sdílené hodnoty nasazení, které tento článek přečte, včetně WORK_DIRadresáře ve vašem prostředí Bash, kde tento článek ukládá soubory ke stažení a vygenerování. Ve výchozím nastavení je WORK_DIR~/.local/share/aksflexnode/<deployment-name>. Článek odvozuje všechny další proměnné, které potřebuje. Pokud jste soubor prostředí ještě nevytvořili, nejprve naplánujte nasazení flexibilních uzlů . Nepokračujte za tento krok, pokud shell hlásí chybu.

Nastavte aktivní předplatné a zobrazte Azure, Kubernetes a hostitelské cíle:

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

Ověřte, že ResourceId odpovídá AKS_RESOURCE_ID, název hostitele řídicí roviny Kubernetes odpovídá ApiServer a příkaz SSH vrací FLEX_HOST_NAME. Pokud se některý cíl neshoduje, před přenosem nebo spuštěním souborů zastavte a opravte soubor prostředí, kubeconfig nebo cíl SSH.

Stáhněte a ověřte verzi Flex node

  1. Identifikujte architekturu hostitele a vyberte odpovídající archiv vydaných verzí.

    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. Stáhněte archiv a manifest kontrolních součtů z vybraného vydání.

    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. Vyberte pro archiv přesně jednu položku kontrolního součtu a ověřte soubor.

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

    Nepokračujte, pokud příkaz pro kontrolní součet nehlásí, že archiv je OK.

  4. Stáhněte bootstrap skript ze stejného tagu vydání a ověřte jeho syntaxi interpretu Bash.

    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"

    Verze aktuálně nepublikuje samostatný kontrolní součet pro tento skript. Stáhněte jej bez přesměrování do shellu, udržujte jeho verzi v souladu s ověřeným archivem agenta a ukončete proces, pokud kontrola syntaxe selže.

Načíst aktuální bootstrap data poolu

Spravovaná identita a cesty instančního objektu používají data bootstrap, která načtete ve svém prostředí Bash. Pokud jste vybrali Azure Arc spravovanou identitu, přeskočte tuto část. Příkaz Bootstrap Arc načte čerstvá data prostřednictvím identity počítače Arc.

Pro spravovanou identitu nebo instanční objekt načtěte data bezprostředně před přenosem souborů do hostitele. Odpověď obsahuje token bootstrap, jehož platnost vyprší po jedné hodině. Nevytiskávejte odpověď ani ji neukládejte do poznámek.

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"

Pokračujte, pokud ${WORK_DIR}/base-config.json existuje a není prázdný. Dokončete přenos a spuštění hostitele do jedné hodiny. Pokud platnost tokenu vyprší, spusťte příkaz znovu a nahraďte starý soubor.

Přenos souborů a příprava hostitele

  1. Vytvořte neutajovaný soubor pro předání hostitele.

    {
    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. Zkopírujte ověřené soubory vydání a předávací soubor na hostitele.

    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. Pro spravovanou identitu nebo objekt služby také zkopírujte chráněná zaváděcí data:

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

  4. Připojte se k hostiteli a spusťte shell s právy uživatele root:

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

  5. Načtěte neutajované předávací hodnoty a ověřte přenesené soubory:

    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 -

    Pokračujte, jakmile příkaz pro kontrolní součet ohlásí, že archiv je OK. Zastavte, pokud se nezdaří kontrola kontrolního součtu nebo syntaxe skriptu.

  6. Pro spravovanou identitu nebo instanční objekt nainstalujte data bootstrap:

    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

Inicializace hostitele

Vyplňte pouze část, která odpovídá identitě nakonfigurované v předchozím článku.

Tuto část použijte až poté, co prostředek počítače s Arc odpovídá hostiteli SSH, himdsd je aktivní, ověření HIMDS vrací kód HTTP 200 pro daný prostředek AKS a existuje přiřazení role v oboru AKS, jak bylo ověřeno v předchozím článku. Tento postup načte aktuální inicializační data pomocí identity počítače Arc a nepoužívá soubor base-config.json z prostředí Bash.

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

Pokračujte, až se ve výstupu zobrazí Arc preflight: OK, dokončí se registrace počítače a bootstrap skript oznámí, že byla spuštěna služba agenta Flex Node. Pokud bootstrap nemůže načíst data, ověřte připojení ke službě Arc, himdsd, přiřazení role v oboru AKS a přístup hostitele ke službě Azure Resource Manager.

Odstraňte dočasné soubory vydání

Po úspěšném dokončení bootstrapu odeberte z hostitele přechodný skript, archiv a soubor pro předání:

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

První exit opustí kořenové prostředí. Druhý zavře relaci SSH a vrátí se do prostředí Bash.

Odstraňte duplicitní položky v prostředí Bash:

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"

Ponechejte /etc/aks-flex-node a přihlašovací údaj objektu služby, dokud hostitel zůstává připojený. Běžící agent používá tuto konfiguraci pro synchronizaci uzlu a počítače Azure.

Ověření uzlu Kubernetes

Nastavte název uzlu na název hostitele Linuxu zaznamenaný ve sdíleném prostředí. Nejprve počkejte, až se objekt Node vytvoří, a pak počkejte, až se připraví:

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

Pokračujte, když je uzel Ready. Pokud se uzel nevytvoří nebo nepřejde do stavu Ready, před opakováním bootstrapu ověřte výstup bootstrapu, konektivitu k API a službu agenta.

Ověřte prostředek Azure Machine

  1. Zobrazí seznam počítačů ve fondu cílových uzlů flex node.

    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. Vyhledejte počítač, který zaregistroval připravený uzel Kubernetes:

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

    Pokračujte, až příkaz vrátí přesně jeden název počítače.

  3. Zobrazit tento počítač:

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

    Pokračujte, když virtuální počítač existuje, odkazuje na FLEX_NODE_NAME a hlásí úspěšný stav zřizování. Zaznamenejte si název počítače pro operace v rámci životního cyklu:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Ověřte síťové připojení uzlu Flex

  1. Zobrazte web flex, CIDR podu a veřejný klíč WireGuard.

    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. Ověřte lokality a související síťové prostředky Unbounded-Net.

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

  3. Zobrazte pody Unbounded-Net naplánované na uzlu flex.

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

Nepokračujte v ověřování úloh, pokud:

  • Uzel je Ready.
  • Lokalita je lokalita Unbounded-Net Flex nakonfigurovaná v článku o sítích.
  • CIDR podu patří do plánovaného FLEX_POD_CIDR rozsahu.
  • Veřejný klíč WireGuard se naplní.
  • cluster-flex-private-l3 SitePeering odkazuje na lokality cluster a flex-site.
  • Každý vrácený pod Unbounded-Net na uzlu je Running.
  • Ve veřejné topologii WireGuardu existuje očekávané propojení fondu bran.

Ověřte agenta flex node

Počkejte až jednu minutu, než se služba aktivuje. Pokud ne, zobrazte stav služby a nedávné protokoly:

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'

Pokračovat, když výstup obsahuje ActiveState=active, SubState=runninga Result=success.

Pokud se agent opakovaně restartuje, protože nemůže vypsat prostředky MachineOperation, vraťte se k dočasnému kroku RBAC pro démon flex v Konfigurace sítě a vytvoření fondu uzlů flex v AKS, ověřte, že role a vazba role existují, a potom agenta restartujte:

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

Ověřte umístění úlohy a připojení

Vytvoření úlohy ověřování

Vytvořte vyhrazený obor názvů. Pokud tento obor názvů již existuje, před dalším pokusem vyčistěte předchozí běh ověřování.

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

Vytvořte server HTTP, který plánovač Kubernetes umístí na flexibilní uzel a zpřístupní ho prostřednictvím služby ClusterIP:

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

Ověření zpětného volání a připojení k místní službě

Zkontrolujte protokoly a spouštění příkazů pomocí cesty zpětného volání serveru rozhraní API Kubernetes:

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

Získejte ClusterIP a z workloadu uzlu flex odešlete požadavek na službu:

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"

Očekávaná odpověď je:

flex-network-ok

Ověření přesměrování portů

V aktuálním terminálu přesměrujte místní port přes server rozhraní API Kubernetes. Tento příkaz používá prostředí nasazení a kubeconfig, které jste načetli dříve:

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

Ve druhém terminálu odešlete požadavek na přesměrovaný koncový bod:

curl -fsS http://127.0.0.1:18080

Očekávaná odpověď je flex-network-ok. Po kontrole stiskněte ctrl+C v prvním terminálu.

Ověření připojení z uzlu spravovaného službou AKS

Vyhledání připraveného uzlu systému spravovaného službou AKS:

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

Spusťte na daném uzlu klientský pod a zkontrolujte očekávanou odpověď:

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

Uzel Kubernetes ve stavu Ready označuje registraci uzlu. Sama o sobě nedokazuje síťové propojení úloh, operace zpětného volání ani operace životního cyklu Azure.

Vyčistit zátěž ověřování

Odstraňte pouze dočasné prostředky, které jste vytvořili v tomto článku.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Další krok

Dále spravujte, aktualizujte, upgradujte nebo odeberte připojený uzel flex.

  • Poslední aktualizace v