Een flexknooppunt koppelen aan een AKS-cluster (preview)

Important

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals het is' en 'voor zover beschikbaar' en zijn uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning naar best vermogen. Zodoende zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

Nadat u het AKS-cluster, het netwerk, de flex-nodegroep, de host en de identiteit hebt voorbereid, initialiseert u de host en koppelt u deze aan de doelpool.

In dit artikel leert u het volgende:

  • Download en controleer de flexknooppuntrelease.
  • Initialiseer de host via de geselecteerde Azure-identiteit om actuele poolgegevens op te halen.
  • Controleer het Kubernetes-knooppunt, Azure Machine, netwerkstatus en agentservice.
  • De plaatsing van werkbelastingen, Kubernetes-callbacks en connectiviteit tussen knooppunten valideren.

Voer de beheeropdrachten in dit artikel uit in een linux-compatibele Bash-omgeving met de vereiste hulpprogramma's en netwerktoegang. In dit artikel wordt die omgeving uw Bash-omgeving genoemd. De afzonderlijke computer die aan het cluster wordt toegevoegd, is de flexknooppunthost; voer daar alleen opdrachten uit wanneer een stap u expliciet naartoe leidt.

Voer voor een privé-AKS-cluster elke kubectl opdracht uit vanuit een Bash-omgeving die de privé-API-server kan oplossen en bereiken. U kunt Azure CLI, artefactdownload-, SSH- en SCP-opdrachten uitvoeren vanuit uw Bash-omgeving wanneer deze beschikt over de vereiste Azure en hosttoegang. Het flexknooppunthostnetwerk moet ook het privé-API-eindpunt oplossen en bereiken.

Voordat u begint

  • Voltooi Netwerken configureren en maak een flexknooppuntgroep in AKS.
  • Voltooi De voorbereiding van een flexknooppunthost en -identiteit.
  • Installeer Azure CLI, de aks-preview extensie, een kubectl versie binnen één secundaire versie van AKS_VERSION, jq, curl, sha256sum, een OpenSSH-client en scp in uw Bash-omgeving.
  • Gebruik voor beheerde identiteit of service-principal een Azure-account waarmee bootstrapgegevens voor de geselecteerde flexknooppuntgroep kunnen worden opgehaald.
  • Zorg ervoor dat uw Bash-omgeving de flexknooppunthost kan bereiken via het goedgekeurde SSH-beheerpad.
  • Zorg ervoor dat de host van het flex-knooppunt via HTTPS de eindpunten voor release- en bootstrapartefacten kan bereiken die worden geretourneerd in de bootstrapgegevens van de pool, evenals Azure Resource Manager, Microsoft Entra ID en het geselecteerde AKS API-eindpunt.

Opmerking

Sla geen referenties, certificaten, persoonlijke sleutels, toegangstokens, bootstrapgegevens of kubeconfig-inhoud op in het bestand met de gedeelde omgeving.

De implementatieomgeving laden

Start een nieuwe Bash-sessie, identificeer het omgevingsbestand en laad het. Vervang <deployment-name> door het implementatielabel dat in de voorgaande artikelen wordt gebruikt.

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

Het omgevingsbestand levert de gedeelde implementatiewaarden die in dit artikel worden gelezen, inclusief WORK_DIRde map in uw Bash-omgeving waarin in dit artikel bestanden worden gedownload en gegenereerd. Standaard is WORK_DIR~/.local/share/aksflexnode/<deployment-name>. In het artikel worden eventuele andere variabelen afgeleid die nodig zijn. Als u het omgevingsbestand nog niet hebt gemaakt, voltooit u eerst de implementatie van uw flexknooppunten . Ga niet verder dan deze stap als de shell een fout meldt.

Stel het actieve abonnement in en geef de Azure, Kubernetes en hostdoelen weer:

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

Controleer of ResourceId overeenkomt met AKS_RESOURCE_ID, de hostnaam van het Kubernetes-control-plane overeenkomt met ApiServer en de SSH-opdracht FLEX_HOST_NAME retourneert. Als een doel niet overeenkomt, stopt en corrigeert u het omgevingsbestand, de kubeconfig of het SSH-doel voordat u bestanden overdraagt of uitvoert.

De flex node-release downloaden en verifiëren

  1. Identificeer de hostarchitectuur en selecteer het overeenkomende releasearchief.

    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. Download het archief- en controlesommanifest uit de geselecteerde release.

    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. Selecteer precies één controlesomvermelding voor het archief en controleer het bestand.

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

    Ga niet verder tenzij de checksumopdracht meldt dat het archief OK is.

  4. Download het bootstrap-script van dezelfde releasetag en valideer de Bash-syntaxis.

    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"

    De release publiceert momenteel geen afzonderlijke controlesom voor dit script. Download het zonder deze naar een shell te sluisen, zorg ervoor dat de versie overeenkomt met het geverifieerde agentarchief en stop als de syntaxiscontrole mislukt.

Huidige bootstrapgegevens van de pool ophalen

De beheerde identiteit en service-principalpaden maken gebruik van bootstrapgegevens die u ophaalt in uw Bash-omgeving. Als u Azure Arc beheerde identiteit hebt geselecteerd, kunt u deze sectie overslaan. Met de opdracht Arc bootstrap worden actuele gegevens opgehaald via de Arc-machine-identiteit.

Voor beheerde identiteit of service-principal haalt u de gegevens direct op voordat u bestanden overbrengt naar de host. Het antwoord bevat een bootstraptoken dat na één uur verloopt. Druk het antwoord niet af of sla het op in notities.

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"

Ga door als ${WORK_DIR}/base-config.json bestaat en niet leeg is. Voltooi de overdracht en initialiseer de host binnen één uur. Als het token verloopt, voert u de opdracht opnieuw uit en vervangt u het oude bestand.

Bestanden overdragen en de host voorbereiden

  1. Maak een niet-geheim overdrachtsbestand voor de host.

    {
    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. Kopieer de geverifieerde releasebestanden en het handoff-bestand naar de host.

    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. Kopieer voor een beheerde identiteit of service-principal ook de beveiligde bootstrapgegevens:

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

  4. Maak verbinding met de host en start een hoofdshell:

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

  5. Laad de niet-geheime overdrachtswaarden en valideer de overgedragen bestanden:

    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 -

    Ga door wanneer de checksumopdracht meldt dat het archief OK is. Stop als de controlesom of de controle van de scriptsyntaxis mislukt.

  6. Installeer de bootstrapgegevens voor een beheerde identiteit of een service-principal:

    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

De host initialiseren

Voltooi alleen de sectie die overeenkomt met de identiteit die is geconfigureerd in het vorige artikel.

Gebruik deze sectie pas nadat de Arc-machineresource overeenkomt met de SSH-host, himdsd actief is, retourneert de HIMDS-verificatie HTTP 200 voor de exacte AKS-resource en is de AKS-roltoewijzing aanwezig, zoals geverifieerd in het vorige artikel. Met dit pad worden nieuwe bootstrapgegevens opgehaald via de identiteit van de Arc-machine en wordt het base-config.json bestand niet uit uw Bash-omgeving gebruikt.

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

Ga door wanneer de uitvoerrapporten Arc preflight: OKzijn voltooid, machineregistratie is voltooid en het bootstrap-script meldt dat de flexknooppuntagentservice is gestart. Als bootstrap geen gegevens kan ophalen, controleert u de Arc-verbinding, himdsdde toewijzing van AKS-rollen en hosttoegang tot Azure Resource Manager.

Tijdelijke releasebestanden verwijderen

Nadat bootstrap is geslaagd, verwijdert u het tijdelijke script, archief en overdrachtsbestand van de host:

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

De eerste exit verlaat de root-shell. De tweede sluit de SSH-sessie en keert terug naar uw Bash-omgeving.

Verwijder de kopieën in uw Bash-omgeving:

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"

Behoud /etc/aks-flex-node en de referentie van de service-principal zolang de host gekoppeld blijft. De actieve agent gebruikt deze configuratie voor knooppunt- en Azure machineafstemming.

Het Kubernetes-knooppunt controleren

Stel de naam van het knooppunt in op de Linux-hostnaam die is vastgelegd in de gedeelde omgeving. Wacht eerst tot het knooppuntobject is gemaakt en wacht totdat het gereed is:

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

Ga door wanneer het knooppunt is Ready. Als het knooppunt niet is gemaakt of niet gereed is, controleert u de bootstrap-uitvoer, API-connectiviteit en agentservice voordat u bootstrap opnieuw probeert uit te voeren.

De Azure Machine-resource controleren

  1. Vermeld de machines in de doel flexknooppuntgroep.

    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. Zoek de machine die het voorbereide Kubernetes-knooppunt heeft geregistreerd:

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

    Ga door wanneer de opdracht precies één computernaam retourneert.

  3. Deze machine weergeven:

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

    Ga door wanneer de machine bestaat, naar FLEX_NODE_NAME verwijst en een geslaagde inrichtingsstatus heeft. Noteer de computernaam voor levenscyclusbewerkingen:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Flexknooppuntnetwerken controleren

  1. Geef de flexsite, pod CIDR en de openbare WireGuard-sleutel weer.

    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. Controleer de sites en gerelateerde Unbounded-Net netwerkresources.

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

  3. Geef de Unbounded-Net pods weer die zijn gepland voor het flexknooppunt.

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

Ga niet verder met de workloadvalidatie, tenzij:

  • Het knooppunt is Ready.
  • De Site is de Unbounded-Net flex-site die in het artikel over netwerken is geconfigureerd.
  • De pod CIDR behoort tot het geplande FLEX_POD_CIDR bereik.
  • De openbare WireGuard-sleutel is ingevuld.
  • De cluster-flex-private-l3 SitePeering verwijst naar de sites cluster en flex-site.
  • Elke teruggegeven Unbounded-Net pod op het knooppunt is Running.
  • Voor een openbare WireGuard-topologie is de verwachte peering tussen gatewaypools aanwezig.

De flexknooppuntagent controleren

Wacht maximaal één minuut totdat de service actief is. Als dit niet het probleem is, geeft u de servicestatus en recente logboeken weer:

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'

Ga door wanneer de uitvoer ActiveState=active, SubState=running en Result=success bevat.

Als de agent steeds opnieuw opstart omdat deze MachineOperation-resources niet kan weergeven, gaat u terug naar de tijdelijke RBAC-stap voor de flex-daemon in Netwerken configureren en een flex-knooppuntgroep maken in AKS, controleert u of de rol en binding bestaan en start u de agent vervolgens opnieuw op:

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

Plaatsing en connectiviteit van workloads valideren

Een validatieworkload maken

Maak een toegewezen naamruimte. Als deze naamruimte al bestaat, moet u de vorige validatieuitvoering opschonen voordat u het opnieuw probeert.

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

Maak een HTTP-server die de Kubernetes-scheduler op het flexknooppunt plaatst en maak deze beschikbaar via een ClusterIP-service:

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

Callbacks en verbinding met lokale services controleren

Controleer de logboeken en de uitvoering van opdrachten met behulp van het callbackpad van de Kubernetes-API-server:

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

Haal de ClusterIP op en benader de service vanuit de flex-node-workload:

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"

Het verwachte antwoord is:

flex-network-ok

Port Forwarding controleren

Stuur in de huidige terminal een lokale poort door via de Kubernetes-API-server. Deze opdracht maakt gebruik van de implementatieomgeving en kubeconfig die u eerder hebt geladen:

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

Vraag in een tweede terminal het doorgestuurde eindpunt aan:

curl -fsS http://127.0.0.1:18080

Het verwachte antwoord is flex-network-ok. Druk op Ctrl+C in de eerste terminal na de controle.

Connectiviteit controleren vanaf een door AKS beheerd knooppunt

Zoek een gereed AKS-beheerd systeemknooppunt:

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

Voer een clientpod uit op dat knooppunt en controleer op het verwachte antwoord:

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

Een Kubernetes-knooppunt met de Ready status Toont knooppuntregistratie. Het bewijst op zichzelf niet dat het gaat om netwerken voor workloads, callback-bewerkingen of Azure-levenscyclusbewerkingen.

De validatieworkload opschonen

Verwijder alleen de tijdelijke resources die u in dit artikel hebt gemaakt.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Volgende stap

Vervolgens kunt u het gekoppelde flexknooppunt beheren, bijwerken, upgraden of verwijderen.

  • Laatst bijgewerkt om