Rencanakan node fleksibel untuk 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:

Simpul fleksibel memperluas kluster Azure Kubernetes Service (AKS) hingga mencakup mesin Linux yang Anda kelola di luar kumpulan simpul kluster yang dikelola Azure. Sebelum Anda menambahkan node flex, pilih bagaimana host mengautentikasi ke Azure, bagaimana ia mencapai server API Kubernetes, dan bagaimana lalu lintas jaringan bergerak antara lingkungan AKS dan simpul flex.

Artikel ini membantu Anda membuat keputusan ini, merencanakan rentang alamat yang tidak tumpang tindih, dan membuat file lingkungan bersama untuk artikel penyebaran yang tersisa.

Sebelum Anda mulai

  • Tinjau node flex untuk gambaran umum AKS.
  • Tinjau konsep identitas dan akses untuk node flex.
  • Tinjau konsep jaringan untuk simpul fleksibel.
  • Gunakan lingkungan Bash yang kompatibel dengan Linux yang memiliki alat dan akses jaringan yang diperlukan. Seri deployment ini menyebut lingkungan tersebut sebagai lingkungan Bash Anda. Mesin terpisah yang bergabung dengan kluster adalah host flex node.
  • Pasang Azure CLI. Jalankan az --version untuk menemukan versi terinstal. Untuk menginstal atau meningkatkan, lihat Install Azure CLI.
  • Masuk ke Azure dengan akun yang dapat membaca langganan target dan konfigurasi jaringan virtual.
  • Siapkan jaringan virtual dan subnet Azure yang ada untuk simpul AKS yang dikelola Azure. Jaringan virtual dapat berada dalam grup sumber daya yang berbeda dari kluster AKS. Ketika ya, pastikan bahwa identitas kluster AKS memiliki izin yang diperlukan pada subnet.

Buat keputusan penerapan

Rencanakan keputusan berikut sebelum Anda membuat atau mengonfigurasi sumber daya.

Keputusan Opsi Apa yang diatur oleh keputusan
Identitas host Identitas terkelola, identitas terkelola Azure Arc, atau perwakilan layanan Bagaimana agen node fleksibel melakukan autentikasi ke Azure
Akses API AKS Kluster AKS publik atau privat Bagaimana lingkungan Bash dan host node fleksibel Anda melakukan resolusi dan mengakses server API Kubernetes
Konektivitas node Flex Konektivitas Lapisan 3 atau gateway WireGuard Unbounded-Net Cara node yang dikelola oleh AKS, node fleksibel, pod, dan layanan Kubernetes saling berkomunikasi

Keputusan ini membahas berbagai bagian penyebaran. Misalnya, memilih titik akhir API AKS publik tidak membuat konektivitas jaringan antara node yang dikelola AKS dan host node fleksibel.

Pilih identitas host

Gunakan tabel keputusan dalam konsep identitas dan akses untuk simpul flex untuk memilih identitas Azure yang digunakan agen simpul flex.

Identitas host mengotorisasi operasi Azure. Ini tidak menggantikan konektivitas jaringan atau konfigurasi bootstrap Kubernetes yang diperlukan host untuk bergabung dengan kluster. Jangan simpan kredensial dalam file lingkungan bersama.

Pilih akses AKS API publik atau privat

Server API Kubernetes adalah titik akhir manajemen untuk kluster. Lingkungan Bash Anda dan setiap host node flex harus dapat melakukan resolusi dan terhubung ke endpoint ini.

  • Akses AKS API publik menggunakan titik akhir publik yang aman. Autentikasi dan otorisasi Kubernetes masih mengontrol akses ke kluster. Titik akhir API publik tidak mengekspos aplikasi yang berjalan di kluster.
  • Akses API AKS privat menggunakan titik akhir privat di jaringan virtual AKS. Jalankan perintah penyiapan Azure CLI, kubectl, dan kluster di lingkungan Bash Anda, yang harus berjalan pada komputer yang terhubung ke jaringan privat tersebut. Jaringan simpul fleksibel juga harus dapat menyelesaikan nama DNS privat kluster dan merutekan lalu lintas ke titik akhir privat.

Penyebaran simpul Flex mendukung akses publik dan privat ke server API. Jalur privat memerlukan konfigurasi DNS, perutean, dan eksekusi perintah tambahan, sebagaimana disebutkan pada bagian yang relevan. Untuk panduan AKS umum, lihat Merencanakan jaringan sarana kontrol untuk AKS, Membuat kluster AKS privat, dan Menyambungkan ke kluster AKS privat.

Pilih konektivitas simpul fleksibel

Seri penyebaran ini membuat kluster AKS tanpa plugin jaringan bawaan dan menginstal Unbounded-Net pada node yang dikelola AKS dan simpul fleksibel. Unbounded-Net menetapkan rentang alamat pod dan mengonfigurasi perutean antara lingkungan AKS dan node fleksibel. Artikel ini menjelaskan alur kerja tersebut. Konfigurasi CNI atau konfigurasi jaringan lainnya mungkin memerlukan konfigurasi perutean, firewall, DNS, gateway, keamanan, dan siklus hidup yang berbeda. Untuk penjelasan tentang model jaringan pratinjau publik, lihat konsep jaringan untuk simpul fleksibel.

Anda menyediakan konektivitas jaringan yang mendasari antara lingkungan AKS dan lingkungan node fleksibel. Konektivitas Lapisan 3 berarti bahwa kedua jaringan node sudah dapat merutekan paket IP ke alamat node satu sama lain, di kedua arah. Pilih metode yang sesuai dengan jaringan Anda yang ada:

Metode konektivitas Kapan harus menggunakannya
Interkoneksi jaringan virtual Kluster AKS dan host node fleksibel berada di jaringan virtual Azure, termasuk jaringan virtual di wilayah yang berbeda.
VPN Gateway Host simpul fleksibel berada di lingkungan lokal atau jaringan lain yang terhubung ke Azure melalui VPN situs-ke-situs terenkripsi.
ExpressRoute Organisasi Anda menggunakan koneksi privat khusus antara jaringannya dan Azure.
gateway Unbounded-Net WireGuard Jaringan AKS dan jaringan node fleksibel tidak memiliki koneksi privat yang dirutekan. Anda mengonfigurasi dan mengoperasikan terowongan WireGuard pada kumpulan simpul gateway AKS, dan simpul gateway tersebut harus dapat diakses secara publik. Rencanakan kapasitas dan ketersediaan gateway, karena lalu lintas pod lintas lingkungan bergantung pada pool ini. Lihat kluster AKS publik dengan lab Unbounded-Net WireGuard.

Panduan Microsoft Learn menggunakan konektivitas Lapisan 3 dengan Unbounded-Net.

AKS API Konektivitas node Flex Guidance
Public Konektivitas Lapisan 3 Konfigurasi yang disarankan
Privat Konektivitas Lapisan 3 Memerlukan konfigurasi DNS, perutean, dan eksekusi perintah tambahan
Public Gateway publik WireGuard Topologi alternatif; lihat lab AKSFlexNode
Privat Gateway publik WireGuard Tidak tercakup dalam dokumentasi ini

Note

Untuk contoh topologi tambahan, lihat lab AKSFlexNode, termasuk contoh yang menggunakan server API AKS publik dengan gateway WireGuard dan server API AKS privat dengan jaringan yang dikelola pelanggan. Lab ini melengkapi konfigurasi yang didokumentasikan dalam artikel ini. Lab ini mungkin menggunakan komponen jaringan yang berbeda dan memiliki tanggung jawab operasional atau dukungan yang berbeda. Sebelum menggunakan lab, tinjau prasyarat, batasan, versi komponen yang berlaku, dan tanggung jawab pelanggan. Lab GitHub tidak memperluas cakupan dukungan yang didokumenkan di Microsoft Learn.

Untuk memberikan umpan balik tentang topologi yang tidak diwakili, buka masalah di repositori AKSFlexNode. Sertakan lokasi host simpul fleksibel, model akses AKS API, metode konektivitas yang diusulkan, CNI yang diusulkan, dan jalur jaringan yang diperlukan oleh skenario.

Merencanakan konektivitas jaringan yang diperlukan

Bekerja sama dengan administrator jaringan Anda untuk memastikan desain jaringan menyediakan konektivitas berikut:

Persyaratan Mengapa hal ini diperlukan
Lingkungan Bash Anda dapat menyelesaikan dan menjangkau server API AKS. Anda memerlukan koneksi ini untuk mengonfigurasi dan mengelola kluster.
Setiap host node flex dapat menyelesaikan dan menjangkau server API AKS. Agen simpul flex dan kubelet menggunakan koneksi ini untuk bergabung dengan kluster dan berkomunikasi dengan sarana kontrol Kubernetes.
Node yang dikelola AKS dan host simpul fleksibel dapat menjangkau alamat IP privat satu sama lain. Untuk sebagian besar metode konektivitas, Unbounded-Net menggunakan jaringan simpul sebagai jalur yang mendasar antara kedua lingkungan.
Lalu lintas Pod dan layanan Kubernetes dapat dirutekan antara node yang dikelola AKS dan flex node. Beban kerja memerlukan komunikasi lintas node, DNS kluster, dan akses layanan Kubernetes.
Sarana kontrol AKS dapat terhubung ke kubelet pada node flex. AKS menggunakan jalur ini untuk operasi kubelet, termasuk kubectl logs, kubectl exec, dan kubectl port-forward.

Anda mengonfigurasi dan mengoperasikan jaringan host eksternal, termasuk perutean, peering jaringan virtual, koneksi VPN atau ExpressRoute, aturan firewall dan grup keamanan jaringan, DNS, pengaturan proksi, dan konfigurasi Unbounded-Net yang didokumentasikan dalam seri ini. Untuk model tanggung jawab penuh, lihat kebijakan dukungan untuk node flex.

Batasi akses manajemen host ke alamat sumber yang disetujui. Untuk VM Azure, kaitkan grup keamanan jaringan dengan subnet host atau antarmuka jaringan. Untuk host di luar Azure, terapkan kontrol firewall yang setara. Jika Anda menggunakan az vm create untuk membuat host node fleksibel, tinjau alamat IP publik apa pun dan aturan grup keamanan jaringan yang dibuat oleh perintah tersebut. Kecuali Anda membatasi aturan SSH, aturan tersebut dapat mengizinkan koneksi ke port TCP 22 dari sumber publik apa pun.

Mengumpulkan nilai penyebaran

Artikel yang tersisa menggunakan kembali nilai berikut.

Nilai sumber daya Azure umum

Variable Deskripsi Saat digunakan
SUBSCRIPTION_ID Langganan yang berisi kluster AKS dan sumber daya Azure terkait. Setiap penerapan
RESOURCE_GROUP Grup sumber daya yang berisi kluster AKS. Setiap penerapan
CLUSTER_NAME Nama klaster AKS. Setiap penerapan
FLEX_POOL_NAME Nama kumpulan simpul flex. Gunakan huruf dan digit saja. Setiap penerapan
AKS_API_ACCESS Model akses API untuk kluster AKS. Atur nilai ke public atau private. Persiapan kluster dan validasi konektivitas API
AKS_RESOURCE_ID ID sumber daya Azure dari kluster AKS. Azure menyediakan nilai ini setelah kluster ada. Artikel selanjutnya

Kluster AKS dan nilai jaringan virtual

Variable Deskripsi Saat digunakan
LOCATION Wilayah Azure untuk kluster AKS. Konfirmasikan bahwa wilayah ini memenuhi persyaratan ketersediaan regional . Membuat kluster AKS
AKS_VNET_NAME Nama jaringan virtual yang berisi subnet AKS. Menemukan dan memvalidasi subnet AKS
AKS_VNET_RESOURCE_GROUP Grup sumber daya yang berisi jaringan virtual AKS. Ini dapat berbeda dari RESOURCE_GROUP. Menemukan dan memvalidasi subnet AKS
AKS_SUBNET_NAME Nama subnet yang digunakan oleh simpul AKS yang dikelola Azure. Menemukan dan memvalidasi subnet AKS
AKS_SUBNET_ID ID sumber daya Azure dari subnet AKS. Membuat kluster AKS
AKS_NODE_VM_SIZE Ukuran VM Azure untuk kumpulan node sistem AKS yang dikelola Azure. Nilai ini tidak menentukan ukuran host node flex. Membuat kluster AKS
SERVICE_CIDR Rentang alamat untuk layanan Kubernetes. Mengonfigurasi profil jaringan kluster AKS
DNS_SERVICE_IP Alamat IP untuk layanan DNS Kubernetes. Mengonfigurasi profil jaringan kluster AKS

Ambil ID sumber daya subnet AKS dan rentang alamat sebelum Anda membuat file lingkungan:

az network vnet subnet show \
    --resource-group '<virtual-network-resource-group>' \
    --vnet-name '<virtual-network-name>' \
    --name '<aks-subnet-name>' \
    --query "{ResourceId:id,AddressPrefix:addressPrefix,AddressPrefixes:addressPrefixes}" \
    --output json

Nilai alamat AKS dan Unbounded-Net

Anda menggunakan SERVICE_CIDR dan DNS_SERVICE_IP untuk mengonfigurasi profil jaringan kluster AKS. Konfigurasikan CIDR node dan pod untuk menyiapkan site Unbounded-Net yang digunakan dalam panduan ini.

Node AKS, pod AKS, node flex, pod flex, dan rentang layanan Kubernetes harus mengikuti desain jaringan yang dipilih dan tidak boleh saling tumpang tindih atau jaringan apa pun yang dapat dijangkau melalui peering jaringan virtual, VPN, atau ExpressRoute. Koordinasikan nilai akhir dengan administrator jaringan Anda.

Jangan menyalin contoh CIDR dari deployment lain. CIDR mengidentifikasi ruang alamat yang dapat dirutekan, sehingga menggunakan kembali contoh yang tumpang tindih dengan Azure atau jaringan yang terhubung milik Anda dapat menyebabkan lalu lintas menjadi tidak jelas atau membuat node dan pod tidak dapat saling berkomunikasi.

Variable Deskripsi Digunakan oleh
AKS_SUBNET_CIDR Rentang alamat yang ditetapkan untuk subnet bagi node AKS yang dikelola Azure. Azure Virtual Network dan validasi subnet AKS
AKS_NODE_CIDR Rentang simpul situs Unbounded-Net yang mencakup subnet simpul AKS. Situs kluster utama Unbounded-Net
AKS_POD_CIDR Kumpulan alamat untuk pod pada simpul AKS yang dikelola Azure. Situs kluster utama Unbounded-Net
FLEX_HOST_SUBNET_CIDR Rentang alamat yang berisi host simpul fleksibel. Validasi jaringan host node Flex
FLEX_NODE_CIDR Unbounded-Net Rentang node situs yang berisi subnet host node fleksibel. Situs Unbounded-Net untuk simpul fleksibel
FLEX_POD_CIDR Kumpulan alamat untuk pod pada simpul flex. Situs Unbounded-Net untuk simpul fleksibel
SERVICE_CIDR Rentang alamat untuk layanan Kubernetes. Profil jaringan kluster AKS
DNS_SERVICE_IP Alamat IP untuk layanan DNS Kubernetes. Profil jaringan kluster AKS

Menerapkan aturan berikut pada rencana pengalamatan:

  • AKS_SUBNET_CIDR harus terkandung dalam AKS_NODE_CIDR.
  • FLEX_HOST_SUBNET_CIDR harus terkandung dalam FLEX_NODE_CIDR.
  • DNS_SERVICE_IP harus berada di dalam SERVICE_CIDR.

Delapan nilai ini tidak delapan rentang terpisah. Lima adalah rentang independen yang tidak boleh tumpang tindih, dua adalah rentang subnet yang terkandung dalam rentang simpul Situs yang sesuai, dan satu adalah satu alamat IP di dalam rentang layanan.

Nilai berikut memenuhi setiap aturan di bagian ini. Perlakukan mereka sebagai ilustrasi hubungan, bukan sebagai default. Konfirmasikan nilai Anda sendiri terhadap Azure dan ruang alamat jaringan yang terhubung sebelum Anda menggunakannya.

Variable Example Relationship
AKS_NODE_CIDR 10.10.0.0/16 Rentang independen
AKS_SUBNET_CIDR 10.10.1.0/24 Terkandung dalam AKS_NODE_CIDR
AKS_POD_CIDR 10.244.0.0/16 Rentang independen
FLEX_NODE_CIDR 10.20.0.0/16 Rentang independen
FLEX_HOST_SUBNET_CIDR 10.20.1.0/24 Terkandung dalam FLEX_NODE_CIDR
FLEX_POD_CIDR 10.245.0.0/16 Rentang independen
SERVICE_CIDR 10.96.0.0/16 Rentang independen
DNS_SERVICE_IP 10.96.0.10 Dalam SERVICE_CIDR

Tinjau ruang alamat jaringan virtual Azure saat ini:

az network vnet list \
    --query "[].{ResourceGroup:resourceGroup,Name:name,AddressPrefixes:addressSpace.addressPrefixes}" \
    --output table

Azure dapat mengidentifikasi konflik dalam sumber daya yang dikelolanya, tetapi tidak dapat memvalidasi rentang alamat di setiap jaringan lokal atau eksternal yang terhubung.

Nilai versi komponen

Simpul Flex memerlukan versi AKS yang kompatibel, ekstensi Azure CLI, Unbounded-Net, dan agen simpul flex. Gunakan versi yang tercantum dalam artikel ini, dan jangan pilih atau tingkatkan komponen ini secara independen.

Variable Deskripsi
AKS_VERSION Versi Kubernetes yang didukung untuk kluster AKS.
AKS_PREVIEW_VERSION aks-preview versi ekstensi Azure CLI 22.0.0b8 atau yang lebih baru.
UNBOUNDED_VERSION Versi Unbounded-Net yang didukung.
AKS_FLEX_NODE_VERSION Versi agen node flex yang didukung.

Ketersediaan regional

Node Flex memerlukan rilis AKS v20260904 atau yang lebih baru di wilayah tempat kluster Anda dihosting. AKS menerapkan rilis berbasis tanggal ini secara otomatis, dan terpisah dari versi Kubernetes yang Anda tetapkan di AKS_VERSION.

Sebelum Anda membuat atau memilih kluster, buka tab Rilis AKS dari pelacak rilis AKS, temukan wilayah Anda, dan periksa versi di bawah Saat Ini dalam Operasi. Versi rilis AKS menggunakan vYYYYMMDD format . Jika wilayah Anda menampilkan versi yang lebih lama, tunggu rilis menjangkau wilayah atau, jika persyaratan penyebaran Anda memungkinkan, pilih wilayah tempat rilis yang diperlukan tersedia.

Nilai ruang kerja lokal

Variable Deskripsi
WORK_DIR Direktori di lingkungan Bash Tempat artikel yang tersisa menyimpan unduhan, file yang dihasilkan, dan file kubeconfig kluster. Nilai defaultnya adalah ~/.local/share/aksflexnode/<deployment-name>. Untuk menyimpan file-file ini di tempat lain, seperti direktori sementara yang Anda hapus setelah penyebaran, ubah WORK_DIR nilai dalam file lingkungan.

Membuat file lingkungan bersama

Buat satu file lingkungan untuk setiap penyebaran. File ini menjaga agar nilai yang tidak bersifat rahasia tetap konsisten di semua artikel dan sesi terminal lainnya.

Jangan menyimpan token akses, data bootstrap, konten kubeconfig, kredensial perwakilan layanan, sertifikat, kunci privat sertifikat, atau kunci privat SSH dalam file ini.

  1. Pilih label penyebaran singkat dan buat direktori yang dilindungi untuk file lingkungan.

    export FLEXNODE_DEPLOYMENT="flexnode-demo"
export FLEXNODE_ENV_DIR="${HOME}/.config/aks-flexnode"
export FLEXNODE_ENV_FILE="${FLEXNODE_ENV_DIR}/${FLEXNODE_DEPLOYMENT}.env"

install -d -m 0700 "${FLEXNODE_ENV_DIR}"

  2. Buat file lingkungan.

    if [[ -e "${FLEXNODE_ENV_FILE}" ]]; then
    printf 'Environment file already exists: %s\n' "${FLEXNODE_ENV_FILE}" >&2
    false
else
    install -m 0600 /dev/null "${FLEXNODE_ENV_FILE}"

    cat > "${FLEXNODE_ENV_FILE}" <<'EOF'
set_flexnode_env() {
    if [[ "$#" -ne 2 || ! "$1" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]]; then
        printf 'Usage: set_flexnode_env NAME VALUE\n' >&2
        return 2
    fi

    local name="$1"
    local value="$2"
    local temporary_file

    temporary_file="$(mktemp "$(dirname "${FLEXNODE_ENV_FILE}")/flexnode.env.XXXXXX")" || return 1
    awk -v prefix="export ${name}=" 'index($0, prefix) != 1 { print }' \
        "${FLEXNODE_ENV_FILE}" > "${temporary_file}" || {
        rm -f "${temporary_file}"
        return 1
    }

    printf 'export %s=%q\n' "${name}" "${value}" >> "${temporary_file}" || {
        rm -f "${temporary_file}"
        return 1
    }

    install -m 0600 "${temporary_file}" "${FLEXNODE_ENV_FILE}" || {
        rm -f "${temporary_file}"
        return 1
    }

    rm -f "${temporary_file}"
    export "${name}=${value}"
}

# Customer inputs
export SUBSCRIPTION_ID='<subscription-id>'
export LOCATION='<supported-aks-region>'
export RESOURCE_GROUP='<aks-resource-group>'
export CLUSTER_NAME='<aks-cluster-name>'
export FLEX_POOL_NAME='<flex-node-pool-name>'
export AKS_API_ACCESS='<public-or-private>'

# AKS virtual network
export AKS_VNET_NAME='<virtual-network-name>'
export AKS_VNET_RESOURCE_GROUP='<virtual-network-resource-group>'
export AKS_SUBNET_NAME='<aks-subnet-name>'
export AKS_SUBNET_ID='<aks-subnet-resource-id>'

# Network address ranges
export AKS_SUBNET_CIDR='<aks-node-subnet-cidr>'
export AKS_POD_CIDR='<aks-pod-cidr>'
export AKS_NODE_CIDR='<aks-site-node-cidr>'
export FLEX_HOST_SUBNET_CIDR='<flex-host-subnet-cidr>'
export FLEX_NODE_CIDR='<flex-site-node-cidr>'
export FLEX_POD_CIDR='<flex-node-pod-cidr>'
export SERVICE_CIDR='<kubernetes-service-cidr>'
export DNS_SERVICE_IP='<kubernetes-dns-service-ip>'

# Azure-managed AKS system node pool
export AKS_NODE_VM_SIZE='<supported-and-available-aks-node-vm-size>'

# Compatible component versions for flex nodes (preview)
export AKS_VERSION='1.36.2'
export AKS_PREVIEW_VERSION='22.0.0b8'
export UNBOUNDED_VERSION='v0.8.0'
export AKS_FLEX_NODE_VERSION='v0.2.0'

# Local paths
export WORK_DIR="${HOME}/.local/share/aksflexnode/${FLEXNODE_DEPLOYMENT}"

# Values recorded by later articles
export AKS_RESOURCE_ID=''
export FLEXNODE_KUBECONFIG=''
export FLEX_POOL_RESOURCE_ID=''
export FLEX_MACHINE_NAME=''
export FLEX_HOST_NAME=''
export FLEX_HOST_SSH_TARGET=''
export FLEX_HOST_PRIVATE_IP=''
export HOST_PRINCIPAL_OBJECT_ID=''
export HOST_IDENTITY_CLIENT_ID=''
export SSH_PUBLIC_KEY_PATH=''
export SSH_PRIVATE_KEY_PATH=''
export VM_RESOURCE_GROUP=''
export VM_NAME=''
export VM_RESOURCE_ID=''
export ARC_RESOURCE_GROUP=''
export ARC_MACHINE_NAME=''
export ARC_RESOURCE_ID=''
export SP_TENANT_ID=''
export SP_CLIENT_ID=''
export SP_OBJECT_ID=''
EOF
fi

    Pembantu set_flexnode_env memungkinkan artikel selanjutnya merekam nilai yang dihasilkan Azure tanpa menambahkan definisi duplikat ke file.

  3. Buka ${FLEXNODE_ENV_FILE} di editor dan ganti setiap nilai yang diapit dalam tanda kurung sudut. Biarkan nilai di bawah Nilai yang dicatat oleh artikel berikutnya tetap kosong.

  4. Periksa bahwa tidak ada placeholder yang tersisa.

    if grep -n '<[^>]*>' "${FLEXNODE_ENV_FILE}"; then
    printf 'Replace the unresolved placeholders before you continue.\n' >&2
    false
else
    printf 'No unresolved placeholders found.\n'
fi

  5. Muat file lingkungan, buat direktori kerja, dan atur langganan Azure aktif.

    source "${FLEXNODE_ENV_FILE}"
install -d -m 0700 "${WORK_DIR:?Load the deployment environment first.}"
az account set --subscription "${SUBSCRIPTION_ID}"
az account show \
    --query "{Name:name,SubscriptionId:id}" \
    --output table

    Pastikan bahwa ID langganan yang dikembalikan cocok dengan SUBSCRIPTION_ID.

    Konfirmasikan bahwa AKS_API_ACCESS mengidentifikasi jalur yang didukung:

    case "${AKS_API_ACCESS}" in
    public|private)
        printf 'AKS API access: %s\n' "${AKS_API_ACCESS}"
        ;;
    *)
        printf 'Set AKS_API_ACCESS to public or private.\n' >&2
        false
        ;;
esac

    Mulai setiap sesi terminal baru dengan mengatur label penyebaran dan memuat file lingkungannya:

    export FLEXNODE_DEPLOYMENT="flexnode-demo"
export FLEXNODE_ENV_FILE="${HOME}/.config/aks-flexnode/${FLEXNODE_DEPLOYMENT}.env"
test -s "${FLEXNODE_ENV_FILE}"
source "${FLEXNODE_ENV_FILE}"
install -d -m 0700 "${WORK_DIR:?Load the deployment environment first.}"

Memvalidasi nilai perencanaan

Verifikasi subnet AKS yang dipilih.

az network vnet subnet show \
    --resource-group "${AKS_VNET_RESOURCE_GROUP}" \
    --vnet-name "${AKS_VNET_NAME}" \
    --name "${AKS_SUBNET_NAME}" \
    --query "{AddressPrefix:addressPrefix,AddressPrefixes:addressPrefixes,ResourceId:id}" \
    --output json

Konfirmasikan bahwa ID sumber daya dan rentang alamat yang dikembalikan cocok AKS_SUBNET_ID dan AKS_SUBNET_CIDR.

Langkah selanjutnya

Selanjutnya, siapkan kluster AKS untuk node flex. Artikel berikutnya membuat kluster AKS publik atau privat dan merekam ID sumber daya kluster.

  • Terakhir diperbarui pada