Rugalmas csomópont csatolása AKS-fürthöz (előzetes verzió)

Important

Az AKS előzetes verziójú funkciói önkiszolgáló, opt-in alapon érhetők el. Az előzetes verziókat "ahogy van" és "rendelkezésre állóként" biztosítjuk, és a szolgáltatási szerződésekből és a korlátozott jótállásból kizárjuk őket. Az AKS előzetes verzióihoz részleges támogatást nyújt az ügyfélszolgálat a tőle telhető legjobb módon. Ezért ezek a funkciók nem éles használatra vannak szánva. További információkért tekintse meg az alábbi támogatási cikkeket:

Miután előkészítette az Azure Kubernetes Service (AKS) fürtöt, a hálózatot, a rugalmas csomópontkészletet, a gazdagépet és az identitást, végezze el a gazdagép kezdeti beállítását, majd csatlakoztassa azt a célkészlethez.

Ebben a cikkben a következőt találja:

  • Töltse le és ellenőrizze a flex node kiadását.
  • Inicializálja a gazdagépet a kiválasztott Azure-identitásának használatával a friss készletadatok lekéréséhez.
  • Ellenőrizze a Kubernetes-csomópontot, a Azure gépet, a hálózat állapotát és az ügynökszolgáltatást.
  • Ellenőrizze a számítási feladatok elhelyezését, a Kubernetes-visszahívásokat és a csomópontok közötti kapcsolatot.

Futtassa a jelen cikkben szereplő felügyeleti parancsokat egy Linux-kompatibilis Bash-környezetben, amely rendelkezik a szükséges eszközökkel és hálózati hozzáféréssel. Ez a cikk ezt a környezetet Bash-környezetnek nevezi. A klaszterhez csatlakozó különálló gép a flex node host; ott csak akkor futtasson parancsokat, ha egy adott lépés kifejezetten erre utasítja.

Privát AKS-fürt esetén minden kubectl parancsot olyan Bash-környezetből futtasson, amely képes feloldani és elérni a privát API-kiszolgálót. A Bash-környezetből Azure CLI-, összetevők letöltésére szolgáló, SSH- és SCP-parancsokat futtathat, ha rendelkezésre áll a szükséges Azure- és gazdagép-hozzáférés. A rugalmas csomópont gazdagéphálózatának a privát API-végpontot is fel kell oldania és el kell érnie.

Mielőtt hozzákezdene

  • Fejezze be a hálózatkezelés konfigurálását, és hozzon létre egy rugalmas csomópontkészletet az AKS-ben.
  • Fejezze be a rugalmas csomópont gazdagépének és identitásának előkészítését.
  • Telepítse az Azure CLI-t, a aks-preview bővítményt, a kubectl egy olyan verzióját, amely legfeljebb egy alverzióval tér el a jq, sha256sum, AKS_VERSION, curl verziójától, valamint egy OpenSSH-ügyfelet és a scp eszközt a Bash-környezetben.
  • Felügyelt identitás vagy szolgáltatásnév esetén használjon egy Azure fiókot, amely le tudja kérni a kiválasztott rugalmas csomópontkészlet rendszerindítási adatait.
  • Győződjön meg arról, hogy a Bash-környezet képes elérni a flexcsomópont-gazdagépet a jóváhagyott SSH-kezelési útvonalon keresztül.
  • Győződjön meg arról, hogy a flexcsomópont gazdagépe HTTPS-en keresztül el tudja érni a készlet bootstrap-adataiban visszaadott kiadási és bootstrap-artefaktumvégpontokat, valamint az Azure Resource Managert, a Microsoft Entra ID-t és a kiválasztott AKS API-végpontot.

Megjegyzés:

A megosztott környezeti fájlban ne tároljon hitelesítő adatokat, tanúsítványokat, titkos kulcsokat, hozzáférési jogkivonatokat, rendszerindítási adatokat vagy kubeconfig-tartalmat.

Az üzembehelyezési környezet betöltése

Indítsa el az új Bash-munkamenetet, azonosítsa a környezeti fájlt, és töltse be. Cserélje le a(z) <deployment-name>-t az előző cikkekben használt telepítési címkével.

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

A környezeti fájl tartalmazza a cikk által beolvasott megosztott üzembehelyezési értékeket, beleértve WORK_DIRa Bash-környezet címtárát is, ahol ez a cikk letölti és létrehozza a fájlokat. Alapértelmezés szerint WORK_DIR az ~/.local/share/aksflexnode/<deployment-name>. A cikk a szükséges egyéb változókat is levezeti. Ha még nem hozta létre a környezeti fájlt, először végezze el a rugalmas csomópontok üzembe helyezésének megtervezését . Ne lépjen tovább ennél a lépésnél, ha a parancsértelmező hibát jelez.

Állítsa be az aktív előfizetést, és jelenítse meg a Azure, a Kubernetes és a gazdagép céljait:

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

Ellenőrizze, hogy a ResourceId megegyezik-e a(z) AKS_RESOURCE_ID értékével, a Kubernetes vezérlősík gazdagépneve megegyezik-e a(z) ApiServer értékével, és az SSH-parancs a(z) FLEX_HOST_NAME értéket adja-e vissza. Ha valamelyik cél nem egyezik, állítsa le és javítsa ki a környezeti fájlt, a kubeconfigot vagy az SSH-célt a fájlok átvitele vagy futtatása előtt.

A flex node kiadásának letöltése és ellenőrzése

  1. Azonosítsa a gazdagéparchitektúrát, és válassza ki a megfelelő kiadási archívumot.

    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. Töltse le az archív és ellenőrzőösszeg-jegyzékfájlt a kiválasztott kiadásból.

    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. Jelöljön ki pontosan egy ellenőrzőösszeg-bejegyzést az archívumhoz, és ellenőrizze a fájlt.

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

    Ne folytassa, hacsak az ellenőrzőösszeg-parancs nem azt jelzi, hogy az archívum OK.

  4. Töltse le a bootstrap szkriptet ugyanabból a kiadási címkéből, és ellenőrizze annak Bash-szintaxisát.

    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"

    A kiadás jelenleg nem tesz közzé külön ellenőrzőösszeget ehhez a szkripthez. Töltse le anélkül, hogy a rendszerhéjba pipázta volna, a verzió megfeleltethető az ellenőrzött ügynök archívumának, és állítsa le, ha a szintaxis ellenőrzése sikertelen.

Az aktuális pool bootstrap-adatainak lekérése

A felügyelt identitás- és szolgáltatásnév-elérési utak a Bash-környezetben lekért bootstrap-adatokat használják. Ha Azure Arc felügyelt identitást jelölte ki, hagyja ki ezt a szakaszt. Az Arc bootstrap parancs friss adatokat kér le az Arc-gép identitásán keresztül.

Felügyelt identitás vagy szolgáltatásnév esetén azonnal kérje le az adatokat, mielőtt fájlokat továbbít a gazdagépre. A válasz egy bootstrap tokent tartalmaz, amely egy óra múlva lejár. Ne nyomtassa ki a választ, és ne tárolja jegyzetekben.

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"

Folytassa, ha ${WORK_DIR}/base-config.json létezik, és nem üres. Fejezze be az átvitelt és a gazdagép indítását egy órán belül. Ha a jogkivonat lejár, futtassa újra a parancsot, és cserélje le a régi fájlt.

Fájlok átvitele és a gazdagép előkészítése

  1. Hozzon létre egy nem titkos gazdagép-átadófájlt.

    {
    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. Másolja az ellenőrzött kiadási fájlokat és az átadási fájlt a gazdagépre.

    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. Felügyelt identitás vagy szolgáltatásnév esetén másolja a védett rendszerindítási adatokat is:

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

  4. Kapcsolódjon a gazdagéphez, és indítsa el a root parancsértelmezőt:

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

  5. Töltse be a nem biztonságos átadási értékeket, és ellenőrizze az átvitt fájlokat:

    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 -

    Folytassa, ha az ellenőrzőösszeg-parancs azt jelzi, hogy az archívum OK. Állítsa le, ha az ellenőrzőösszeg vagy a szkript szintaxisának ellenőrzése sikertelen.

  6. Felügyelt identitás vagy szolgáltatásnév esetén telepítse a bootstrap adatokat:

    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

A gazdagép inicializálása

Csak az előző cikkben konfigurált identitásnak megfelelő szakaszt töltse ki.

Ezt a szakaszt csak akkor használja, ha az Arc-gép erőforrása megfelel az SSH-gazdagépnek, himdsd aktív, a HIMDS-ellenőrzés http 200-as értéket ad vissza a pontos AKS-erőforráshoz, és az AKS-hatókörű szerepkör-hozzárendelés jelen van az előző cikkben igazolt módon. Ez az elérési út friss bootstrap-adatokat kér le az Arc-gép identitásán keresztül, és nem használja a fájlt a base-config.json Bash-környezetből.

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

Folytassa, amikor a kimenetben megjelenik a(z) Arc preflight: OK, a gép regisztrációja befejeződik, és a bootstrapszkript azt jelzi, hogy a Flex Node Agent szolgáltatás elindult. Ha a bootstrap nem tud adatokat lekérni, ellenőrizze az Arc-kapcsolatot, himdsd az AKS-hatókörű szerepkör-hozzárendelést és a gazdagép Azure Resource Managerhez való hozzáférését.

Ideiglenes kiadási fájlok eltávolítása

A rendszerindítás sikeres végrehajtása után távolítsa el az átmeneti szkriptet, az archívumot és az átadási fájlt a gazdagépről:

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

Az első exit elhagyja a gyökérhéjat. A második bezárja az SSH-munkamenetet, és visszatér a Bash-környezetbe.

Távolítsa el a másolatokat a Bash-környezetben:

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"

Őrizze meg a(z) /etc/aks-flex-node és a szolgáltatásnévhez tartozó rendszerbiztonsági tag hitelesítő adatait, amíg a gazdagép csatlakoztatva marad. A futó ügynök ezt a konfigurációt használja csomópont- és Azure gép egyeztetéséhez.

A Kubernetes-csomópont ellenőrzése

Állítsa a csomópont nevét a megosztott környezetben rögzített Linux-gazdagépnévre. Először várja meg, amíg a Csomópont objektum létrejön, majd várja meg, amíg készen áll:

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

Folytassa, amikor a csomópont Ready. Ha a csomópont nincs létrehozva, vagy nem áll készen, ellenőrizze a rendszerindító kimenetét, az API-kapcsolatot és az ügynökszolgáltatást, mielőtt újrapróbálkozná a rendszerindítót.

A Azure gép erőforrásának ellenőrzése

  1. Sorolja fel a cél flex csomópontkészletében lévő gépeket.

    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. Keresse meg az előkészített Kubernetes-csomópontot regisztráló gépet:

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

    Folytassa, ha a parancs pontosan egy gépnevet ad vissza.

  3. Mutassa azt a gépet:

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

    Folytassa, ha a gép létezik, a(z) FLEX_NODE_NAME elemre hivatkozik, és sikeres üzembe helyezési állapotot jelez. Jegyezze fel a gép nevét az életciklus-műveletekhez:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Flex-csomópont hálózati kapcsolatának ellenőrzése

  1. Jelenítse meg a Flex-helyet, a pod CIDR-t és a WireGuard nyilvános kulcsát.

    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. Ellenőrizze a webhelyek és a kapcsolódó Unbounded-Net hálózati erőforrásokat.

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

  3. A rugalmas csomópontra ütemezett Unbounded-Net podok megjelenítése.

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

Ne folytassa a munkaterhelés ellenőrzését, kivéve, ha:

  • A csomópont az Ready.
  • A webhely az Unbounded-Net Flex-webhely, amely a hálózatkezelési cikkben van konfigurálva.
  • A pod CIDR a tervezett FLEX_POD_CIDR tartományhoz tartozik.
  • A WireGuard nyilvános kulcsa meg van adva.
  • A cluster-flex-private-l3 SitePeering a cluster és flex-site Sites elemre hivatkozik.
  • A csomóponton minden visszaadott Unbounded-Net pod Running.
  • Nyilvános WireGuard-topológia esetén a várt átjárókészlet-társviszony létezik.

A flex csomópontügynök ellenőrzése

Várjon akár egy percet, amíg a szolgáltatás aktívvá válik. Ha nem, jelenítse meg a szolgáltatás állapotát és a legutóbbi naplókat:

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'

Folytassa, ha a kimenet tartalmaz ActiveState=active, SubState=runningés Result=success.

Ha az ügynök ismétlődően újraindul, mert nem tudja listázni MachineOperation az erőforrásokat, térjen vissza az ideiglenes flex démon RBAC-lépéshez a Hálózat konfigurálása területen, és hozzon létre egy rugalmas csomópontkészletet az AKS-ben, ellenőrizze, hogy létezik-e a szerepkör és a kötés, majd indítsa újra az ügynököt:

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

A munkaterhelés elhelyezésének és kapcsolódásának ellenőrzése

Érvényesítési számítási feladat létrehozása

Hozzon létre egy dedikált névteret. Ha ez a névtér már létezik, az újrapróbálkozás előtt törölje az előző érvényesítési futtatásokat.

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

Hozzon létre egy HTTP-kiszolgálót, amelyet a Kubernetes ütemező a rugalmas csomóponton helyez el, és tegye elérhetővé egy ClusterIP szolgáltatáson keresztül:

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

Visszahívások és helyi szolgáltatáskapcsolat ellenőrzése

Ellenőrizze a naplókat és a parancsok végrehajtását a Kubernetes API-kiszolgáló visszahívási útvonalával:

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

Kérje le a ClusterIP-t, és érje el a szolgáltatást a flex node-beli munkaterhelésből:

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"

A várt válasz a következő:

flex-network-ok

Porttovábbítás ellenőrzése

Az aktuális terminálon továbbítson egy helyi portot a Kubernetes API-kiszolgálón keresztül. Ez a parancs a korábban betöltött üzembehelyezési környezetet és kubeconfigot használja:

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

Egy második terminálban kérje le a továbbított végpontot:

curl -fsS http://127.0.0.1:18080

A várható válasz: flex-network-ok. Az ellenőrzés után nyomja le a CtrlCbillentyűkombinációt+ az első terminálban.

Kapcsolat ellenőrzése AKS által felügyelt csomópontról

Keressen egy kész AKS által felügyelt rendszercsomópontot:

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

Futtasson egy ügyfél podot a csomóponton, és ellenőrizze a várt választ:

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

A(z) Ready állapotú Kubernetes-csomópont a csomópont regisztrációját jelzi. Önmagában nem bizonyítja a számítási feladatok hálózatkezelését, a visszahívási műveleteket vagy Azure életciklus-műveleteket.

Tisztítsa meg az ellenőrzési munkaterhelést

Távolítsa el csak a cikkben létrehozott ideiglenes erőforrásokat.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Következő lépés

Ezután kezelheti, frissítheti, bővítheti vagy eltávolíthatja a csatlakoztatott flex csomópontot.

  • Utolsó frissítés időpontja: