Flexknoten für AKS planen (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:

Flex-Knoten erweitern einen Azure Kubernetes Service (AKS)-Cluster um Linux-Computer, die Sie außerhalb der von Azure verwalteten Knotenpools des Clusters verwalten. Bevor Sie einen Flex-Knoten hinzufügen, wählen Sie aus, wie sich der Host für Azure authentifiziert, wie er den Kubernetes-API-Server erreicht und wie der Netzwerkdatenverkehr zwischen den AKS- und Flex-Knotenumgebungen verschoben wird.

Dieser Artikel hilft Ihnen dabei, diese Entscheidungen zu treffen, nicht überlappende Adressbereiche zu planen und eine freigegebene Umgebungsdatei für die verbleibenden Bereitstellungsartikel zu erstellen.

Bevor Sie anfangen

  • Lesen Sie die Übersicht über Flex Nodes für AKS.
  • Überprüfen Sie Identitäts- und Zugriffskonzepte für Flexknoten.
  • Überprüfen Sie Netzwerkkonzepte für Flexknoten.
  • Verwenden Sie eine linuxkompatible Bash-Umgebung mit den erforderlichen Tools und Netzwerkzugriff. Diese Reihe von Bereitstellungsschritten bezeichnet diese Umgebung als Ihre Bash-Umgebung. Der separate Computer, der dem Cluster beitritt, ist der Flexknotenhost.
  • Installieren Sie die Azure CLI. Führen Sie az --version aus, um die installierte Version zu ermitteln. Informationen zum Installieren oder Aktualisieren finden Sie unter Installieren des Azure CLI.
  • Melden Sie sich bei Azure mit einem Konto an, das das Zielabonnement und die Konfiguration des virtuellen Netzwerks lesen kann.
  • Bereiten Sie ein vorhandenes Azure virtuelles Netzwerk und Subnetz für die Azure verwalteten AKS-Knoten vor. Das virtuelle Netzwerk kann sich in einer anderen Ressourcengruppe als dem AKS-Cluster befinden. Wenn dies der Fall ist, stellen Sie sicher, dass die AKS-Clusteridentität über die erforderlichen Berechtigungen für das Subnetz verfügt.

Treffen der Bereitstellungsentscheidungen

Planen Sie die folgenden Entscheidungen, bevor Sie Ressourcen erstellen oder konfigurieren.

Entscheidung Options Was die Entscheidung steuert
Hostidentität Verwaltete Identität, von Azure Arc verwaltete Identität oder Dienstprinzipal So authentifiziert sich der Flex-Knoten-Agent bei Azure
AKS-API-Zugriff Öffentlicher oder privater AKS-Cluster Wie Ihre Bash-Umgebung und Flex-Node-Hosts den Kubernetes-API-Server auflösen und erreichen
Flex-Knotenkonnektivität Layer 3-Konnektivität oder ein Unbounded-Net WireGuard-Gateway Wie AKS-verwaltete Knoten, Flex-Knoten, Pods und Kubernetes-Dienste kommunizieren

Diese Entscheidungen befassen sich mit verschiedenen Teilen der Bereitstellung. Wenn Sie z. B. einen öffentlichen AKS-API-Endpunkt auswählen, wird keine Netzwerkkonnektivität zwischen AKS-verwalteten Knoten und Flexknotenhosts erstellt.

Auswählen der Hostidentität

Verwenden Sie die Entscheidungstabelle in Identitäts- und Zugriffskonzepten für Flexknoten, um die Azure Identität auszuwählen, die der Flexknoten-Agent verwendet.

Die Hostidentität autorisiert Azure Vorgänge. Es ersetzt weder die Netzwerkanbindung noch die Kubernetes-Bootstrap-Konfiguration, die der Host benötigt, um dem Cluster beizutreten. Speichern Sie keine Anmeldeinformationen in der gemeinsamen Umgebungsdatei.

Auswählen des öffentlichen oder privaten AKS-API-Zugriffs

Der Kubernetes-API-Server ist der Verwaltungsendpunkt für den Cluster. Ihre Bash-Umgebung und jeder Host eines Flex-Knotens müssen in der Lage sein, diesen Endpunkt aufzulösen und eine Verbindung zu ihm herzustellen.

  • Der Zugriff auf die öffentliche AKS-API verwendet einen gesicherten öffentlichen Endpunkt. Kubernetes-Authentifizierung und Autorisierung steuern weiterhin den Zugriff auf den Cluster. Ein öffentlicher API-Endpunkt macht die im Cluster ausgeführten Anwendungen nicht verfügbar.
  • Der Zugriff auf private AKS-API verwendet einen privaten Endpunkt im virtuellen AKS-Netzwerk. Führen Sie Azure CLI-, kubectl und Befehle zum Einrichten des Clusters in Ihrer Bash-Umgebung aus, die auf einem Computer ausgeführt werden muss, der mit diesem privaten Netzwerk verbunden ist. Das Flexknotennetzwerk muss auch in der Lage sein, den privaten DNS-Namen des Clusters aufzulösen und den Datenverkehr an den privaten Endpunkt weiterzuleiten.

Flex-Knotenbereitstellungen unterstützen sowohl öffentlichen als auch privaten Zugriff auf den API-Server. Für den privaten Pfad sind zusätzliche DNS-, Routing- und Befehlsausführungskonfigurationen erforderlich, die dort aufgerufen werden, wo sie angewendet werden. Allgemeine Anleitungen zu AKS finden Sie unter Planen der Steuerungsebenennetzwerke für AKS, Erstellen eines privaten AKS-Clusters und Herstellen einer Verbindung mit einem privaten AKS-Cluster.

Auswählen der Flex-Knotenkonnektivität

Diese Bereitstellungsreihe erstellt den AKS-Cluster ohne integriertes Netzwerk-Plug-In und installiert Unbounded-Net sowohl auf den AKS-verwalteten Knoten als auch auf Flex-Knoten. Unbounded-Net weist Pod-Adressbereiche zu und konfiguriert das Routing zwischen den AKS- und Flex-Node-Umgebungen. In diesem Artikel wird dieser Workflow beschrieben. Andere CNI- oder Netzwerkkonfigurationen erfordern möglicherweise unterschiedliche Routing-, Firewall-, DNS-, Gateway-, Sicherheits- und Lebenszykluskonfigurationen. Eine Erläuterung des Public Preview-Netzwerkmodells finden Sie unter Netzwerkkonzepte für Flexknoten.

Sie stellen die zugrunde liegende Netzwerkverbindung zwischen den AKS- und Flex-Knotenumgebungen bereit. Layer 3-Konnektivität bedeutet, dass beide Knotennetzwerke IP-Pakete bereits in beide Richtungen an die Knotenadressen der anderen weiterleiten können. Wählen Sie die Methode aus, die ihrem vorhandenen Netzwerk entspricht:

Konnektivitätsmethode Wann wird es verwendet?
Peering in virtuellen Netzwerken Die AKS-Cluster und FlexNode-Hosts befinden sich in virtuellen Azure-Netzwerken, auch in virtuellen Netzwerken in unterschiedlichen Regionen.
VPN-Gateway Die Flexknotenhosts befinden sich in einer lokalen Umgebung oder in einem anderen Netzwerk, das über ein verschlüsseltes Site-to-Site-VPN mit Azure verbunden ist.
ExpressRoute Ihre Organisation verwendet eine dedizierte private Verbindung zwischen ihrem Netzwerk und Azure.
Unbounded-Net WireGuard-Gateway Die AKS- und Flex-Knotennetzwerke verfügen nicht über eine private Routingverbindung. Sie konfigurieren und betreiben die WireGuard-Tunnel in einem AKS-Gatewayknotenpool, und diese Gatewayknoten müssen öffentlich zugänglich sein. Planen Sie die Kapazität und Verfügbarkeit des Gateways ein, da der umgebungsübergreifende Pod-Datenverkehr von diesem Pool abhängt. Sehen Sie sich den öffentlichen AKS-Cluster mit Unbounded-Net WireGuard Lab an.

Die Schritt-für-Schritt-Anleitung in Microsoft Learn verwendet Layer 3-Konnektivität mit Unbounded-Net.

AKS-API Flex-Knotenkonnektivität Leitfaden
Öffentlichkeit Konnektivität der Ebene 3 Empfohlene Konfiguration
Privat Konnektivität der Ebene 3 Erfordert zusätzliche DNS-, Routing- und Befehlsausführungskonfiguration
Öffentlichkeit Öffentliches WireGuard-Gateway Alternative Topologie; siehe die AKSFlexNode Labs
Privat Öffentliches WireGuard-Gateway Nicht abgedeckt durch diese Dokumentation

Note

Weitere Topologiebeispiele finden Sie in den AKSFlexNode Labs, einschließlich Beispielen, die einen öffentlichen AKS-API-Server mit einem WireGuard-Gateway und einen privaten AKS-API-Server mit vom Kunden verwalteten Netzwerken verwenden. Diese Labore ergänzen die in diesem Artikel dokumentierte Konfiguration. Diese Labore verwenden möglicherweise unterschiedliche Netzwerkkomponenten und weisen unterschiedliche betriebliche oder Supportaufgaben auf. Bevor Sie ein Labor verwenden, überprüfen Sie ihre Voraussetzungen, Einschränkungen, anwendbare Komponentenversionen und Kundenverantwortungen. Ein GitHub Lab erweitert den in Microsoft Learn dokumentierten Unterstützungsbereich nicht.

Um Feedback zu einer nicht dargestellten Topologie zu geben, öffnen Sie ein Problem im AKSFlexNode-Repository. Geben Sie den Standort des Flex-Knotenhosts, das AKS-API-Zugriffsmodell, die vorgeschlagene Verbindungsmethode, die vorgeschlagene CNI und die für das Szenario erforderlichen Netzwerkpfade an.

Planen der erforderlichen Netzwerkkonnektivität

Arbeiten Sie mit Ihrem Netzwerkadministrator zusammen, um sicherzustellen, dass das Netzwerkdesign die folgende Konnektivität bietet:

Anforderung Warum ist dies erforderlich?
Ihre Bash-Umgebung kann den AKS-API-Server auflösen und erreichen. Sie benötigen diese Verbindung, um den Cluster zu konfigurieren und zu verwalten.
Jeder Flexknotenhost kann den AKS-API-Server auflösen und erreichen. Der Flexknoten-Agent und kubelet verwenden diese Verbindung, um dem Cluster beizutreten und mit der Kubernetes-Steuerebene zu kommunizieren.
AKS-verwaltete Knoten und Flex-Node-Hosts können gegenseitig die privaten IP-Adressen des jeweils anderen erreichen. Für die meisten Konnektivitätsmethoden verwendet Unbounded-Net die Knotennetzwerke als zugrunde liegenden Pfad zwischen den beiden Umgebungen.
Der Pod- und Kubernetes-Dienstverkehr kann zwischen AKS-verwalteten Knoten und Flex-Knoten weitergeleitet werden. Workloads benötigen knotenübergreifende Kommunikation, Cluster-DNS und Kubernetes-Dienstzugriff.
Die AKS-Steuerebene kann eine Verbindung mit dem Kubelet auf einem Flexknoten herstellen. AKS verwendet diesen Pfad für Kubelet-Vorgänge, einschließlich kubectl logs, kubectl exec und kubectl port-forward.

Sie konfigurieren und betreiben das externe Hostnetzwerk, einschließlich Routing, virtueller Netzwerk-Peering, VPN- oder ExpressRoute-Verbindungen, Firewall- und Netzwerksicherheitsgruppenregeln, DNS, Proxyeinstellungen und der in dieser Reihe dokumentierten Unbounded-Net Konfiguration. Informationen zum Modell mit voller Verantwortung finden Sie in der Supportrichtlinie für Flexknoten.

Einschränken des Hostverwaltungszugriffs auf genehmigte Quelladressen. Ordnen Sie einer Azure VM eine Netzwerksicherheitsgruppe dem Hostsubnetz oder der Netzwerkschnittstelle zu. Wenden Sie für einen Host außerhalb Azure entsprechende Firewallsteuerelemente an. Wenn Sie az vm create verwenden, um einen Flex-Knoten-Host zu erstellen, überprüfen Sie die öffentliche IP-Adresse und die Regeln der Netzwerksicherheitsgruppe, die der Befehl erstellt. Sofern Sie die SSH-Regel nicht einschränken, können Verbindungen mit TCP-Port 22 aus einer beliebigen öffentlichen Quelle zugelassen werden.

Erfassen der Bereitstellungswerte

Die übrigen Artikel verwenden die folgenden Werte wieder.

Allgemeine Azure Ressourcenwerte

Variable BESCHREIBUNG Wann sie verwendet wird
SUBSCRIPTION_ID Abonnement, das den AKS-Cluster und zugehörige Azure-Ressourcen enthält. Jede Bereitstellung
RESOURCE_GROUP Ressourcengruppe, die den AKS-Cluster enthält. Jede Bereitstellung
CLUSTER_NAME Name des AKS-Clusters. Jede Bereitstellung
FLEX_POOL_NAME Name des Flex-Knotenpools. Verwenden Sie nur Buchstaben und Ziffern. Jede Bereitstellung
AKS_API_ACCESS API-Zugriffsmodell für den AKS-Cluster. Legen Sie den Wert auf public oder private. Clustervorbereitung und API-Konnektivitätsüberprüfung
AKS_RESOURCE_ID Azure Ressourcen-ID des AKS-Clusters. Azure stellt diesen Wert bereit, nachdem der Cluster vorhanden ist. Spätere Artikel

AKS-Cluster- und Virtuelle Netzwerkwerte

Variable BESCHREIBUNG Wann sie verwendet wird
LOCATION Azure Region für den AKS-Cluster. Stellen Sie sicher, dass diese Region die regionale Verfügbarkeitsanforderung erfüllt. Erstellen des AKS-Clusters
AKS_VNET_NAME Name des virtuellen Netzwerks, das das AKS-Subnetz enthält. Suchen und Überprüfen des AKS-Subnetzes
AKS_VNET_RESOURCE_GROUP Ressourcengruppe, die das virtuelle AKS-Netzwerk enthält. Es kann sich von RESOURCE_GROUP unterscheiden. Suchen und Überprüfen des AKS-Subnetzes
AKS_SUBNET_NAME Name des Subnetzes, das von den Azure verwalteten AKS-Knoten verwendet wird. Suchen und Überprüfen des AKS-Subnetzes
AKS_SUBNET_ID Azure Ressourcen-ID des AKS-Subnetzes. Erstellen des AKS-Clusters
AKS_NODE_VM_SIZE Azure VM-Größe für den Azure verwalteten AKS-Systemknotenpool. Dieser Wert passt nicht zur Größe des Flex-Knoten-Hosts. Erstellen des AKS-Clusters
SERVICE_CIDR Adressbereich für Kubernetes-Dienste. Konfigurieren des AKS-Clusternetzwerkprofils
DNS_SERVICE_IP IP-Adresse für den Kubernetes-DNS-Dienst. Konfigurieren des AKS-Clusternetzwerkprofils

Rufen Sie die AKS-Subnetzressourcen-ID und Adressbereiche ab, bevor Sie die Umgebungsdatei erstellen:

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

AKS- und Unbounded-Net-Adresswerte

Sie verwenden SERVICE_CIDR und DNS_SERVICE_IP, um das Netzwerkprofil des AKS-Clusters zu konfigurieren. Konfigurieren Sie die Knoten- und Pod-CIDRs, um die von dieser Anleitung verwendeten Unbounded-Net-Sites zu konfigurieren.

Die Adressbereiche für AKS-Knoten, AKS-Pods, Flex-Knoten, Flex-Pod und Kubernetes-Dienst müssen dem ausgewählten Netzwerkdesign entsprechen und dürfen sich weder untereinander noch mit Netzwerken überschneiden, die über Peering virtueller Netzwerke, VPN oder ExpressRoute erreichbar sind. Koordinieren Sie die endgültigen Werte mit Ihrem Netzwerkadministrator.

Kopieren Sie keine Beispiel-CIDRs aus einer anderen Bereitstellung. CIDRs identifizieren routbaren Adressraum; daher kann die Wiederverwendung eines Beispiels, das sich mit Ihren Azure- oder verbundenen Netzwerken überschneidet, zu mehrdeutigem Datenverkehr führen oder verhindern, dass Knoten und Pods sich gegenseitig erreichen.

Variable BESCHREIBUNG Verwendet von
AKS_SUBNET_CIDR Adressbereich, der dem Subnetz für Azure verwaltete AKS-Knoten zugewiesen ist. Validierung des virtuellen Azure-Netzwerks und des AKS-Subnetzes
AKS_NODE_CIDR Unbounded-Net-Standort-Knotenbereich, der das AKS-Knotensubnetz enthält. Unbounded-Net primärer Clusterstandort
AKS_POD_CIDR Adresspool für Pods auf von Azure verwalteten AKS-Knoten. Unbounded-Net primärer Clusterstandort
FLEX_HOST_SUBNET_CIDR Adressbereich, der die Hosts der Flex-Knoten enthält. Validierung des Hostnetzwerks des Flex-Node
FLEX_NODE_CIDR Unbounded-Net-Site-Knotenbereich, der das Subnetz des Flex-Knoten-Hosts enthält. Unbounded-Net Site für Flexknoten
FLEX_POD_CIDR Adresspool für Pods auf Flexknoten. Unbounded-Net Site für Flexknoten
SERVICE_CIDR Adressbereich für Kubernetes-Dienste. AKS-Clusternetzwerkprofil
DNS_SERVICE_IP IP-Adresse für den Kubernetes-DNS-Dienst. AKS-Clusternetzwerkprofil

Wenden Sie die folgenden Regeln auf den Adressplan an:

  • AKS_SUBNET_CIDR muss in AKS_NODE_CIDR enthalten sein.
  • FLEX_HOST_SUBNET_CIDR muss in FLEX_NODE_CIDR enthalten sein.
  • DNS_SERVICE_IP muss innen SERVICE_CIDRsein.

Diese acht Werte sind nicht acht separate Bereiche. Fünf sind unabhängige Bereiche, die sich nicht überlappen dürfen, zwei Subnetzbereiche, die innerhalb ihres entsprechenden Standortknotenbereichs enthalten sind, und eine ist eine einzelne IP-Adresse innerhalb des Dienstbereichs.

Die folgenden Werte erfüllen jede Regel in diesem Abschnitt. Betrachten Sie sie als Veranschaulichung der Beziehungen, nicht als Standardwerte. Gleichen Sie Ihre eigenen Werte mit dem Adressraum von Azure und dem des verbundenen Netzwerks ab, bevor Sie sie verwenden.

Variable Example Relationship
AKS_NODE_CIDR 10.10.0.0/16 Unabhängiger Bereich
AKS_SUBNET_CIDR 10.10.1.0/24 Enthalten in AKS_NODE_CIDR
AKS_POD_CIDR 10.244.0.0/16 Unabhängiger Bereich
FLEX_NODE_CIDR 10.20.0.0/16 Unabhängiger Bereich
FLEX_HOST_SUBNET_CIDR 10.20.1.0/24 Enthalten in FLEX_NODE_CIDR
FLEX_POD_CIDR 10.245.0.0/16 Unabhängiger Bereich
SERVICE_CIDR 10.96.0.0/16 Unabhängiger Bereich
DNS_SERVICE_IP 10.96.0.10 Innerhalb von SERVICE_CIDR

Überprüfen Sie die aktuellen Azure virtuellen Netzwerkadressräume:

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

Azure können Konflikte innerhalb der von ihr verwalteten Ressourcen identifizieren, adressbereiche können jedoch nicht in jedem verbundenen lokalen oder externen Netzwerk überprüft werden.

Komponentenversionswerte

Flex-Knoten erfordern kompatible Versionen von AKS, die Azure CLI Erweiterung, Unbounded-Net und den Flex-Knoten-Agent. Verwenden Sie die in diesem Artikel aufgeführten Versionen, und wählen Oder aktualisieren Sie diese Komponenten nicht unabhängig.

Variable BESCHREIBUNG
AKS_VERSION Unterstützte Kubernetes-Version für den AKS-Cluster.
AKS_PREVIEW_VERSION aks-previewAzure CLI Erweiterungsversion 22.0.0b8 oder höher.
UNBOUNDED_VERSION Unterstützte Version von Unbounded-Net.
AKS_FLEX_NODE_VERSION Unterstützte Flexknoten-Agent-Version.

Regionale Verfügbarkeit

Flex-Knoten erfordern AKS-Version v20260904 oder höher in der Region, in der Ihr Cluster gehostet wird. AKS wendet diese datumsbasierten Releases automatisch an, und sie sind getrennt von der Kubernetes-Version, die Sie in AKS_VERSION festgelegt haben.

Öffnen Sie vor dem Erstellen oder Auswählen eines Clusters die Registerkarte "AKS Release " der AKS-Versionsverfolgung, suchen Sie Ihre Region, und überprüfen Sie die Version unter "Derzeit im Betrieb". AKS-Releaseversionen verwenden das Format vYYYYMMDD. Wenn Ihre Region eine frühere Version anzeigt, warten Sie, bis die Version die Region erreicht hat, oder wählen Sie, wenn ihre Bereitstellungsanforderungen zulassen, eine Region aus, in der die erforderliche Version verfügbar ist.

Wert des lokalen Arbeitsbereichs

Variable BESCHREIBUNG
WORK_DIR Verzeichnis in Ihrer Bash-Umgebung, in dem die verbleibenden Artikel Downloads, generierte Dateien und die Cluster kubeconfig-Datei speichern. Der Standardwert ist ~/.local/share/aksflexnode/<deployment-name>. Wenn Sie diese Dateien an einer anderen Stelle beibehalten möchten, z. B. ein temporäres Verzeichnis, das Sie nach der Bereitstellung entfernen, ändern Sie den WORK_DIR Wert in der Umgebungsdatei.

Freigegebene Umgebungsdatei erstellen

Erstellen Sie eine Umgebungsdatei für jede Bereitstellung. Die Datei sorgt dafür, dass die nicht geheimen Werte in den verbleibenden Artikeln und Terminalsitzungen konsistent bleiben.

Speichern Sie keine Zugriffstoken, Bootstrap-Daten, Kubeconfig-Inhalte, Dienstprinzipalanmeldeinformationen, Zertifikate, private Zertifikatschlüssel oder private SSH-Schlüssel in dieser Datei.

  1. Wählen Sie eine kurze Bereitstellungsbezeichnung aus, und erstellen Sie ein geschütztes Verzeichnis für die Umgebungsdatei.

    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. Erstellen Sie die Umgebungsdatei.

    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

    Mit dem set_flexnode_env Hilfsprogramm können spätere Artikel Azure generierten Werte aufzeichnen, ohne der Datei doppelte Definitionen hinzuzufügen.

  3. Öffnen Sie ${FLEXNODE_ENV_FILE} in einem Editor, und ersetzen Sie jeden Wert, der in winkelige Klammern eingeschlossen ist. Lassen Sie die Werte unter Von späteren Artikeln erfasste Werte leer.

  4. Stellen Sie sicher, dass keine Platzhalter mehr vorhanden sind.

    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. Laden Sie die Umgebungsdatei, erstellen Sie das Arbeitsverzeichnis, und legen Sie das aktive Azure-Abonnement fest.

    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

    Vergewissern Sie sich, dass die zurückgegebene Abonnement-ID übereinstimmt SUBSCRIPTION_ID.

    Bestätigen Sie, dass AKS_API_ACCESS einen unterstützten Pfad identifiziert:

    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

    Starten Sie jede neue Terminalsitzung, indem Sie die Bereitstellungsbezeichnung festlegen und ihre Umgebungsdatei laden:

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

Überprüfen der Planungswerte

Überprüfen Sie das ausgewählte AKS-Subnetz.

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

Vergewissern Sie sich, dass die zurückgegebene Ressourcen-ID und der Adressbereich übereinstimmen AKS_SUBNET_ID und AKS_SUBNET_CIDR.

Nächster Schritt

Bereiten Sie als Nächstes einen AKS-Cluster für Flexknoten vor. Der nächste Artikel erstellt den öffentlichen oder privaten AKS-Cluster und zeichnet die Clusterressourcen-ID auf.

  • Zuletzt aktualisiert um