Anfügen eines Flexknotens an einen AKS-Cluster (Vorschau)

Important

AKS-Preview-Funktionen stehen auf Selbstbedienungs- und Opt-in-Basis zur Verfügung. Vorschauversionen werden „im Istzustand“ und „wie verfügbar“ bereitgestellt und sind von den Service Level Agreements und der eingeschränkten Garantie ausgeschlossen. AKS-Vorschauversionen werden teilweise vom Kundensupport auf Grundlage der bestmöglichen Leistung abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen. Weitere Informationen finden Sie in den folgenden Supportartikeln:

Nachdem Sie den Azure Kubernetes Service (AKS) Cluster, Netzwerk, Flex-Knotenpool, Host und Identität vorbereitet haben, bootstrapieren Sie den Host, und fügen Sie ihn an den Zielpool an.

In diesem Artikel erfahren Sie:

  • Laden Sie das Flex-Node-Release herunter und verifizieren Sie es.
  • Initialisieren Sie den Host mithilfe seiner ausgewählten Azure-Identität, um aktuelle Pooldaten abzurufen.
  • Überprüfen Sie den Kubernetes-Knoten, Azure Computer, Netzwerkstatus und Agentdienst.
  • Überprüfen Sie die Workload-Platzierung, Kubernetes-Callbacks und die Konnektivität zwischen Knoten.

Führen Sie die Verwaltungsbefehle in diesem Artikel in einer linuxkompatiblen Bash-Umgebung aus, die über die erforderlichen Tools und den Netzwerkzugriff verfügt. Dieser Artikel bezeichnet diese Umgebung als Ihre Bash-Umgebung. Der separate Rechner, der dem Cluster beitritt, ist der Flex-Node-Host; führen Sie dort nur dann Befehle aus, wenn Sie in einem Schritt ausdrücklich dazu angewiesen werden.

Führen Sie bei einem privaten AKS-Cluster jeden kubectl-Befehl in einer Bash-Umgebung aus, die den privaten API-Server auflösen und erreichen kann. Sie können Azure CLI- und Artefaktdownload-, SSH- und SCP-Befehle aus Ihrer Bash-Umgebung ausführen, wenn sie über den erforderlichen Azure und Hostzugriff verfügt. Das Flexknotenhostnetzwerk muss auch den privaten API-Endpunkt auflösen und erreichen.

Bevor Sie anfangen

  • Konfigurieren Sie das Netzwerk, und erstellen Sie einen Flex-Knotenpool in AKS.
  • Schließen Sie Einen Flexknotenhost und eine Identität vorbereiten ab.
  • Installieren Sie Azure CLI, die aks-preview Erweiterung, eine kubectl Version in einer Nebenversion von AKS_VERSION, jq, curl, sha256sumeinem OpenSSH-Client und scp in Ihrer Bash-Umgebung.
  • Verwenden Sie für verwaltete Identitäten oder Dienstprinzipal ein Azure Konto, das Bootstrapdaten für den ausgewählten Flexknotenpool abrufen kann.
  • Stellen Sie sicher, dass Ihre Bash-Umgebung den Flex-Knotenhost über den genehmigten SSH-Verwaltungspfad erreichen kann.
  • Stellen Sie sicher, dass der Flex-Knotenhost die in den Pool-Bootstrap-Daten zurückgegebenen Release- und Bootstrap-Artefaktendpunkte sowie Azure Resource Manager, Microsoft Entra ID und den ausgewählten AKS-API-Endpunkt über HTTPS erreichen kann.

Note

Speichern Sie keine Anmeldeinformationen, Zertifikate, privaten Schlüssel, Zugriffstoken, Bootstrapdaten oder Kubeconfig-Inhalte in der Freigegebenen Umgebungsdatei.

Bereitstellungsumgebung laden

Starten Sie eine neue Bash-Sitzung, identifizieren Sie die Umgebungsdatei, und laden Sie sie. Ersetzen Sie durch <deployment-name> die Bereitstellungsbezeichnung, die in den vorherigen Artikeln verwendet wird.

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

Die Umgebungsdatei stellt die gemeinsam verwendeten Bereitstellungswerte bereit, die dieser Artikel verwendet, einschließlich WORK_DIR, dem Verzeichnis in Ihrer Bash-Umgebung, in dem dieser Artikel Downloads und erzeugte Dateien speichert. WORK_DIR ist standardmäßig ~/.local/share/aksflexnode/<deployment-name>. Der Artikel leitet alle anderen Variablen ab, die er benötigt. Wenn Sie die Umgebungsdatei noch nicht erstellt haben, schließen Sie zuerst Planen Sie Ihre Flex-Knoten-Bereitstellung ab. Fahren Sie nach diesem Schritt nicht fort, wenn die Shell einen Fehler meldet.

Legen Sie das aktive Abonnement fest, und zeigen Sie die Azure, Kubernetes und Hostziele an:

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

Vergewissern Sie sich, dass ResourceId übereinstimmt AKS_RESOURCE_ID, der Kubernetes-Hostname der Steuerebene mit apiServer übereinstimmt, und der SSH-Befehl gibt zurück FLEX_HOST_NAME. Wenn ein Ziel nicht übereinstimmt, beenden und korrigieren Sie die Umgebungsdatei, kubeconfig oder SSH-Ziel, bevor Sie Dateien übertragen oder ausführen.

Herunterladen und Überprüfen der Flex-Knoten-Freigabe

  1. Identifizieren Sie die Hostarchitektur, und wählen Sie das entsprechende Releasearchiv aus.

    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. Laden Sie das Archiv- und Prüfsummenmanifest aus der ausgewählten Version herunter.

    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. Wählen Sie genau einen Prüfsummeneintrag für das Archiv aus, und überprüfen Sie die Datei.

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

    Fahren Sie nur fort, wenn der Prüfsummenbefehl meldet, dass das Archiv OK ist.

  4. Laden Sie das Bootstrap-Skript aus demselben Releasetag herunter, und überprüfen Sie die 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"

    Für dieses Skript wird im Release derzeit keine separate Prüfsumme bereitgestellt. Laden Sie es herunter, ohne es per Pipe an eine Shell zu übergeben, halten Sie es versionsgleich mit dem verifizierten Agentenarchiv, und brechen Sie ab, wenn die Syntaxprüfung fehlschlägt.

Aktuelle Pool-Bootstrapdaten abrufen

Die verwalteten Identitäts- und Dienstprinzipalpfade verwenden Bootstrap-Daten, die Sie in Ihrer Bash-Umgebung abrufen. Wenn Sie Azure Arc verwaltete Identität ausgewählt haben, überspringen Sie diesen Abschnitt. Der Arc-Bootstrap-Befehl ruft neue Daten über die Arc-Computeridentität ab.

Rufen Sie für eine verwaltete Identität oder einen Dienstprinzipal die Daten unmittelbar ab, bevor Sie Dateien an den Host übertragen. Die Antwort enthält ein Bootstrap-Token, das nach einer Stunde abläuft. Drucken Sie die Antwort nicht, oder speichern Sie sie nicht in Notizen.

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"

Fahren Sie fort, wenn ${WORK_DIR}/base-config.json vorhanden und nicht leer ist. Schließen Sie den Transfer- und Host-Bootstrap innerhalb einer Stunde ab. Wenn das Token abläuft, führen Sie den Befehl erneut aus, und ersetzen Sie die alte Datei.

Übertragen von Dateien und Vorbereiten des Hosts

  1. Erstellen Sie eine nicht geheime Host-Übergabedatei.

    {
    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. Kopieren Sie die überprüften Releasedateien und die Übergabedatei auf den 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. Kopieren Sie bei verwalteten Identitäten oder Dienstprinzipalen auch die geschützten Bootstrap-Daten:

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

  4. Stellen Sie eine Verbindung mit dem Host her, und starten Sie eine Stammshell:

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

  5. Laden Sie die nicht geheimen Übergabewerte und validieren Sie die übertragenen Dateien:

    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 -

    Fahren Sie fort, wenn der Befehl zur Prüfsummenberechnung meldet, dass das Archiv OK ist. Beenden Sie, wenn die Prüfsummen- oder Skriptsyntaxprüfung fehlschlägt.

  6. Installieren Sie die Bootstrapdaten für verwaltete Identitäten oder Dienstprinzipale:

    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

Host initialisieren

Füllen Sie nur den Abschnitt aus, der der im vorherigen Artikel konfigurierten Identität entspricht.

Verwenden Sie diesen Abschnitt nur, nachdem die Arc-Computerressource mit dem SSH-Host übereinstimmt, himdsd ist aktiv, die HIMDS-Überprüfung gibt HTTP 200 für die genaue AKS-Ressource zurück, und die AKS-bereichsbezogene Rollenzuweisung ist vorhanden, wie im vorherigen Artikel überprüft. Dieser Pfad ruft neue Bootstrapdaten über die Arc-Computeridentität ab und verwendet die base-config.json Datei nicht aus Ihrer Bash-Umgebung.

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

Fahren Sie fort, wenn die Ausgabe Arc preflight: OK meldet, die Maschinenregistrierung abgeschlossen ist und das Bootstrap-Skript meldet, dass der Dienst des Flex-Node-Agenten gestartet wurde. Wenn bootstrap keine Daten abrufen kann, überprüfen Sie die Arc-Verbindung, himdsd die AKS-bezogene Rollenzuweisung und den Hostzugriff auf Azure Resource Manager.

Temporäre Freigabedateien entfernen

Entfernen Sie nach dem erfolgreichen Bootstrap die vorübergehende Skript-, Archiv- und Übergabedatei vom Host:

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

Die erste exit verlässt die Root-Shell. Die zweite schließt die SSH-Sitzung und kehrt zu Ihrer Bash-Umgebung zurück.

Entfernen Sie die Kopien in Ihrer Bash-Umgebung:

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"

Behalten Sie /etc/aks-flex-node und die Anmeldeinformationen des Dienstprinzipals bei, solange der Host angefügt bleibt. Der laufende Agent verwendet diese Konfiguration für den Abgleich von Knoten und Azure-Maschinen.

Überprüfen des Kubernetes-Knotens

Setzen Sie den Knotennamen auf den Linux-Hostnamen, der in der gemeinsam genutzten Umgebung gespeichert ist. Warten Sie zunächst, bis das Node-Objekt erstellt wurde, und warten Sie dann, bis es bereit ist:

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

Fahren Sie fort, wenn der Knoten Ready ist. Wenn der Knoten nicht erstellt wird oder nicht bereit ist, überprüfen Sie die Bootstrap-Ausgabe, die API-Konnektivität und den Agentdienst, bevor Sie bootstrap wiederholen.

Überprüfen der Azure-Maschinenressource

  1. Listen Sie die Systeme im Ziel-Flex-Knotenpool auf.

    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. Suchen Sie den Computer, der den vorbereiteten Kubernetes-Knoten registriert hat:

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

    Fahren Sie fort, wenn der Befehl genau einen Computernamen zurückgibt.

  3. Diesen Computer anzeigen:

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

    Fahren Sie fort, wenn die Maschine existiert, auf FLEX_NODE_NAME verweist und einen erfolgreichen Bereitstellungszustand meldet. Notieren Sie sich den Maschinennamen für Lebenszyklusvorgänge:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Überprüfen Sie das Flex-Node-Netzwerk.

  1. Zeigen Sie den öffentlichen Schlüssel "Flex site", "pod CIDR" und "WireGuard" an.

    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. Überprüfen Sie die Websites und die zugehörigen Unbounded-Net Netzwerkressourcen.

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

  3. Zeigen Sie die Unbounded-Net-Pods an, die dem Flex-Knoten zugewiesen sind.

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

Fahren Sie nicht mit der Workloadüberprüfung fort, es sei denn:

  • Der Knoten ist Ready.
  • Die Site ist die Unbounded-Net Flex-Site, die im Netzwerkartikel konfiguriert wurde.
  • Der pod CIDR gehört zum geplanten FLEX_POD_CIDR Bereich.
  • Der öffentliche WireGuard-Schlüssel wird ausgefüllt.
  • Das cluster-flex-private-l3 SitePeering verweist auf die cluster und flex-site Sites.
  • Jeder zurückgegebene Unbounded-Net Pod auf dem Knoten ist Running.
  • Für eine öffentliche WireGuard-Topologie ist das vorgesehene Peering des Gateway-Pools vorhanden.

Überprüfen des Flex-Knoten-Agents

Warten Sie bis zu einer Minute, bis der Dienst aktiv wird. Falls das nicht funktioniert, zeigen Sie den Status des Dienstes und die aktuellen Protokolle an:

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'

Fahren Sie fort, wenn die Ausgabe enthält ActiveState=active, SubState=runningund Result=success.

Wenn der Agent wiederholt neu gestartet wird, da er keine Ressourcen auflisten MachineOperation kann, kehren Sie zum temporären Flex-Daemon-RBAC-Schritt in " Netzwerk konfigurieren" zurück, und erstellen Sie einen Flex-Knotenpool in AKS, überprüfen Sie, ob die Rolle und Bindung vorhanden ist, und starten Sie den Agent neu:

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

Platzierung von Workloads und Konnektivität überprüfen

Erstellen Sie eine Validierungsworkload

Erstellen Sie einen dedizierten Namespace. Wenn dieser Namespace bereits vorhanden ist, bereinigen Sie die vorherige Überprüfung, bevor Sie den Vorgang wiederholen.

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

Erstellen Sie einen HTTP-Server, den der Kubernetes-Scheduler auf dem Flexknoten platziert, und machen Sie ihn über einen ClusterIP-Dienst verfügbar:

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

Überprüfen von Rückrufen und lokaler Dienstkonnektivität

Überprüfen Sie Protokolle und Befehlsausführung mithilfe des Kubernetes-API-Serverrückrufpfads:

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

Rufen Sie die ClusterIP ab, und senden Sie vom Workload des Flex-Knotens eine Anfrage an den Dienst:

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"

Die erwartete Antwort lautet:

flex-network-ok

Überprüfen Sie die Portweiterleitung

Leiten Sie im aktuellen Terminal einen lokalen Port über den Kubernetes-API-Server weiter. Dieser Befehl verwendet die Bereitstellungsumgebung und kubeconfig, die Sie zuvor geladen haben:

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

Fordern Sie in einem zweiten Terminal den weitergeleiteten Endpunkt an:

curl -fsS http://127.0.0.1:18080

Die erwartete Antwort ist flex-network-ok. Drücken Sie strg+C im ersten Terminal nach der Überprüfung.

Konnektivität von einem AKS-verwalteten Knoten aus überprüfen

Suchen Sie einen verfügbaren, von AKS verwalteten Systemknoten:

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

Führen Sie auf diesem Knoten einen Client-Pod aus, und prüfen Sie, ob die erwartete Antwort zurückgegeben wird:

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

Ein Kubernetes-Knoten im Ready Status zeigt die Knotenregistrierung an. Dies allein belegt keine Workload-Netzwerke, Callback-Operationen oder Azure-Lebenszyklusvorgänge.

Validierungsarbeitslast bereinigen

Entfernen Sie nur die temporären Ressourcen, die Sie in diesem Artikel erstellt haben.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Nächster Schritt

Als Nächstes können Sie den angehängten Flexknoten verwalten, aktualisieren, aufrüsten oder entfernen.

  • Zuletzt aktualisiert um