Förbereda en flexnodvärd och -identitet (förhandsversion)

Important

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och frivillig registrering. Förhandsversioner tillhandahålls "i befintligt skick" och "i mån av tillgång," och de är undantagna från servicenivåavtal och begränsad garanti. AKS-förhandsversioner stöds delvis av kundsupport efter bästa förmåga. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

Innan du kopplar en Linux-värd som en flexnod förbereder du värden, konfigurerar den identitet som du valde under planeringen och beviljar identiteten åtkomst till Azure Kubernetes Service (AKS)-klustret.

I den här artikeln kommer du att:

  • Granska värdkraven och etablera eller välj sedan Linux-värden och dess Azure-identitet.
  • Förbered och inspektera värddatorn och registrera de värden som används av anslutningsarbetsflödet.
  • Tilldela identitetsåtkomsten i AKS-klusteromfånget och verifiera den identiteten.

Kör hanteringskommandona i den här artikeln i en Linux-kompatibel Bash-miljö som har de verktyg och nätverksåtkomst som krävs. I den här artikeln kallas den miljön för din Bash-miljö. Den separata dator som ansluter till klustret är flexnodsvärden; kör kommandon där endast när ett steg uttryckligen instruerar dig att göra det.

Innan du börjar

  • Slutför Konfigurera nätverk och skapa en flexnodpool i AKS.
  • Granska identitets- och åtkomstbegrepp för flexnoder och välj ett identitetsalternativ.
  • Använd ett Azure konto som kan inspektera värdresursen och skapa en rolltilldelning i AKS-klusteromfånget. Role Based Access Control Administrator och User Access Administrator är exempel på roller som kan skapa tilldelningen.
  • Installera Azure CLI och en OpenSSH-klient i bash-miljön.
  • Förbered ett SSH-nyckelpar som accepteras av värddatorn.

Läs in driftsättningsmiljön

Starta en ny Bash-session, identifiera miljöfilen från planeringsartikeln och läs in den. Ersätt <deployment-name> med distributionsetiketten.

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

Miljöfilen innehåller de delade distributionsvärden som den här artikeln läser, inklusive WORK_DIRkatalogen i bash-miljön där den här artikeln lagrar nedladdningar och genererade filer. Som standard är WORK_DIR~/.local/share/aksflexnode/<deployment-name>. Artikeln härleder alla andra variabler som den behöver. Om du inte har skapat miljöfilen ännu slutför du Planera distributionen av flexnoder först.

Om filen inte hittas eller inte kan läsas in stoppar du och återgår till planeringsartikeln innan du fortsätter.

Ange den aktiva prenumerationen och bekräfta det valda klustret:

az account set --subscription "${SUBSCRIPTION_ID}"

az aks show \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${CLUSTER_NAME}" \
    --query "{Name:name,ResourceId:id,ProvisioningState:provisioningState}" \
    --output table

Fortsätt när resurs-ID:t matchar AKS_RESOURCE_ID och etableringstillståndet är Succeeded.

1. Granska värdkraven

Använd en dedikerad värd som uppfyller följande krav:

  • En AMD64- eller ARM64-värd som kör Ubuntu 24.04 LTS, Azure Linux 3.x eller Red Hat Enterprise Linux (RHEL) 9 eller 10.
  • Ett unikt värdnamn som är ett giltigt DNS-underdomännamn. Agenten konverterar den till gemener när den registrerar noden.
  • Minst fyra vCPU:er och minst 8 GiB gratis under /var/lib.
  • Ett SSH-konto med root- eller lösenordslös sudo åtkomst till värden.
  • Nätverksåtkomst till AKS API-servern, Azure Resource Manager, Microsoft Entra ID, den valda flexnodutgåvan och artefaktspegeln samt de containerregister som krävs.
  • Befintlig Layer 3-anslutning mellan flexnodens värdnätverk och det AKS-hanterade nodnätverket. Värden och AKS-klustret behöver inte finnas i samma Azure-region.

Din Bash-miljö måste också kunna ansluta till värddatorn för flexnoden via SSH. En offentlig IP-adress krävs inte när du har en annan godkänd hanteringsväg.

2. Etablera eller välj värd och identitet

Slutför endast avsnittet för identitetsalternativet som valts i identitets- och åtkomstbegrepp för flexnoder. Konfigurera inte fler än ett beständigt Azure-identitetsläge för samma värd.

Tip

Vill du ansluta en dator utanför Azure? Använd en Azure Arc hanterad identitet om datorn redan är Arc-aktiverad eller använder tjänstens huvudnamn. Använd endast Azure vm-hanterad identitet när flexnodvärden är en Azure virtuell dator.

Ange de SSH-nyckelsökvägar som används av varje identitetsalternativ:

export SSH_PRIVATE_KEY_PATH="<path-to-private-key>"
export SSH_PUBLIC_KEY_PATH="<path-to-public-key>"

Varje identitetsalternativ upprättar också två värdadresser. FLEX_HOST_SSH_TARGET är adressen som används av bash-miljön. FLEX_HOST_PRIVATE_IP är värdadressen som kan nås från det AKS-hanterade nodnätverket. Bekräfta med nätverksadministratören som FLEX_HOST_PRIVATE_IP tillhör FLEX_HOST_SUBNET_CIDR och är den adress som kan nås från det AKS-hanterade nodnätverket. Använd inte en separat publik adress eller en adress enbart för hantering som adress för flexnoden.

Använda en Azure Arc hanterad identitet

Använd det här alternativet för en värd som redan är ansluten till Azure Arc. Om det behövs följer du Anslut hybriddatorer med Azure Arc-aktiverade servrar.

Ange Arc-resursvärdena och värdadresserna:

export ARC_RESOURCE_GROUP="<arc-machine-resource-group>"
export ARC_MACHINE_NAME="<arc-machine-name>"
export FLEX_HOST_SSH_TARGET="<admin-user>@<reachable-host-address>"
export FLEX_HOST_PRIVATE_IP="<private-ip-reachable-from-aks>"

Hämta resurs-ID, anslutningsstatus och huvudobjekt-ID:

ARC_RESOURCE_ID="/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${ARC_RESOURCE_GROUP}/providers/Microsoft.HybridCompute/machines/${ARC_MACHINE_NAME}"
export ARC_RESOURCE_ID

HOST_PRINCIPAL_OBJECT_ID="$(az resource show \
    --ids "${ARC_RESOURCE_ID}" \
    --query identity.principalId \
    --output tsv)"
export HOST_PRINCIPAL_OBJECT_ID

az resource show \
    --ids "${ARC_RESOURCE_ID}" \
    --query "{Name:name,Status:properties.status,IdentityType:identity.type,PrincipalId:identity.principalId}" \
    --output yaml

Fortsätt när Status är Connected och PrincipalId fylls i.

Kontrollera Connected Machine-agenten och Hybrid Instance Metadata Service på värden:

ssh -i "${SSH_PRIVATE_KEY_PATH}" "${FLEX_HOST_SSH_TARGET}" \
    'sudo azcmagent show && systemctl is-active himdsd'

Bekräfta att azcmagent show rapporterar samma prenumerations-ID, resursgrupp och datornamn som ARC_RESOURCE_ID, ARC_RESOURCE_GROUPoch ARC_MACHINE_NAME. Kontrollera också att himdsd är aktiv. Om resursen inte stämmer, stoppa och korrigera värdena för Arc-resursen innan du tilldelar åtkomst.

Registrera Arc- och identitetsvärdena:

set_flexnode_env ARC_RESOURCE_GROUP "${ARC_RESOURCE_GROUP}"
set_flexnode_env ARC_MACHINE_NAME "${ARC_MACHINE_NAME}"
set_flexnode_env ARC_RESOURCE_ID "${ARC_RESOURCE_ID}"
set_flexnode_env FLEX_HOST_SSH_TARGET "${FLEX_HOST_SSH_TARGET}"
set_flexnode_env FLEX_HOST_PRIVATE_IP "${FLEX_HOST_PRIVATE_IP}"
set_flexnode_env HOST_PRINCIPAL_OBJECT_ID "${HOST_PRINCIPAL_OBJECT_ID}"
set_flexnode_env HOST_IDENTITY_CLIENT_ID ""

Använda tjänstens huvudnamn

Använd det här alternativet för en annan virtuell maskin eller fysisk värd som stöds. Använd hellre certifikatbaserade autentiseringsuppgifter än en långlivad klienthemlighet. Följande steg skapar ett dedikerat program och tjänstens huvudnamn med ett självsignerat certifikat för utvärdering. De skapar inte en klienthemlighet eller tilldelar en Azure roll. Du ger åtkomst till mål-AKS-klustret i steg 4.

Innan du fortsätter:

  • Installera OpenSSL i Bash-miljön och använd en up-to-date Azure CLI som stöder az login --certificate.
  • Logga in med ett konto som kan registrera program och skapa tjänsthuvudnamn i Microsoft Entra-klientorganisationen som är kopplad till målprenumerationen. Enbart ägarskap av en Azure-prenumeration beviljar inte dessa katalogbehörigheter. Om din klientorganisation begränsar programregistreringen ber du klientadministratören om hjälp. Se Skapa ett huvudnamn för Azure-tjänsten med Azure CLI.
  • Bekräfta att din organisation tillåter självsignerade certifikat för utvärdering. För en befintlig godkänd identitet använder du dess klient-ID, programklient-ID, objekt-ID för tjänstens huvudnamn och skyddade PEM-fil och går vidare till Registrera tjänstens huvudnamn och värdvärden.

Lagra inte autentiseringsuppgiften, den privata nyckeln eller sökvägen till autentiseringsuppgiften i den delade miljöfilen. Skriv inte ut PEM-filen eller inkludera den i källkontrollen. PEM-filen innehåller en okrypterad privat nyckel så att agenten kan autentisera utan en interaktiv lösenordsprompt. Skydda den med filbehörigheter och godkända värdåtkomstkontroller.

Skapa ett certifikatbaserat huvudnamn för tjänsten

Kör dessa kommandon i Bash-miljön när du är inloggad med ditt operatörskonto.

  1. Kontrollera prenumerationen, klientorganisationen och det konto du är inloggad med.

    az account set --subscription "${SUBSCRIPTION_ID}"
az account show \
    --query "{SubscriptionId:id,TenantId:tenantId,Account:user.name}" \
    --output table

SP_TENANT_ID="$(az account show --query tenantId --output tsv)"
export SP_TENANT_ID

    Fortsätt endast om prenumerationen och klientorganisationen är de avsedda målen.

  2. Välj ett unikt programvisningsnamn och skapa en skyddad katalog för autentiseringsuppgifter.

    export SP_DISPLAY_NAME="aks-flexnode-${FLEXNODE_DEPLOYMENT}-$(date -u +%Y%m%dT%H%M%SZ)"
install -d -m 0700 "${WORK_DIR:?Load the deployment environment first.}"
SP_CREDENTIAL_DIR="$(mktemp -d "${WORK_DIR}/sp-credential.XXXXXXXX")"
export SP_CREDENTIAL_DIR
export SP_CLIENT_CERTIFICATE_FILE="${SP_CREDENTIAL_DIR:?Credential directory wasn't created.}/sp-client.pem"

  3. Skapa ett 30-dagars certifikat och en kombinerad PEM-fil som innehåller certifikatet och den privata nyckeln.

    (
    set -e
    umask 077

    openssl req -x509 -newkey rsa:2048 -sha256 -days 30 -nodes \
        -keyout "${SP_CREDENTIAL_DIR}/sp-client.key" \
        -out "${SP_CREDENTIAL_DIR}/sp-client.crt" \
        -subj "/CN=${SP_DISPLAY_NAME}"

    cat "${SP_CREDENTIAL_DIR}/sp-client.crt" \
        "${SP_CREDENTIAL_DIR}/sp-client.key" \
        > "${SP_CLIENT_CERTIFICATE_FILE}"
    chmod 0600 "${SP_CLIENT_CERTIFICATE_FILE}"
    rm -f "${SP_CREDENTIAL_DIR}/sp-client.key"
)

openssl x509 \
    -in "${SP_CREDENTIAL_DIR}/sp-client.crt" \
    -noout -subject -dates
stat -c '%a %n' "${SP_CLIENT_CERTIFICATE_FILE}"

    Stoppa om det inte går att skapa certifikatet. Bekräfta att PEM-behörigheterna är 600. 30-dagars giltigheten är för utvärdering, inte en rotationsprincip. Ersätt autentiseringsuppgiften enligt den godkända processen innan den upphör att gälla, om värden fortfarande är ansluten.

  4. Skapa programmet och tjänstens huvudnamn genom att endast ladda upp det offentliga certifikatet.

    SP_CLIENT_ID="$(az ad sp create-for-rbac \
    --name "${SP_DISPLAY_NAME}" \
    --cert "@${SP_CREDENTIAL_DIR}/sp-client.crt" \
    --query appId \
    --output tsv)"
export SP_CLIENT_ID

    Fortsätt endast när kommandot lyckas och returnerar ett programklient-ID. Kommandot kan rapportera att det har justerat slutdatumet för autentiseringsuppgifter så att det matchar certifikatets förfallodatum. Lägg inte till --role eller --scopes; den senare rolltilldelningen är begränsad till AKS-klustret. Kör inte skapande mot ett befintligt program igen för att rotera dess autentiseringsuppgifter.

  5. Hämta objekt-ID:t för tjänstens huvudnamn och kontrollera de registrerade autentiseringsuppgifterna.

    SP_OBJECT_ID="$(az ad sp show \
    --id "${SP_CLIENT_ID}" \
    --query id \
    --output tsv)"
export SP_OBJECT_ID

az ad sp show \
    --id "${SP_CLIENT_ID}" \
    --query "{ClientId:appId,ServicePrincipalObjectId:id}" \
    --output table

az ad app show \
    --id "${SP_CLIENT_ID}" \
    --query "{ClientId:appId,PasswordCredentials:length(passwordCredentials),Certificates:keyCredentials[].{KeyId:keyId,Expires:endDateTime}}" \
    --output json

    Bekräfta att objekt-ID:t för tjänstens huvudnamn är ifyllt, båda klient-ID:na matchar SP_CLIENT_ID, PasswordCredentials är 0och exakt ett certifikat registreras med den förväntade förfallotiden. Om katalogreplikeringen fördröjer sökningen väntar du en kort stund och försöker igen i stället för att skapa ett annat program.

För ett test med endast autentiseringsuppgifter kör du bara kontrollen för certifikatautentisering i Verifiera tjänstens huvudnamn. Du behöver inte tilldela en Azure roll eller förbereda en värd för kontrollen. När testet är klart tar du bort det dedikerade testprogrammet och lokala autentiseringsuppgifter.

Registrera tjänstens huvudnamn och värdvärden

Ange värdadresserna. Om du har valt en befintlig identitet anger du först SP_TENANT_ID, SP_CLIENT_ID och SP_OBJECT_ID till dess identifierare.

export FLEX_HOST_SSH_TARGET="<admin-user>@<reachable-host-address>"
export FLEX_HOST_PRIVATE_IP="<private-ip-reachable-from-aks>"

: "${SP_TENANT_ID:?Set the Microsoft Entra tenant ID.}"
: "${SP_CLIENT_ID:?Set the application client ID.}"
: "${SP_OBJECT_ID:?Set the service principal object ID.}"
export HOST_IDENTITY_CLIENT_ID=""
export HOST_PRINCIPAL_OBJECT_ID="${SP_OBJECT_ID}"

set_flexnode_env FLEX_HOST_SSH_TARGET "${FLEX_HOST_SSH_TARGET}"
set_flexnode_env FLEX_HOST_PRIVATE_IP "${FLEX_HOST_PRIVATE_IP}"
set_flexnode_env SP_TENANT_ID "${SP_TENANT_ID}"
set_flexnode_env SP_CLIENT_ID "${SP_CLIENT_ID}"
set_flexnode_env SP_OBJECT_ID "${SP_OBJECT_ID}"
set_flexnode_env HOST_IDENTITY_CLIENT_ID "${HOST_IDENTITY_CLIENT_ID}"
set_flexnode_env HOST_PRINCIPAL_OBJECT_ID "${HOST_PRINCIPAL_OBJECT_ID}"

SP_OBJECT_ID är objekt-ID för Enterprise-programmet, även kallat objekt-ID för tjänstens huvudnamn. Det är inte objekt-ID för appregistreringen. Bekräfta att SP_CLIENT_ID, SP_OBJECT_IDoch certifikatet tillhör samma tjänsthuvudnamn.

Bootstrap mappar SP_TENANT_ID och SP_CLIENT_ID till azure.servicePrincipal.tenantId och azure.servicePrincipal.clientId i den genererade agentkonfigurationen. SP_OBJECT_IDanvänds för Azure rolltilldelning, inte som agentens klient-ID. För fältet för certifikatfilen, den fullständiga maskerade konfigurationsstrukturen och säkra verifieringskommandon, se Granska den renderade konfigurationen för tjänsthuvudnamnet.

Behåll den skyddade PEM-filen för identitetsverifiering och bootstrap av värden. Gör det tillgängligt på värdsystemet genom er godkända process för hantering av autentiseringsuppgifter innan det ansluts. Registrera dess plats via din godkända autentiseringshanteringsprocess, inte i den delade miljöfilen. Fortsätt med Förbered och granska värden och tilldela sedan AKS-rollen.

Använda en Azure hanterad identitet för virtuell dator

Använd det här alternativet för en Azure virtuell dator. Skapa en virtuell dator genom att följa snabbstarten: Skapa en virtuell Linux-dator med Azure CLI eller välj en befintlig virtuell dator. Placera den virtuella datorn i flexnodens värdnätverk som planeras för den här distributionen. Du behöver ingen offentlig IP-adress när bash-miljön har en annan godkänd SSH-sökväg.

Ange de virtuella datorvärdena:

export VM_RESOURCE_GROUP="<vm-resource-group>"
export VM_NAME="<vm-name>"
export VM_ADMIN_USER="<vm-admin-user>"

Hämta resurs-ID:t för den virtuella datorn och värdadresserna. SSH-målet använder den offentliga IP-adressen när den virtuella datorn har en och den privata adressen annars:

VM_RESOURCE_ID="$(az vm show \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --query id \
    --output tsv)"
export VM_RESOURCE_ID

FLEX_HOST_PRIVATE_IP="$(az vm show \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --show-details \
    --query privateIps \
    --output tsv)"
export FLEX_HOST_PRIVATE_IP

VM_PUBLIC_IP="$(az vm show \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --show-details \
    --query publicIps \
    --output tsv)"
export VM_PUBLIC_IP

export FLEX_HOST_SSH_TARGET="${VM_ADMIN_USER}@${VM_PUBLIC_IP:-${FLEX_HOST_PRIVATE_IP}}"

Bekräfta den privata adress som returneras för den virtuella datorn:

az vm list-ip-addresses \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --query "[0].virtualMachine.{Name:name,PrivateAddresses:network.privateIpAddresses}" \
    --output table

Fortsätt endast när FLEX_HOST_PRIVATE_IP innehåller en enda privat adress som tillhör FLEX_HOST_SUBNET_CIDR och kan nås från det AKS-hanterade nodnätverket. Om Azure returnerar mer än en adress anger du FLEX_HOST_PRIVATE_IP till den planerade flexnodadressen innan du fortsätter.

Om den virtuella datorn inte har någon offentlig IP-adress, eller om din Bash-miljö når värden via en annan godkänd hanteringsväg, anger du FLEX_HOST_SSH_TARGET som den adress eller det värdnamn som du kan nå från din Bash-miljö.

Slutför något av följande alternativ för hanterad identitet.

Systemtilldelad hanterad identitet

Aktivera den systemtilldelade hanterade identiteten:

az vm identity assign \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --output none

Hämta dess huvudobjekt-ID:

HOST_PRINCIPAL_OBJECT_ID="$(az vm show \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --query identity.principalId \
    --output tsv)"
export HOST_PRINCIPAL_OBJECT_ID

export HOST_IDENTITY_CLIENT_ID=""

Användartilldelad hanterad identitet

Skapa eller välj en identitet genom att följa Hantera användartilldelade hanterade identiteter med hjälp av Azure CLI.

Ange identitetsvärdena:

export USER_ASSIGNED_IDENTITY_RESOURCE_GROUP="<identity-resource-group>"
export USER_ASSIGNED_IDENTITY_NAME="<identity-name>"

Hämta identitetsidentifierarna:

USER_ASSIGNED_IDENTITY_RESOURCE_ID="$(az identity show \
    --resource-group "${USER_ASSIGNED_IDENTITY_RESOURCE_GROUP}" \
    --name "${USER_ASSIGNED_IDENTITY_NAME}" \
    --query id \
    --output tsv)"
export USER_ASSIGNED_IDENTITY_RESOURCE_ID

HOST_PRINCIPAL_OBJECT_ID="$(az identity show \
    --resource-group "${USER_ASSIGNED_IDENTITY_RESOURCE_GROUP}" \
    --name "${USER_ASSIGNED_IDENTITY_NAME}" \
    --query principalId \
    --output tsv)"
export HOST_PRINCIPAL_OBJECT_ID

HOST_IDENTITY_CLIENT_ID="$(az identity show \
    --resource-group "${USER_ASSIGNED_IDENTITY_RESOURCE_GROUP}" \
    --name "${USER_ASSIGNED_IDENTITY_NAME}" \
    --query clientId \
    --output tsv)"
export HOST_IDENTITY_CLIENT_ID

Tilldela identiteten till den virtuella datorn:

az vm identity assign \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --identities "${USER_ASSIGNED_IDENTITY_RESOURCE_ID}" \
    --output none

Kontrollera att den virtuella datorn visar den valda identiteten:

az vm identity show \
    --resource-group "${VM_RESOURCE_GROUP}" \
    --name "${VM_NAME}" \
    --query "{Type:type,UserAssignedIdentities:userAssignedIdentities}" \
    --output yaml

Fortsätt när utdata innehåller USER_ASSIGNED_IDENTITY_RESOURCE_ID.

Registrera den virtuella datorns identitet

Registrera den virtuella datorn och identitetsvärdena:

set_flexnode_env VM_RESOURCE_GROUP "${VM_RESOURCE_GROUP}"
set_flexnode_env VM_NAME "${VM_NAME}"
set_flexnode_env VM_ADMIN_USER "${VM_ADMIN_USER}"
set_flexnode_env VM_RESOURCE_ID "${VM_RESOURCE_ID}"
set_flexnode_env VM_PUBLIC_IP "${VM_PUBLIC_IP}"
set_flexnode_env FLEX_HOST_SSH_TARGET "${FLEX_HOST_SSH_TARGET}"
set_flexnode_env FLEX_HOST_PRIVATE_IP "${FLEX_HOST_PRIVATE_IP}"
set_flexnode_env HOST_PRINCIPAL_OBJECT_ID "${HOST_PRINCIPAL_OBJECT_ID}"
set_flexnode_env HOST_IDENTITY_CLIENT_ID "${HOST_IDENTITY_CLIENT_ID}"

3. Förbered och inspektera värddatorn

Anslut till värddatorn:

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

På värddatorn kontrollerar du operativsystemet, arkitekturen, värdnamnet, CPU:n och det tillgängliga lagringsutrymmet:

source /etc/os-release
printf 'Operating system: %s %s\n' "${NAME}" "${VERSION_ID}"
printf 'Architecture: %s\n' "$(uname -m)"
printf 'Host name: %s\n' "$(hostname)"
printf 'vCPUs: %s\n' "$(nproc)"
free -h
df -h /var/lib

Jämför resultaten med värdkraven i steg 1. Lös eventuella skillnader innan du fortsätter.

Bootstrap-skriptet kräver curl, jq och tar på värddatorn och avbryts om någon av dem saknas. Flex Node-agenten installerar de återstående körningspaketen under bootstrap.

Installera någon av dessa tre som avbilden inte redan innehåller:

# Ubuntu
sudo apt-get update && sudo apt-get install -y curl jq tar

# Azure Linux 3
sudo tdnf install -y curl jq tar

Avsluta värdsessionen:

exit

Läs det faktiska Linux-värdnamnet från din Bash-miljö:

FLEX_HOST_NAME="$(ssh \
    -i "${SSH_PRIVATE_KEY_PATH}" \
    "${FLEX_HOST_SSH_TARGET}" \
    hostname)"
export FLEX_HOST_NAME

printf 'Flex host name: %s\n' "${FLEX_HOST_NAME}"

Fortsätt när kommandot returnerar det förväntade värdnamnet.

Hämta AKS API-serverns FQDN och verifiera namnupplösning och HTTPS-anslutning från värddatorn:

AKS_API_FQDN="$(az aks show \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${CLUSTER_NAME}" \
    --query '(privateFqdn || fqdn)' \
    --output tsv)"
export AKS_API_FQDN

ssh -i "${SSH_PRIVATE_KEY_PATH}" "${FLEX_HOST_SSH_TARGET}" \
    "getent hosts '${AKS_API_FQDN}' && \
    timeout 5 bash -c '</dev/tcp/${AKS_API_FQDN}/443'"

Om namnmatchningen eller TCP-anslutningen misslyckas korrigerar du DNS-, routnings- eller nätverkskontroller innan du fortsätter. Ett offentligt AKS-kluster använder sitt offentliga API FQDN. För ett privat AKS-kluster måste Bash-miljön och flexnodens värdnätverk kunna lösa upp och dirigera trafik till det privata API:ets FQDN.

Registrera värdvärdena. Den delade miljöfilen lagrar sökvägar och icke-säkerhetsidentifierare, inte nyckel- eller autentiseringsuppgifter.

set_flexnode_env SSH_PRIVATE_KEY_PATH "${SSH_PRIVATE_KEY_PATH}"
set_flexnode_env SSH_PUBLIC_KEY_PATH "${SSH_PUBLIC_KEY_PATH}"
set_flexnode_env FLEX_HOST_NAME "${FLEX_HOST_NAME}"

4. Tilldela AKS-rollen

Det aktuella förhandsgranskningsarbetsflödet använder Azure Kubernetes Service deltagarrollen i det exakta AKS-klusteromfånget. Alla tre identitetsalternativen använder ett objekt-ID för tjänsthuvudnamnet för Azures rollbaserade åtkomstkontroll. Använd en dedikerad värdidentitet och ta bort den här tilldelningen när du tar bort värden enligt beskrivningen i Hantera och ta bort flexnoder i AKS.

Visa det markerade objekt-ID:t för huvudobjektet:

printf 'Principal object ID: %s\n' "${HOST_PRINCIPAL_OBJECT_ID}"

Fortsätt endast när värdet fylls i och tillhör den valda vm-identiteten, Arc-datorn eller tjänstens huvudnamn.

Kontrollera om tilldelningen redan finns:

az role assignment list \
    --assignee-object-id "${HOST_PRINCIPAL_OBJECT_ID}" \
    --scope "${AKS_RESOURCE_ID}" \
    --fill-principal-name false \
    --query "[?roleDefinitionName=='Azure Kubernetes Service Contributor Role'].{PrincipalId:principalId,Role:roleDefinitionName,Scope:scope}" \
    --output table

Om kommandot inte returnerar någon rad skapar du tilldelningen:

az role assignment create \
    --assignee-object-id "${HOST_PRINCIPAL_OBJECT_ID}" \
    --assignee-principal-type ServicePrincipal \
    --role "Azure Kubernetes Service Contributor Role" \
    --scope "${AKS_RESOURCE_ID}" \
    --output none

Kör listkommandot igen. Fortsätt när huvud-ID:t och omfånget matchar den valda identiteten och AKS_RESOURCE_ID. Det kan ta flera minuter att sprida rolltilldelningen.

5. Verifiera den valda identiteten

Innan du startar värden bekräftar du att den valda identiteten kan autentisera och läsa det exakta AKS-målklustret. Slutför endast avsnittet för ditt identitetsalternativ.

Verifiera en hanterad identitet för Azure Arc

I din Bash-miljö skickar du det icke-hemliga AKS-resurs-ID:t till den Azure Arc-aktiverade servern:

[[ "${AKS_RESOURCE_ID}" == /subscriptions/*/providers/Microsoft.ContainerService/managedClusters/* ]]
printf -v AKS_RESOURCE_ID_QUOTED '%q' "${AKS_RESOURCE_ID}"

ssh -t \
    -i "${SSH_PRIVATE_KEY_PATH}" \
    "${FLEX_HOST_SSH_TARGET}" \
    "export AKS_RESOURCE_ID=${AKS_RESOURCE_ID_QUOTED}; \
    exec bash -l"

På den Azure Arc-aktiverade servern begär du en Azure Resource Manager token från Hybrid Instance Metadata Service (HIMDS) och använder den för att läsa AKS-resursen. För att kunna läsa utmaningstoken krävs rot eller medlemskap i himds gruppen:

TOKEN_URL="${IDENTITY_ENDPOINT:-http://127.0.0.1:40342/metadata/identity/oauth2/token}?api-version=2019-11-01&resource=https%3A%2F%2Fmanagement.azure.com"

CHALLENGE_TOKEN_PATH="$(curl --silent --show-error \
    --dump-header - \
    --output /dev/null \
    --header Metadata:true \
    "${TOKEN_URL}" |
    sed -n 's/^[Ww][Ww][Ww]-[Aa]uthenticate: Basic realm=//p' |
    tr -d '\r')"

test -n "${CHALLENGE_TOKEN_PATH}"
CHALLENGE_TOKEN="$(sudo cat "${CHALLENGE_TOKEN_PATH}")"

TOKEN="$(curl --fail --silent --show-error \
    --header Metadata:true \
    --header "Authorization: Basic ${CHALLENGE_TOKEN}" \
    "${TOKEN_URL}" |
    jq -r '.access_token // empty')"

test -n "${TOKEN}"

AKS_ARM_HTTP="$(curl --silent --show-error \
    --output /dev/null \
    --write-out '%{http_code}' \
    --header "Authorization: Bearer ${TOKEN}" \
    "https://management.azure.com${AKS_RESOURCE_ID}?api-version=2025-07-01")"

unset CHALLENGE_TOKEN TOKEN
printf 'AKS_ARM_HTTP=%s\n' "${AKS_ARM_HTTP}"

Förväntat resultat: AKS_ARM_HTTP=200. Kör exit för att lämna den Azure Arc-aktiverade serversessionen.

Verifiera ett tjänsthuvudkonto

I din Bash-miljö använder du den kombinerade PEM-filen från stegen för att förbereda tjänsthuvudnamnet. Om du har startat en ny session eller valt en befintlig identitet anger du dess skyddade sökväg igen:

export SP_CLIENT_CERTIFICATE_FILE="<protected-path-to-sp-client.pem>"
test -s "${SP_CLIENT_CERTIFICATE_FILE}"

Stoppa om filen inte finns eller är tom. Lägg inte till den här sökvägen i den delade miljöfilen.

Verifiera först certifikatautentiseringen med en isolerad Azure CLI profil. Underskalet tar bort sin temporära cache för token även om ett kommando misslyckas och påverkar inte din vanliga Azure CLI-inloggning.

(
    set -e
    SP_AZURE_CONFIG_DIR="$(mktemp -d)"
    chmod 0700 "${SP_AZURE_CONFIG_DIR}"
    trap 'rm -rf -- "${SP_AZURE_CONFIG_DIR}"' EXIT
    export AZURE_CONFIG_DIR="${SP_AZURE_CONFIG_DIR}"

    az login \
        --service-principal \
        --username "${SP_CLIENT_ID}" \
        --certificate "${SP_CLIENT_CERTIFICATE_FILE}" \
        --tenant "${SP_TENANT_ID}" \
        --allow-no-subscriptions \
        --output none

    az account get-access-token \
        --resource https://management.azure.com/ \
        --query "{Tenant:tenant,ExpiresOn:expiresOn}" \
        --output table
)

Kontrollera att Tenant stämmer överens med SP_TENANT_ID och att tokenen inte har upphört att gälla. Det här kommandot skriver bara ut tenanten och utgångsdatumet, inte åtkomsttoken. --allow-no-subscriptionslåter dig testa autentisering innan du beviljar Azure åtkomst. Lyckad autentisering visar inte behörighet att läsa eller registrera med AKS-klustret.

När AKS-rolltilldelningen i steg 4 har spridits kontrollerar du åtkomsten till det exakta målklustret:

(
    set -e
    SP_AZURE_CONFIG_DIR="$(mktemp -d)"
    chmod 0700 "${SP_AZURE_CONFIG_DIR}"
    trap 'rm -rf -- "${SP_AZURE_CONFIG_DIR}"' EXIT
    export AZURE_CONFIG_DIR="${SP_AZURE_CONFIG_DIR}"

    az login \
        --service-principal \
        --username "${SP_CLIENT_ID}" \
        --certificate "${SP_CLIENT_CERTIFICATE_FILE}" \
        --tenant "${SP_TENANT_ID}" \
        --output none

    az account set --subscription "${SUBSCRIPTION_ID}"

    az aks show \
        --resource-group "${RESOURCE_GROUP}" \
        --name "${CLUSTER_NAME}" \
        --query "{Name:name,ResourceId:id,ProvisioningState:provisioningState}" \
        --output table
)

Fortsätt endast när det returnerade resurs-ID:t matchar AKS_RESOURCE_ID och etableringstillståndet är Succeeded. Om autentiseringen lyckas men klusterbegäran nekas kontrollerar du objekt-ID:t för tjänstens huvudnamn, exakt rolltilldelningsomfång och spridning innan du försöker igen. Den här kontrollen visar att tjänstens huvudnamn och dess certifikat kan läsa målklustret. Värden använder den förberedda autentiseringsuppgiften i Koppla en flexnod till ett AKS-kluster.

Verifiera en hanterad identitet för en Azure virtuell dator

I din Bash-miljö skickar du det icke-hemliga AKS-resurs-ID:t och identitetens klient-ID till Azure-VM:n:

[[ "${AKS_RESOURCE_ID}" == /subscriptions/*/providers/Microsoft.ContainerService/managedClusters/* ]]
printf -v AKS_RESOURCE_ID_QUOTED '%q' "${AKS_RESOURCE_ID}"
printf -v HOST_IDENTITY_CLIENT_ID_QUOTED '%q' "${HOST_IDENTITY_CLIENT_ID}"

ssh -t \
    -i "${SSH_PRIVATE_KEY_PATH}" \
    "${FLEX_HOST_SSH_TARGET}" \
    "export AKS_RESOURCE_ID=${AKS_RESOURCE_ID_QUOTED}; \
    export HOST_IDENTITY_CLIENT_ID=${HOST_IDENTITY_CLIENT_ID_QUOTED}; \
    exec bash -l"

På den Azure virtuella datorn begär du en Azure Resource Manager token från den valda hanterade identiteten och använder den för att läsa AKS-resursen:

TOKEN_URL="http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fmanagement.azure.com%2F"

if [ -n "${HOST_IDENTITY_CLIENT_ID}" ]; then
    ENCODED_CLIENT_ID="$(jq -rn \
        --arg value "${HOST_IDENTITY_CLIENT_ID}" \
        '$value|@uri')"
    TOKEN_URL="${TOKEN_URL}&client_id=${ENCODED_CLIENT_ID}"
fi

TOKEN="$(curl --fail --silent --show-error \
    --header Metadata:true \
    "${TOKEN_URL}" |
    jq -r '.access_token // empty')"

test -n "${TOKEN}"

AKS_ARM_HTTP="$(curl --silent --show-error \
    --output /dev/null \
    --write-out '%{http_code}' \
    --header "Authorization: Bearer ${TOKEN}" \
    "https://management.azure.com${AKS_RESOURCE_ID}?api-version=2025-07-01")"

unset TOKEN
printf 'AKS_ARM_HTTP=%s\n' "${AKS_ARM_HTTP}"

Förväntat resultat: AKS_ARM_HTTP=200. För en användartilldelad identitet använder begäran samma HOST_IDENTITY_CLIENT_ID som arbetsflödet för bilagan skickar till --msi-client-id. Kör exit för att lämna Azure VM-session.

Anslutningsarbetsflödet utför den slutliga heltäckande kontrollen när värddatorn använder den valda identiteten för att registrera sin Azure Machine-resurs.

Nästa steg

Anslut och verifiera sedan den förberedda värddatorn som flexnod.

  • Uppdaterades senast