Koppla en flexnod till ett AKS-kluster (förhandsversion)

Important

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och frivillig registrering. Förhandsversioner tillhandahålls "i befintligt skick" och "i mån av tillgång," och de är undantagna från servicenivåavtal och begränsad garanti. AKS-förhandsversioner stöds delvis av kundsupport efter bästa förmåga. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

När du har förberett Azure Kubernetes Service-klustret (AKS), nätverket, den flexibla nodpoolen, värden och identiteten bootstrappar du värden och ansluter den till målpoolen.

I den här artikeln kommer du att:

  • Ladda ned och verifiera flex node-utgåvan.
  • Initialisera värden med hjälp av sin valda Azure-identitet för att hämta uppdaterade pooldata.
  • Verifiera Kubernetes Node, Azure Machine, nätverkstillstånd och agenttjänsten.
  • Verifiera arbetsbelastningsplacering, Kubernetes-återanrop och anslutning mellan noder.

Kör hanteringskommandona i den här artikeln i en Linux-kompatibel Bash-miljö som har de verktyg och nätverksåtkomst som krävs. I den här artikeln kallas den miljön för din Bash-miljö. Den separata dator som ansluter till klustret är flexnodsvärden; kör kommandon där endast när ett steg uttryckligen instruerar dig att göra det.

För ett privat AKS-kluster kör du varje kubectl kommando från en Bash-miljö som kan matcha och nå den privata API-servern. Du kan köra kommandona Azure CLI, artefaktnedladdning, SSH och SCP från Bash-miljön när den har nödvändig Azure och värdåtkomst. Värdnätverket för flexnoden måste också kunna slå upp och nå den privata API-slutpunkten.

Innan du börjar

  • Slutför Konfigurera nätverk och skapa en flexnodpool i AKS.
  • Slutför Förbered en värd för en flexnod och identitet.
  • Installera Azure CLI, aks-preview tillägget, en kubectl version inom en delversion av AKS_VERSION, jq, curl, sha256sum, en OpenSSH-klient och scp i bash-miljön.
  • För hanterad identitet eller tjänsthuvudnamn använder du ett Azure-konto som kan hämta bootstrap-data för den valda Flex-nodpoolen.
  • Se till att din Bash-miljö kan nå värden för flexnoden via den godkända SSH-hanteringsvägen.
  • Kontrollera att flexnodvärden kan nå versions- och bootstrap-artefaktslutpunkterna som returneras i poolens bootstrap-data, Azure Resource Manager, Microsoft Entra ID och den valda AKS API-slutpunkten via HTTPS.

Note

Lagra inte autentiseringsuppgifter, certifikat, privata nycklar, åtkomsttoken, bootstrap-data eller kubeconfig-innehåll i den delade miljöfilen.

Läs in driftsättningsmiljön

Starta en ny Bash-session, identifiera miljöfilen och läs in den. Ersätt <deployment-name> med distributionsetiketten som används i föregående artiklar.

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

Miljöfilen innehåller de delade distributionsvärden som den här artikeln läser, inklusive WORK_DIRkatalogen i bash-miljön där den här artikeln lagrar nedladdningar och genererade filer. Som standard är WORK_DIR~/.local/share/aksflexnode/<deployment-name>. Artikeln härleder alla andra variabler som den behöver. Om du inte har skapat miljöfilen ännu slutför du Planera distributionen av flexnoder först. Fortsätt inte förbi det här steget om gränssnittet rapporterar ett fel.

Ange den aktiva prenumerationen och visa mål för Azure, Kubernetes och värd:

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

Bekräfta att ResourceId matchar AKS_RESOURCE_ID, Kubernetes kontrollplansvärdnamn matchar ApiServer och SSH-kommandot returnerar FLEX_HOST_NAME. Om något mål inte matchar stoppar och korrigerar du miljöfilen, kubeconfig- eller SSH-målet innan du överför eller kör filer.

Ladda ned och verifiera flex node-utgåvan

  1. Identifiera värdarkitekturen och välj det matchande versionsarkivet.

    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. Ladda ned arkivet och manifestet för kontrollsumman från den valda utgåvan.

    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. Välj exakt en checksummapost för arkivet och verifiera filen.

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

    Fortsätt inte om inte kontrollsummakommandot rapporterar att arkivet är OK.

  4. Ladda ned bootstrap-skriptet från samma versionstagg och verifiera dess Bash-syntax.

    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"

    Versionen publicerar för närvarande inte en separat kontrollsumma för det här skriptet. Ladda ner den utan att skicka den via en pipe till ett shell, se till att den matchar versionen i det verifierade agentarkivet och avbryt om syntaxkontrollen misslyckas.

Hämta aktuella bootstrap-data för poolen

Sökvägarna för hanterad identitet och tjänstens huvudnamn använder bootstrap-data som du hämtar i Bash-miljön. Om du har valt Azure Arc hanterad identitet hoppar du över det här avsnittet. Kommandot Arc bootstrap hämtar nya data via Arc-datoridentiteten.

För hanterad identitet eller tjänsthuvudnamn ska du hämta data precis innan du överför filer till värden. Svaret innehåller en bootstrap-token som upphör att gälla efter en timme. Skriv inte ut svaret eller lagra det i anteckningar.

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"

Fortsätt när ${WORK_DIR}/base-config.json finns och inte är tomt. Slutför överföringen och värdens bootstrap inom en timme. Om token upphör att gälla kör du kommandot igen och ersätter den gamla filen.

Överför filer och förbered värddatorn

  1. Skapa en icke-hemlig överlämningsfil för värddatorn.

    {
    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. Kopiera de verifierade releasefilerna och överlämningsfilen till värddatorn.

    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. För hanterad identitet eller tjänstens huvudnamn kopierar du även skyddade bootstrap-data:

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

  4. Anslut till värddatorn och starta ett rotskal:

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

  5. Läs in de icke-sekretiska överlämningsvärdena och verifiera de överförda filerna:

    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 -

    Fortsätt när kontrollsummakommandot rapporterar att arkivet är OK. Stoppa om kontrollsumman eller skriptsyntaxkontrollen misslyckas.

  6. Installera bootstrap-data för den hanterade identiteten eller tjänsthuvudnamnet:

    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

Bootstrap-värden

Slutför endast avsnittet som matchar den identitet som konfigurerades i föregående artikel.

Använd det här avsnittet först när Arc-datorresursen matchar SSH-värden, himdsd är aktiv, HIMDS-verifieringen returnerar HTTP 200 för den exakta AKS-resursen och den AKS-begränsade rolltilldelningen finns, som verifierades i föregående artikel. Den här vägen hämtar färska bootstrap-data via Arc-datorns identitet och använder inte filen base-config.json i Bash-miljön.

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

Fortsätt när utdata visar Arc preflight: OK, maskinregistreringen är slutförd och bootstrap-skriptet rapporterar att tjänsten Flex Node Agent har startat. Om bootstrap inte kan hämta data kontrollerar du rolltilldelningen Arc-anslutning, himdsdAKS-omfattning och värdåtkomst till Azure Resource Manager.

Ta bort temporära utgivningsfiler

När bootstrap har lyckats tar du bort den tillfälliga skript-, arkiv- och överlämningsfilen från värden:

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

Den första exit lämnar rotgränssnittet. Den andra stänger SSH-sessionen och återgår till bash-miljön.

Ta bort kopiorna i Bash-miljö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"

Behåll /etc/aks-flex-node och autentiseringsuppgifterna för tjänsthuvudnamnet medan värden är ansluten. Agenten som körs använder den här konfigurationen för nod- och Azure Machine-avstämning.

Kontrollera Kubernetes-noden

Ange nodnamnet till det Linux-värdnamn som registrerats i den delade miljön. Först väntar du tills node-objektet har skapats och väntar sedan på att det ska bli klart:

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

Fortsätt när noden är Ready. Om noden inte har skapats eller inte blir redo kontrollerar du bootstrap-utdata, API-anslutning och agenttjänst innan du försöker starta om bootstrap.

Verifiera Azure Machine-resursen

  1. Visa en lista över datorerna i målnodpoolen för flex.

    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. Hitta den dator som registrerade den förberedda Kubernetes-noden:

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

    Fortsätt när kommandot returnerar exakt ett datornamn.

  3. Visa datorn:

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

    Fortsätt när maskinen finns, har referensen FLEX_NODE_NAME och rapporterar att provisioneringstillståndet har lyckats. Anteckna datorns namn för åtgärder under livscykeln:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Verifiera flexnodnätverk

  1. Visa flexplatsen, pod-CIDR och den offentliga WireGuard-nyckeln.

    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. Kontrollera platserna och relaterade Unbounded-Net nätverksresurser.

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

  3. Visa Unbounded-Net poddar som schemalagts till flexnoden.

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

Fortsätt inte att validera arbetsbelastningen om inte:

  • Noden är Ready.
  • Webbplatsen är den Unbounded-Net flexwebbplats som konfigurerats i nätverksartikeln.
  • Pod-CIDR:t tillhör det planerade FLEX_POD_CIDR-intervallet.
  • Den offentliga WireGuard-nyckeln är ifylld.
  • cluster-flex-private-l3 SitePeering hänvisar till cluster och flex-site platserna.
  • Varje returnerad Unbounded-Net podd på noden är Running.
  • För en offentlig WireGuard-topologi finns den förväntade gatewaypoolens peering.

Kontrollera Flex Node-agenten

Vänta upp till en minut innan tjänsten blir aktiv. Om den inte gör det visar du tjänsttillståndet och de senaste loggarna:

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'

Fortsätt när utdata innehåller ActiveState=active, SubState=runningoch Result=success.

Om agenten startar om upprepade gånger eftersom den inte kan visa MachineOperation resurser går du tillbaka till det tillfälliga RBAC-steget flex daemon i Konfigurera nätverk och skapar en flexnodpool i AKS, kontrollerar att rollen och bindningen finns och startar sedan om agenten:

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

Verifiera arbetsbelastningsplacering och anslutning

Skapa en valideringsarbetsbelastning

Skapa ett dedikerat namnområde. Om det här namnområdet redan finns rensar du den tidigare valideringskörningen innan du försöker igen.

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

Skapa en HTTP-server som Kubernetes-schemaläggaren placerar på flexnoden och exponera den via en ClusterIP-tjänst:

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

Verifiera återanrop och lokal tjänstanslutning

Kontrollera loggar och kommandoexekvering med hjälp av återanropssökvägen för Kubernetes API-servern:

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

Hämta ClusterIP-adressen och anropa tjänsten från arbetslasten på flexnoden:

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"

Det förväntade svaret är:

flex-network-ok

Kontrollera portvidarebefordran

I den här terminalen vidarebefordra en lokal port via Kubernetes API-servern. Det här kommandot använder distributionsmiljön och kubeconfig som du läste in tidigare:

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

I en andra terminal begär du den vidarebefordrade slutpunkten:

curl -fsS http://127.0.0.1:18080

Det förväntade svaret är flex-network-ok. Tryck på Ctrl+C i den första terminalen efter kontrollen.

Verifiera anslutningen från en AKS-hanterad nod

Hitta en färdig AKS-hanterad systemnod:

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

Kör en klientpodd på noden och sök efter det förväntade svaret:

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

En Kubernetes-nod i Ready tillståndet visar nodregistrering. Det utgör i sig inget bevis för nätverk för arbetsbelastningar, återanropsoperationer eller Azure-livscykelåtgärder.

Rensa valideringsarbetsbelastningen

Ta bara bort de tillfälliga resurser som du skapade i den här artikeln.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Nästa steg

Därefter hanterar, uppdaterar, uppgraderar eller tar du bort den anslutna flexnoden.

  • Uppdaterades senast