Melampirkan simpul fleksibel ke kluster AKS (pratinjau)

Important

Fitur pratinjau AKS tersedia atas dasar layanan mandiri dan pendaftaran sukarela. Pratinjau disediakan "apa adanya" dan "sebagaimana tersedia," dan pratinjau tersebut dikecualikan dari perjanjian tingkat layanan (SLA) serta garansi terbatas. Fitur pratinjau AKS sebagian didukung oleh dukungan pelanggan sebatas upaya terbaik. Dengan demikian, fitur-fitur ini tidak dimaksudkan untuk penggunaan produksi. Untuk informasi lebih lanjut, lihat artikel dukungan berikut ini:

Setelah Anda menyiapkan kluster Azure Kubernetes Service (AKS), jaringan, kumpulan simpul fleksibel, host, dan identitas, inisialisasi host lalu lampirkan ke pool target.

Dalam artikel ini, Anda:

  • Unduh dan verifikasi rilis node flex.
  • Bootstrap host dengan menggunakan identitas Azure yang dipilih untuk mengambil data kumpulan baru.
  • Verifikasi Kubernetes Node, Azure Machine, status jaringan, dan layanan agen.
  • Validasi penempatan beban kerja, panggilan balik Kubernetes, dan konektivitas lintas node.

Jalankan perintah manajemen dalam artikel ini di lingkungan Bash yang kompatibel dengan Linux yang memiliki alat dan akses jaringan yang diperlukan. Artikel ini menyebut lingkungan Bash Anda. Mesin terpisah yang bergabung dengan kluster adalah host node flex; jalankan perintah di sana hanya jika suatu langkah secara eksplisit mengarahkan Anda untuk melakukannya.

Untuk kluster AKS privat, jalankan setiap kubectl perintah dari lingkungan Bash yang dapat menyelesaikan dan menjangkau server API privat. Anda dapat menjalankan perintah Azure CLI, pengunduhan artefak, SSH, dan SCP dari lingkungan Bash Anda saat memiliki akses Azure dan host yang diperlukan. Jaringan host flex node juga harus dapat melakukan resolusi dan menjangkau endpoint API privat.

Sebelum Anda mulai

  • Selesaikan Konfigurasi jaringan dan buat kumpulan simpul fleksibel di AKS.
  • Selesaikan Menyiapkan host dan identitas simpul fleksibel.
  • Instal Azure CLI, ekstensi aks-preview, versi kubectl yang selisih satu versi minor dari AKS_VERSION, curl, jq, sha256sum, klien OpenSSH, dan scp di lingkungan Bash Anda.
  • Untuk identitas terkelola atau prinsipal layanan, gunakan akun Azure yang dapat mengambil data bootstrap untuk pool node fleksibel yang dipilih.
  • Pastikan lingkungan Bash Anda dapat mencapai host simpul fleksibel melalui jalur manajemen SSH yang disetujui.
  • Pastikan bahwa host node flex dapat mencapai titik akhir artefak rilis dan bootstrap yang dikembalikan dalam data bootstrap kumpulan, Azure Resource Manager, Microsoft Entra ID, dan titik akhir API AKS yang dipilih melalui HTTPS.

Note

Jangan menyimpan kredensial, sertifikat, kunci privat, token akses, data bootstrap, atau konten kubeconfig dalam file lingkungan bersama.

Memuat lingkungan penyebaran

Mulai sesi Bash baru, identifikasi file lingkungan, dan muat. Ganti <deployment-name> dengan label penyebaran yang digunakan dalam artikel sebelumnya.

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

File lingkungan menyediakan nilai penyebaran bersama yang dibaca artikel ini, termasuk WORK_DIR, direktori di lingkungan Bash Anda tempat artikel ini menyimpan unduhan dan file yang dihasilkan. Secara default, WORK_DIR adalah ~/.local/share/aksflexnode/<deployment-name>. Artikel ini memperoleh variabel lain yang dibutuhkannya. Jika Anda belum membuat file lingkungan, selesaikan Rencanakan penyebaran simpul fleksibel Anda terlebih dahulu. Jangan lanjutkan ke langkah berikutnya jika shell melaporkan kesalahan.

Atur langganan aktif dan tampilkan target Azure, Kubernetes, dan host:

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

Konfirmasikan bahwa ResourceId cocok AKS_RESOURCE_ID, nama host sarana kontrol Kube cocok dengan ApiServer, dan perintah SSH mengembalikan FLEX_HOST_NAME. Jika ada target yang tidak cocok, hentikan dan koreksi file lingkungan, kubeconfig, atau target SSH sebelum Anda mentransfer atau menjalankan file.

Unduh dan verifikasi rilis flex node

  1. Identifikasi arsitektur host dan pilih arsip rilis yang cocok.

    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. Unduh arsip dan manifes checksum dari rilis yang dipilih.

    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. Pilih tepat satu entri checksum untuk arsip tersebut dan verifikasi berkasnya.

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

    Jangan lanjutkan kecuali perintah checksum melaporkan bahwa arsip adalah OK.

  4. Unduh skrip bootstrap dari tag rilis yang sama dan validasi sintaks Bash-nya.

    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"

    Rilis ini saat ini tidak menyediakan checksum terpisah untuk skrip ini. Unduh tanpa menyalurkannya ke shell, pastikan versinya sesuai dengan arsip agen yang terverifikasi, dan hentikan jika pemeriksaan sintaks gagal.

Ambil data bootstrap kumpulan saat ini

Metode managed identity dan service principal menggunakan data bootstrap yang Anda ambil dari lingkungan Bash. Jika Anda memilih identitas terkelola Azure Arc, lewati bagian ini. Perintah bootstrap Arc mengambil data baru melalui identitas komputer Arc.

Untuk identitas terkelola atau prinsipal layanan, ambil data tersebut segera sebelum Anda mentransfer file ke host. Respons berisi token bootstrap yang kedaluwarsa setelah satu jam. Jangan mencetak respons atau menyimpannya dalam catatan.

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"

Lanjutkan jika ${WORK_DIR}/base-config.json ada dan tidak kosong. Selesaikan transfer dan bootstrap host dalam waktu satu jam. Jika token kedaluwarsa, jalankan perintah lagi dan ganti file lama.

Mentransfer file dan menyiapkan host

  1. Buat file handoff host nonrahasia.

    {
    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. Salin file rilis terverifikasi dan file handoff ke 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. Untuk identitas terkelola atau prinsipal layanan, salin juga data bootstrap yang dilindungi:

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

  4. Hubungkan ke host dan jalankan shell root:

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

  5. Muat nilai serah terima nonrahasia dan validasikan berkas yang ditransfer:

    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 -

    Lanjutkan ketika perintah checksum melaporkan bahwa arsip adalah OK. Hentikan jika pemeriksaan checksum atau sintaks skrip gagal.

  6. Untuk identitas terkelola atau prinsipal layanan, gunakan data bootstrap berikut:

    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

Inisialisasi host

Selesaikan hanya bagian yang cocok dengan identitas yang dikonfigurasi di artikel sebelumnya.

Gunakan bagian ini hanya setelah sumber daya mesin Arc sesuai dengan host SSH, himdsd aktif, verifikasi HIMDS mengembalikan HTTP 200 untuk sumber daya AKS yang sama persis, dan penetapan peran dalam cakupan AKS sudah ada, sebagaimana diverifikasi pada artikel sebelumnya. Metode ini mengambil data bootstrap terbaru melalui identitas mesin Arc dan tidak menggunakan file base-config.json dari lingkungan Bash Anda.

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

Lanjutkan ketika output melaporkan Arc preflight: OK, registrasi mesin selesai, dan skrip bootstrap melaporkan bahwa layanan agen node flex telah dimulai. Jika bootstrap tidak dapat mengambil data, periksa koneksi Arc, himdsd penetapan peran yang dicakup AKS, dan akses host ke Azure Resource Manager.

Menghapus file rilis sementara

Setelah bootstrap berhasil, hapus skrip sementara, arsip, dan file handoff dari host:

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

Yang pertama exit keluar dari root shell. Yang kedua menutup sesi SSH dan kembali ke lingkungan Bash Anda.

Hapus salinan di lingkungan Bash Anda:

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"

Simpan /etc/aks-flex-node dan kredensial perwakilan layanan selama host tetap terhubung. Agen yang berjalan menggunakan konfigurasi ini untuk rekonsiliasi node dan Azure Machine.

Memverifikasi simpul Kubernetes

Atur nama simpul ke nama host Linux yang direkam di lingkungan bersama. Pertama, tunggu hingga objek Node dibuat, lalu tunggu hingga objek siap:

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

Lanjutkan ketika node adalah Ready. Jika node tidak dibuat atau tidak berstatus siap, periksa output bootstrap, konektivitas API, dan layanan agen sebelum menjalankan bootstrap kembali.

Memverifikasi sumber daya Azure Machine

  1. Cantumkan Mesin di kumpulan simpul fleksibel target.

    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. Temukan Komputer yang mendaftarkan simpul Kubernetes yang disiapkan:

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

    Lanjutkan saat perintah mengembalikan tepat satu nama Komputer.

  3. Perlihatkan Mesin tersebut:

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

    Lanjutkan ketika mesin ada, mereferensikan FLEX_NODE_NAME, dan melaporkan status provisi berhasil. Rekam Nama mesin untuk operasi siklus hidup:

    set_flexnode_env FLEX_MACHINE_NAME "${FLEX_MACHINE_NAME}"

Memverifikasi jaringan simpul fleksibel

  1. Tampilkan flex site, pod CIDR, dan kunci publik 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. Verifikasi Situs dan sumber daya jaringan Unbounded-Net terkait.

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

  3. Tampilkan pod Unbounded-Net yang dijadwalkan pada node flex.

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

Jangan lanjutkan ke validasi beban kerja kecuali:

  • Node adalah Ready.
  • Situs tersebut adalah situs flex Unbounded-Net yang dikonfigurasi dalam artikel jaringan.
  • CIDR pod termasuk dalam rentang yang direncanakan FLEX_POD_CIDR .
  • Kunci publik WireGuard telah diisi.
  • cluster-flex-private-l3 SitePeering mereferensikan situs cluster dan flex-site.
  • Setiap pod Unbounded-Net pada node yang dikembalikan adalah Running.
  • Untuk topologi WireGuard publik, ada peering kumpulan gateway yang diharapkan.

Memverifikasi agen simpul flex

Tunggu hingga satu menit agar layanan aktif. Jika tidak, tampilkan status layanan dan log terbaru:

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'

Lanjutkan ketika output berisi ActiveState=active, SubState=running, dan Result=success.

Jika agen berulang kali dimulai ulang karena tidak dapat mencantumkan MachineOperation sumber daya, kembali ke langkah RBAC daemon flex sementara di Mengonfigurasi jaringan dan membuat kumpulan node fleksibel di AKS, verifikasi bahwa peran dan pengikatannya ada, lalu mulai ulang agen:

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

Memvalidasi penempatan dan konektivitas beban kerja

Membuat beban kerja validasi

Buat namespace khusus. Jika namespace ini sudah ada, bersihkan proses validasi sebelumnya sebelum mencoba lagi.

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

Buat server HTTP yang ditempatkan oleh penjadwal Kubernetes pada node flex, dan mengeksposnya melalui layanan 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

Memverifikasi panggilan balik dan konektivitas layanan lokal

Periksa log dan eksekusi perintah dengan menggunakan jalur panggilan balik server 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"'

Dapatkan ClusterIP dan minta layanan dari beban kerja simpul flex:

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"

Respons yang diharapkan adalah:

flex-network-ok

Memverifikasi penerusan port

Di terminal saat ini, teruskan port lokal melalui server API Kubernetes. Perintah ini menggunakan lingkungan penyebaran dan kubeconfig yang Anda muat sebelumnya:

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

Di terminal kedua, buat permintaan ke endpoint yang diteruskan:

curl -fsS http://127.0.0.1:18080

Respons yang diharapkan adalah flex-network-ok. Tekan Ctrl+C di terminal pertama setelah pemeriksaan.

Memverifikasi konektivitas dari simpul yang dikelola AKS

Temukan simpul sistem terkelola AKS yang siap pakai:

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

Jalankan pod klien pada simpul tersebut dan periksa respons yang diharapkan:

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

Simpul Kubernetes yang berstatus Ready menunjukkan bahwa simpul telah terdaftar. Ini tidak dengan sendirinya membuktikan jaringan beban kerja, operasi panggilan balik, atau operasi siklus hidup Azure.

Membersihkan beban kerja validasi

Hapus hanya sumber daya sementara yang Anda buat di artikel ini.

kubectl delete namespace "${VALIDATION_NAMESPACE}"

Langkah selanjutnya

Selanjutnya, kelola, perbarui, tingkatkan, atau hapus simpul flex terlampir.

  • Terakhir diperbarui pada