Příprava hostitele a identity flexibilního uzlu (Preview)

Important

Funkce AKS ve verzi Preview jsou k dispozici na bázi samoobsluhy a dobrovolného přihlášení. Ukázky jsou poskytovány "tak, jak jsou" a "dle dostupnosti" a jsou vyloučeny ze smluv o úrovni služeb a z omezené záruky. Předběžné verze AKS jsou částečně pokryty zákaznickou podporou podle možností. Proto tyto funkce nejsou určené pro produkční použití. Další informace najdete v následujících článcích podpory:

• Zásady podpory AKS
• Nejčastější dotazy ohledně podpory Azure

Před připojením hostitele s Linuxem jako flexibilního uzlu připravte hostitele, nakonfigurujte identitu, kterou jste vybrali při plánování, a udělte této identitě přístup ke clusteru Azure Kubernetes Service (AKS).

V tomto článku se dozvíte:

• Zkontrolujte požadavky na hostitele a pak zřiďte nebo vyberte hostitele s Linuxem a jeho Azure identitu.
• Připravte a zkontrolujte hostitelský systém a zaznamenejte hodnoty používané pracovním postupem připojení.
• Přiřaďte identitě přístup v rámci oboru clusteru AKS a ověřte tuto identitu.

Příkazy pro správu v tomto článku spusťte v prostředí Bash kompatibilním s Linuxem, které má požadované nástroje a síťový přístup. Tento článek označuje toto prostředí jako prostředí Bash. Samostatný počítač, který se připojuje ke clusteru, je hostitel uzlu Flex; příkazy tam spouštějte jen tehdy, když vás k tomu některý krok výslovně vyzve.

Než začnete

• Dokončete konfiguraci sítě a vytvořte fond flexibilních uzlů v AKS.
• Projděte si koncepty identit a přístupu pro flexibilní uzly a vyberte jednu možnost identity.
• Použijte účet Azure, který má oprávnění zkoumat hostitelský prostředek a vytvořit přiřazení role v rozsahu clusteru AKS. Role Based Access Control Administrator a User Access Administrator jsou příklady rolí, které mohou vytvořit toto přiřazení.
• Nainstalujte Azure CLI a klienta OpenSSH v prostředí Bash.
• Připravte pár klíčů SSH přijatý hostitelem.

Načtení prostředí nasazení

Spusťte novou relaci Bash, identifikujte soubor prostředí z článku o plánování a načtěte jej. Nahraďte <deployment-name> popiskem nasazení.

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

Soubor prostředí poskytuje sdílené hodnoty nasazení, které tento článek přečte, včetně WORK_DIRadresáře ve vašem prostředí Bash, kde tento článek ukládá soubory ke stažení a vygenerování. Ve výchozím nastavení je WORK_DIR~/.local/share/aksflexnode/<deployment-name>. Článek odvozuje všechny další proměnné, které potřebuje. Pokud jste soubor prostředí ještě nevytvořili, nejprve naplánujte nasazení flexibilních uzlů .

Pokud soubor nenajdete nebo ho nemůžete načíst, zastavte a vraťte se do článku plánování, než budete pokračovat.

Nastavte aktivní předplatné a potvrďte vybraný cluster:

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

Pokračujte, pokud se ID prostředku shoduje s AKS_RESOURCE_ID a stav zřizování je Succeeded.

1. Kontrola požadavků na hostitele

Použijte vyhrazeného hostitele, který splňuje následující požadavky:

• Hostitel AMD64 nebo ARM64 se systémem Ubuntu 24.04 LTS, Azure Linux 3.x nebo Red Hat Enterprise Linux (RHEL) 9 nebo 10.
• Jedinečný název hostitele, který je platným názvem subdomény DNS. Agent ho při registraci uzlu převede na malá písmena.
• Alespoň čtyři vCPU a alespoň 8 GiB volných v části /var/lib.
• Účet SSH s root přístupem nebo s přístupem přes sudo bez hesla na hostiteli.
• Síťový přístup k serveru AKS API, ke službě Azure Resource Manager, k Microsoft Entra ID, k vybrané verzi flexibilního uzlu a zrcadlu artefaktů a k požadovaným registrům kontejnerů.
• Stávající připojení vrstvy 3 mezi hostitelskou sítí flexibilního uzlu a sítí uzlů spravovaných službou AKS Hostitel a cluster AKS nemusí být ve stejné Azure oblasti.

Prostředí Bash musí být také schopné připojit se k hostiteli flexibilního uzlu přes SSH. Pokud máte jinou schválenou cestu správy, veřejná IP adresa se nevyžaduje.

2. Zřízení nebo výběr hostitele a identity

Vyplňte pouze část pro možnost identity vybranou v konceptech Identita a přístup pro flexibilní uzly. Nekonfigurujte více než jeden trvalý režim Azure identity pro stejného hostitele.

Tip

Připojujete počítač mimo Azure? Použijte spravovanou identitu Azure Arc, pokud je počítač už připojený ke službě Arc, nebo použijte instanční objekt. Spravovanou identitu virtuálního počítače Azure používejte pouze v případech, kdy je hostitelem flexibilního uzlu Azure virtuální počítač.

Nastavte cesty klíčů SSH používané každou možností identity:

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

Každá možnost identity také vytvoří dvě adresy hostitele. FLEX_HOST_SSH_TARGET je adresa používaná vaším prostředím Bash. FLEX_HOST_PRIVATE_IP je adresa hostitele dostupná ze sítě uzlů spravované službou AKS. Ověřte u správce sítě, že FLEX_HOST_PRIVATE_IP patří do FLEX_HOST_SUBNET_CIDR a že jde o adresu dostupnou ze sítě uzlů spravované službou AKS. Jako adresu flexibilního uzlu nepoužívejte samostatnou veřejnou adresu ani adresu jen pro správu.

Použijte spravovanou identitu Azure Arc

Tuto možnost použijte pro hostitele, který už je připojený k Azure Arc. V případě potřeby postupujte podle pokynů pro připojení hybridních počítačů s Azure Arc servery.

Nastavte hodnoty prostředků Arc a adresy hostitele:

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

Získejte ID prostředku, stav připojení a ID objektu zabezpečení:

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

Pokračujte, pokud je Connected a PrincipalId je vyplněno.

Ověřte na hostiteli agenta Connected Machine a službu metadat hybridní instance:

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

Ověřte, že azcmagent show uvádí stejné ID předplatného, stejnou skupinu prostředků a stejný název počítače jako u ARC_RESOURCE_ID, ARC_RESOURCE_GROUP a ARC_MACHINE_NAME. Ověřte také, že himdsd je aktivní. Pokud prostředek neodpovídá, nepokračujte a před přiřazením přístupu opravte hodnoty prostředku Arc.

Poznamenejte si hodnoty Arc a identity:

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

Použijte služebního hlavního prvku

Tuto možnost použijte pro jiný podporovaný virtuální počítač nebo fyzického hostitele. Upřednostněte přihlašovací údaje certifikátu před dlouhodobým tajným kódem klienta. Následující kroky vytvoří vyhrazenou aplikaci a instanční objekt služby s certifikátem podepsaným svým držitelem pro účely vyhodnocení. Nevytvoří tajný klíč klienta ani nepřiřazují Azure roli. V kroku 4 udělíte přístup k cílovému clusteru AKS.

Než budete pokračovat:

• Nainstalujte OpenSSL do prostředí Bash a použijte up-to-date Azure CLI, který podporuje az login --certificate.
• Přihlaste se pomocí účtu, který může registrovat aplikace a vytvářet instanční objekty v tenantu Microsoft Entra přidruženému k cílovému předplatnému. Samotné vlastnictví předplatného Azure tato oprávnění k adresáři samo neuděluje. Pokud váš tenant omezuje registraci aplikace, požádejte o pomoc správce tenanta. Viz Vytvoření instančního objektu služby Azure pomocí Azure CLI.
• Ověřte, že vaše organizace povoluje certifikáty podepsané svým držitelem k vyhodnocení. Pro existující schválenou identitu použijte id tenanta, ID klienta aplikace, ID instančního objektu a chráněný soubor PEM a přeskočte k záznamu hodnot instančního objektu a hostitele.

Neukládejte přihlašovací údaje, privátní klíč ani cestu k přihlašovacím údajům do souboru sdíleného prostředí. Netiskněte soubor PEM ani ho nezahrňte do správy zdrojového kódu. Soubor PEM obsahuje nešifrovaný privátní klíč, aby se agent mohl ověřit bez interaktivní výzvy k zadání hesla. Chraňte jej pomocí oprávnění k souborům a schválených mechanismů řízení přístupu k hostiteli.

Vytvořte instanční objekt služby pomocí certifikátu

Tyto příkazy spusťte v prostředí Bash při přihlášení pomocí účtu operátora.

1. Potvrďte předplatné, tenanta a přihlášený účet.

   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
   

   Pokračujte pouze tehdy, pokud jsou předplatné a tenant zamýšlenými cíli.

2. Zvolte jedinečný zobrazovaný název aplikace a vytvořte chráněný adresář přihlašovacích údajů.

   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. Vytvořte 30denní certifikát a kombinovaný soubor PEM, který obsahuje certifikát a privátní klíč.

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

   Zastavte, pokud se vytvoření certifikátu nezdaří. Ověřte, že oprávnění PEM jsou 600. Platnost 30 dnů je určená pro vyhodnocení, ne pro zásady obměně. Pokud hostitel zůstane připojený, nahraďte přihlašovací údaje schváleným procesem před vypršením jeho platnosti.

4. Vytvořte aplikaci a instanční objekt služby nahráním pouze veřejného certifikátu.

   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
   

   Pokračujte pouze v případech, kdy příkaz proběhne úspěšně a vrátí ID klienta aplikace. Příkaz může nahlásit, že upravil koncové datum přihlašovacích údajů tak, aby odpovídalo vypršení platnosti certifikátu. Nepřidávejte --role nebo --scopes; pozdější přiřazení role je omezené na cluster AKS. Nespouštějte znovu proces vytváření u existující aplikace kvůli obměně jejích přihlašovacích údajů.

5. Získejte ID instančního objektu služby a zkontrolujte zaregistrované přihlašovací údaje.

   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
   

   Ověřte, že je vyplněné ID instančního objektu služby, obě ID klienta se shodují s SP_CLIENT_ID, PasswordCredentials jsou 0 a že je zaregistrovaný právě jeden certifikát s očekávaným datem vypršení platnosti. Pokud replikace adresářů zpožďuje vyhledávání, chvíli počkejte a zkuste vyhledávání zopakovat místo vytvoření jiné aplikace.

V případě testu pouze s přihlašovacími údaji spusťte v Ověření instančního objektu služby pouze kontrolu ověřování pomocí certifikátu. Nemusíte přiřazovat Azure roli ani připravit hostitele na tuto kontrolu. Po dokončení testu odstraňte vyhrazenou testovací aplikaci a místní přihlašovací údaje.

Poznamenejte si hodnoty instančního objektu služby a hostitele.

Nastavte adresy hostitele. Pokud jste vybrali existující identitu, nejprve nastavte SP_TENANT_IDSP_CLIENT_IDa SP_OBJECT_ID na její identifikátory.

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 je ID objektu podnikové aplikace, označované také jako ID instančního objektu. Nejedná se o ID objektu registrace aplikace. Potvrďte, že SP_CLIENT_IDa SP_OBJECT_IDcertifikát patří do stejného instančního objektu.

Bootstrap mapuje SP_TENANT_ID a SP_CLIENT_ID na azure.servicePrincipal.tenantId a azure.servicePrincipal.clientId ve vygenerované konfiguraci agenta. SP_OBJECT_IDse používá pro přiřazení role Azure, ne jako ID klienta agenta. Informace o poli `certificate-file`, úplné podobě konfigurace se skrytými citlivými údaji a bezpečných ověřovacích příkazech najdete v části Kontrola vykreslené konfigurace instančního objektu.

Zachovejte chráněný soubor PEM pro ověření identity a počáteční inicializaci hostitele. Zpřístupněte jej na hostiteli prostřednictvím svého schváleného postupu pro správu přihlašovacích údajů před připojením. Zaznamenejte jeho umístění prostřednictvím schváleného procesu správy přihlašovacích údajů, ne ve sdíleném souboru prostředí. Pokračujte v části Příprava a zkontrolujte hostitele a pak přiřaďte roli AKS.

Použití spravované identity virtuálního počítače Azure

Tuto možnost použijte pro virtuální počítač Azure. Vytvořte virtuální počítač pomocí následujícího rychlého startu: Vytvořte virtuální počítač s Linuxem pomocí Azure CLI nebo vyberte existující virtuální počítač. Umístěte virtuální počítač do hostitelské sítě flex node plánované pro toto nasazení. Pokud má vaše prostředí Bash jinou schválenou cestu SSH, nepotřebujete veřejnou IP adresu.

Nastavte hodnoty virtuálního počítače:

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

Získejte ID prostředku virtuálního počítače a adresy hostitele. Cíl SSH používá veřejnou IP adresu, pokud má virtuální počítač jednu, a privátní adresu v opačném případě:

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

Potvrďte privátní adresu vrácenou pro virtuální počítač:

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

Pokračujte pouze tehdy, když FLEX_HOST_PRIVATE_IP obsahuje jednu privátní adresu, která patří k FLEX_HOST_SUBNET_CIDR a je dostupná ze sítě uzlů spravovaných službou AKS. Pokud Azure vrátí více než jednu adresu, nastavte FLEX_HOST_PRIVATE_IP před pokračováním plánovanou adresu uzlu flex.

Pokud virtuální počítač nemá žádnou veřejnou IP adresu nebo vaše prostředí Bash dosáhne hostitele přes jinou schválenou cestu správy, nastavte FLEX_HOST_SSH_TARGET adresu nebo název hostitele, ke kterému se vaše prostředí Bash může dostat.

Vyplňte jednu z následujících možností spravované identity.

Spravovaná identita přiřazená systémem

Povolte spravovanou identitu přiřazenou systémem:

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

Načtěte ID hlavního objektu:

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

Spravovaná identita přiřazená uživatelem

Vytvořte nebo vyberte identitu podle pokynů ke správě spravovaných identit přiřazených uživatelem pomocí Azure CLI.

Nastavte hodnoty identity:

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

Načtení identifikátorů identity:

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

Přiřaďte identitu k virtuálnímu počítači:

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

Ověřte, že virtuální počítač obsahuje vybranou identitu:

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

Pokračujte, až výstup zahrne USER_ASSIGNED_IDENTITY_RESOURCE_ID.

Záznam identity virtuálního počítače

Poznamenejte si hodnoty virtuálního počítače a identity:

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. Příprava a kontrola hostitele

Připojte se k hostiteli:

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

Na hostiteli zkontrolujte operační systém, architekturu, název hostitele, procesor a dostupné úložiště:

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

Porovnejte výsledky s požadavky na hostitele v kroku 1. Před pokračováním vyřešte všechny rozdíly.

Spouštěcí skript vyžaduje v hostitelském systému curl, jq a tar a ukončí se, pokud některá z nich chybí. Agent uzlu Flex nainstaluje zbývající balíčky běhového prostředí při bootstrapu.

Nainstalujte některou z těchto tří, které image ještě neobsahuje:

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

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

Ukončete relaci hostitele:

exit

Přečtěte si skutečný název hostitele Linuxu z prostředí Bash:

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

Pokračujte, až příkaz vrátí očekávaný název hostitele.

Získejte FQDN serveru rozhraní API AKS a ověřte překlad názvů v DNS a připojení HTTPS z hostitele:

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

Pokud překlad jmen nebo připojení TCP selže, opravte DNS, směrování nebo síťové prvky, než budete pokračovat. Veřejný cluster AKS používá své veřejné rozhraní API FQDN. V případě privátního clusteru AKS musí být vaše prostředí Bash a hostitelská síť uzlů Flex schopny přeložit název a směrovat provoz na privátní FQDN rozhraní API.

Poznamenejte si hodnoty hostitele. Soubor sdíleného prostředí ukládá cesty a nesekretní identifikátory, nikoli obsah klíčů nebo přihlašovacích údajů.

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. Přiřazení role AKS

Aktuální pracovní postup ve verzi Preview používá roli přispěvatele Azure Kubernetes Service v přesném rozsahu clusteru AKS. Všechny tři možnosti identit používají ID instančního objektu služby pro řízení přístupu v Azure na základě role. Použijte vyhrazenou identitu hostitele a toto přiřazení odeberte, když odeberete hostitele, jak je popsáno v tématu Správa a odebírání flexibilních uzlů v AKS.

Zobrazit ID vybraného objektu zabezpečení:

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

Pokračujte pouze tehdy, když je hodnota vyplněna a patří k vybrané identitě virtuálního počítače, počítači Arc nebo instančnímu objektu služby.

Zkontrolujte, jestli přiřazení již existuje:

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

Pokud příkaz nevrátí žádný řádek, vytvořte přiřazení:

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

Spusťte příkaz list znovu. Pokračujte, pokud ID objektu zabezpečení a rozsah odpovídají vybrané identitě a AKS_RESOURCE_ID. Šíření přiřazení rolí může trvat několik minut.

5. Ověření vybrané identity

Před inicializací hostitele ověřte, že se vybraná identita dokáže autentizovat vůči danému cílovému clusteru AKS a má k němu přístup pro čtení. Vyplňte pouze oddíl odpovídající vaší možnosti ověření identity.

Ověřte spravovanou identitu Azure Arc

V prostředí Bash předejte serveru s podporou Azure Arc necitlivé ID prostředku služby AKS:

[[ "${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"

Na serveru s povoleným Azure Arc si vyžádejte token Azure Resource Manager ze služby metadat hybridních instancí (HIMDS) a použijte ho k načtení prostředku AKS. Čtení tokenu výzvy vyžaduje oprávnění uživatele root nebo členství ve skupině himds:

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

Očekávaný výstup: AKS_ARM_HTTP=200. Spuštěním příkazu exit ukončíte relaci serveru s podporou Azure Arc.

Ověřit instanční objekt služby

V prostředí Bash použijte kombinovaný soubor PEM z kroků přípravy instančního objektu. Pokud jste spustili novou relaci nebo vybrali existující identitu, nastavte její chráněnou cestu znovu:

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

Zastavte, pokud soubor neexistuje nebo je prázdný. Nepřidávejte tuto cestu do souboru sdíleného prostředí.

Nejprve ověřte ověřování certifikátu pomocí izolovaného profilu Azure CLI. Vnořený shell odstraní svou dočasnou mezipaměť tokenů, i když příkaz selže, a nezmění vaše běžné přihlášení k Azure CLI.

(
    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
)

Ověřte, že tenant odpovídá SP_TENANT_ID a že platnost tokenu nevypršela. Tento příkaz vypíše pouze tenanta a vypršení platnosti, nikoli přístupový token. --allow-no-subscriptionsumožňuje otestovat ověřování před udělením přístupu Azure. Úspěšné ověřování neprokazuje oprávnění ke čtení nebo registraci v clusteru AKS.

Po rozšíření přiřazení role AKS v kroku 4 ověřte přístup k přesnému cílovému clusteru:

(
    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
)

Pokračujte pouze tehdy, když se vrácené ID prostředku shoduje s AKS_RESOURCE_ID a stav zřizování je Succeeded. Pokud ověřování proběhne úspěšně, ale požadavek na cluster bude zamítnut, před opakováním ověřte ID objektu instančního objektu služby, přesný rozsah přiřazení role a propagaci. Tato kontrola ověří, že instanční objekt služby a jeho certifikát mají oprávnění ke čtení cílového clusteru. Hostitel používá připravené přihlašovací údaje v připojení flexibilního uzlu ke clusteru AKS.

Ověření spravované identity virtuálního počítače Azure

V prostředí Bash předejte virtuálnímu počítači Azure neutajené ID prostředku AKS a ID klienta identity:

[[ "${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"

Na virtuálním počítači Azure požádejte o token Azure Resource Manager z vybrané spravované identity a použijte ho ke čtení prostředku AKS:

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

Očekávaný výstup: AKS_ARM_HTTP=200. V případě uživatelem přiřazené identity požadavek používá stejný HOST_IDENTITY_CLIENT_ID, který pracovní postup přílohy předává do --msi-client-id. Spusťte exit, chcete-li opustit relaci virtuálního počítače Azure.

Pracovní postup připojení provede závěrečnou komplexní kontrolu celého procesu, když hostitel použije vybranou identitu k registraci svého prostředku Azure Machine.

Další krok

Dále připojte a ověřte připravený hostitelský server jako uzel Flex.