Een flexknooppunthost en -identiteit voorbereiden (preview)

Important

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals het is' en 'voor zover beschikbaar' en zijn uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning naar best vermogen. Zodoende zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

Voordat u een Linux-host als flexknooppunt koppelt, bereidt u de host voor, configureert u de identiteit die u tijdens de planning hebt geselecteerd en verleent u die identiteit toegang tot het Azure Kubernetes Service (AKS)-cluster.

In dit artikel leert u het volgende:

  • Controleer de hostvereisten en richt of selecteer vervolgens de Linux-host en de bijbehorende Azure identiteit.
  • Bereid en inspecteer de host en noteer de waarden die worden gebruikt door de werkstroom voor bijlagen.
  • Wijs de identiteitstoegang toe op het AKS-clusterbereik en controleer die identiteit.

Voer de beheeropdrachten in dit artikel uit in een linux-compatibele Bash-omgeving met de vereiste hulpprogramma's en netwerktoegang. In dit artikel wordt die omgeving uw Bash-omgeving genoemd. De afzonderlijke computer die aan het cluster wordt toegevoegd, is de flexknooppunthost; voer daar alleen opdrachten uit wanneer een stap u expliciet naartoe leidt.

Voordat u begint

De implementatieomgeving laden

Start een nieuwe Bash-sessie, identificeer het omgevingsbestand uit het planningsartikel en laad het. Vervang <deployment-name> door uw implementatielabel.

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

Het omgevingsbestand levert de gedeelde implementatiewaarden die in dit artikel worden gelezen, inclusief WORK_DIRde map in uw Bash-omgeving waarin in dit artikel bestanden worden gedownload en gegenereerd. Standaard is WORK_DIR~/.local/share/aksflexnode/<deployment-name>. In het artikel worden eventuele andere variabelen afgeleid die nodig zijn. Als u het omgevingsbestand nog niet hebt gemaakt, rond dan eerst de implementatie van uw flexknooppunten plannen af.

Als het bestand niet is gevonden of niet kan worden geladen, stopt u en keert u terug naar het planningsartikel voordat u doorgaat.

Stel het actieve abonnement in en bevestig het geselecteerde 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

Ga door wanneer de resource-id overeenkomt met AKS_RESOURCE_ID en de inrichtingsstatus Succeeded is.

1. Controleer de hostvereisten

Gebruik een toegewezen host die voldoet aan de volgende vereisten:

  • Een AMD64- of ARM64-host met Ubuntu 24.04 LTS, Azure Linux 3.x of Red Hat Enterprise Linux (RHEL) 9 of 10.
  • Een unieke hostnaam die een geldige DNS-subdomeinnaam is. De agent converteert deze naar kleine letters wanneer het knooppunt wordt geregistreerd.
  • Ten minste vier vCPU's en ten minste 8 GiB gratis onder /var/lib.
  • Een SSH-account met root- of wachtwoordloze sudotoegang op de host.
  • Netwerktoegang tot de AKS-API-server, Azure Resource Manager, Microsoft Entra ID, de geselecteerde flexknooppuntrelease en artefactspiegel en de vereiste containerregisters.
  • Bestaande laag 3-connectiviteit tussen het flexknooppunthostnetwerk en het door AKS beheerde knooppuntnetwerk. Het host- en AKS-cluster hoeven zich niet in dezelfde Azure regio te bevinden.

Uw Bash-omgeving moet ook via SSH verbinding kunnen maken met de flexknooppunthost. Een openbaar IP-adres is niet vereist wanneer u een ander goedgekeurd beheerpad hebt.

2. De host en identiteit inrichten of selecteren

Voltooi alleen de sectie voor de identiteitsoptie die is geselecteerd in Identiteits- en toegangsconcepten voor flexknooppunten. Configureer niet meer dan één duurzame Azure identiteitsmodus voor dezelfde host.

Tip

Een computer buiten Azure verbinden? Gebruik een Azure Arc beheerde identiteit als de machine al is ingeschakeld voor Arc of gebruik een service-principal. Gebruik Azure beheerde identiteit alleen als de flexknooppunthost een Azure VM is.

Stel de SSH-sleutelpaden in die door elke identiteitsoptie worden gebruikt:

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

Elke identiteitsoptie brengt ook twee hostadressen tot stand. FLEX_HOST_SSH_TARGET is het adres dat wordt gebruikt door uw Bash-omgeving. FLEX_HOST_PRIVATE_IP is het hostadres dat bereikbaar is vanaf het door AKS beheerde knooppuntnetwerk. Bevestig bij uw netwerkbeheerder dat FLEX_HOST_SUBNET_CIDR tot FLEX_HOST_PRIVATE_IP behoort en het adres is dat bereikbaar is vanaf het door AKS beheerde knooppuntnetwerk. Gebruik geen afzonderlijk openbaar adres of alleen-beheeradres als het adres van het flexknooppunt.

Een Azure Arc beheerde identiteit gebruiken

Gebruik deze optie voor een host die al is verbonden met Azure Arc. Volg indien nodig Hybride machines verbinden met servers met Azure Arc ingeschakeld.

Stel de Arc-resourcewaarden en de hostadressen in:

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

Haal de resource-id, verbindingsstatus en principal-object-id op:

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

Ga door wanneer StatusConnected is en PrincipalId is ingevuld.

Controleer de Connected Machine Agent en Hybrid Instance Metadata Service op de host:

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

Bevestig dat azcmagent show dezelfde abonnements-id, resourcegroep en machinenaam rapporteert als ARC_RESOURCE_ID, ARC_RESOURCE_GROUP en ARC_MACHINE_NAME. Controleer ook of dit himdsd actief is. Als de resource niet overeenkomt, stopt en corrigeert u de Arc-resourcewaarden voordat u toegang toewijst.

Noteer de arc- en identiteitswaarden:

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

Een service-principal gebruiken

Gebruik deze optie voor een andere ondersteunde virtuele machine of bare-metal-host. Geef de voorkeur aan een certificaat boven een langlevend clientgeheim. Met de volgende stappen maakt u een toegewezen toepassing en service-principal met een zelfondertekend certificaat voor evaluatie. Ze maken geen clientgeheim of wijzen een Azure rol toe. U verleent in stap 4 toegang tot het doel-AKS-cluster.

Voordat u doorgaat:

  • Installeer OpenSSL in uw Bash-omgeving en gebruik een up-to-date Azure CLI die ondersteuning biedtaz login --certificate.
  • Meld u aan met een account waarmee toepassingen kunnen worden geregistreerd en service-principals kunnen worden gemaakt in de Microsoft Entra tenant die is gekoppeld aan het doelabonnement. Het eigendom van een Azure-abonnement alleen verleent deze mapmachtigingen niet. Als uw tenant de registratie van toepassingen beperkt, vraagt u de tenantbeheerder om hulp. Zie Een Azure-service-principal maken met de Azure CLI.
  • Controleer of uw organisatie zelfondertekende certificaten toestaat voor evaluatie. Voor een bestaande goedgekeurde identiteit gebruikt u de tenant-id, de client-id van de toepassing, de object-id van de service-principal en het beveiligde PEM-bestand en gaat u verder met het vastleggen van de service-principal- en hostwaarden.

Sla de inloggegevens, de privésleutel of het pad naar de inloggegevens niet op in het gedeelde omgevingsbestand. Druk het PEM-bestand niet af of neem het op in broncodebeheer. Het PEM-bestand bevat een niet-versleutelde persoonlijke sleutel, zodat de agent kan verifiëren zonder een interactieve wachtwoordprompt. Beveilig het met bestandsrechten en goedgekeurde toegangscontroles voor hosts.

Een service-principal op basis van certificaten maken

Voer deze opdrachten uit in uw Bash-omgeving terwijl u bent aangemeld met uw operatoraccount.

  1. Bevestig het abonnement, de tenant en het aangemelde account.

    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

    Ga alleen door wanneer het abonnement en de tenant de beoogde doelen zijn.

  2. Kies een unieke weergavenaam voor de toepassing en maak een beveiligde map voor inloggegevens.

    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. Maak een certificaat van 30 dagen en een gecombineerd PEM-bestand dat het certificaat en de persoonlijke sleutel bevat.

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

    Stop als het maken van een certificaat mislukt. Controleer of de PEM-machtigingen zijn 600. De geldigheidsduur van 30 dagen is voor evaluatie, geen rotatiebeleid. Vervang de inloggegevens via uw goedgekeurde procedure voordat ze verlopen als de host gekoppeld blijft.

  4. Maak de toepassing en service-principal door alleen het openbare certificaat te uploaden.

    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

    Ga alleen door wanneer de opdracht slaagt en retourneert een client-id van een toepassing. De opdracht kan melden dat deze de einddatum van het aanmeldingsgegeven heeft aangepast zodat deze overeenkomt met de vervaldatum van het certificaat. Voeg --role of --scopes niet toe; de daaropvolgende roltoewijzing is beperkt tot het AKS-cluster. Voer het maken van een bestaande toepassing niet opnieuw uit om de aanmeldingsgegevens ervan te vernieuwen.

  5. Haal de object-ID van de service-principal op en controleer de geregistreerde referenties.

    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

    Controleer of de object-id van de service-principal is ingevuld. Beide client-id's komen overeen SP_CLIENT_ID, PasswordCredentials zijn 0en precies één certificaat is geregistreerd bij de verwachte vervaldatum. Als directoryreplicatie de zoekactie vertraagt, wacht u kort en probeert u de zoekactie opnieuw in plaats van een andere toepassing te maken.

Voor een test met alleen aanmeldingsgegevens voert u alleen de controle op certificaatauthenticatie uit onder Een service-principal verifiëren. U hoeft geen Azure rol toe te wijzen of een host voor te bereiden op die controle. Wanneer de test is voltooid, verwijdert u de toegewezen testtoepassing en lokale referenties.

De service-principal en hostwaarden vastleggen

Stel de hostadressen in. Als u een bestaande identiteit hebt geselecteerd, stelt u eerst SP_TENANT_ID, SP_OBJECT_ID en SP_CLIENT_ID in op de id's van deze identiteit.

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 is object-id van de Enterprise application, ook wel object-id van de service principal genoemd. Dit is niet de object-id van de app-registratie. Bevestig dat SP_CLIENT_ID, SP_OBJECT_IDen het certificaat deel uitmaken van dezelfde service-principal.

Bootstrap wijst SP_TENANT_ID en azure.servicePrincipal.clientId toe aan SP_CLIENT_ID en azure.servicePrincipal.tenantId in de gegenereerde agentconfiguratie. SP_OBJECT_IDwordt gebruikt voor de Azure roltoewijzing, niet als de client-id van de agent. Zie De gegenereerde configuratie van de service-principal controleren voor het veld certificaatbestand, de volledig geredigeerde configuratiestructuur en opdrachten voor veilige verificatie.

Bewaar het beveiligde PEM-bestand voor identiteitsverificatie en hostboottrap. Maak deze beschikbaar op de host via uw goedgekeurde proces voor referentiebeheer vóór bijlage. Leg de locatie vast via het goedgekeurde proces voor het beheer van inloggegevens, niet in het gedeelde omgevingsbestand. Ga verder met Voorbereiden en inspecteren van de host en wijs vervolgens de AKS-rol toe.

Een beheerde identiteit van Azure virtuele machine gebruiken

Gebruik deze optie voor een Azure VM. Maak een virtuele machine door de volgende quickstart te volgen: Maak een virtuele Linux-machine met de Azure CLI of selecteer een bestaande VIRTUELE machine. Plaats de VIRTUELE machine in het hostnetwerk van het flexknooppunt dat voor deze implementatie is gepland. U hebt geen openbaar IP-adres nodig wanneer uw Bash-omgeving een ander goedgekeurd SSH-pad heeft.

Stel de VM-waarden in:

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

Haal de resource-id van de VM en de hostadressen op. Het SSH-doel gebruikt het openbare IP-adres wanneer de virtuele machine er een heeft en het privéadres anders:

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

Bevestig het privéadres dat is geretourneerd voor de virtuele machine:

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

Ga alleen verder wanneer FLEX_HOST_PRIVATE_IP slechts één privéadres bevat dat bij FLEX_HOST_SUBNET_CIDR hoort en bereikbaar is vanuit het door AKS beheerde knooppuntnetwerk. Als Azure meer dan één adres geeft, stelt u FLEX_HOST_PRIVATE_IP in op het adres van het geplande flexknooppunt voordat u doorgaat.

Als de VM geen openbaar IP-adres heeft, of als uw Bash-omgeving de host bereikt via een ander goedgekeurd beheerpad, stelt u FLEX_HOST_SSH_TARGET in op het adres of de hostnaam die uw Bash-omgeving kan bereiken.

Voer een van de volgende opties voor beheerde identiteiten uit.

Door het systeem toegewezen beheerde identiteit

Schakel de door het systeem toegewezen beheerde identiteit in:

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

De id van het principal-object ophalen:

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

Door de gebruiker toegewezen beheerde identiteit

Maak een identiteit of selecteer er een door de instructies in Door de gebruiker toegewezen beheerde identiteiten beheren met behulp van de Azure CLI te volgen.

Stel de identiteitswaarden in:

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

Haal de identiteitsidentificatoren op:

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

Wijs de identiteit toe aan de virtuele machine:

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

Controleer of op de VM de geselecteerde identiteit wordt vermeld:

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

Ga door wanneer de uitvoer USER_ASSIGNED_IDENTITY_RESOURCE_ID bevat.

De VM-identiteit vastleggen

Noteer de VM- en identiteitswaarden:

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. Bereid de host voor en inspecteer deze

Verbinding maken met de host:

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

Controleer op de host het besturingssysteem, de architectuur, de hostnaam, de CPU en de beschikbare opslag:

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

Vergelijk de resultaten met de hostvereisten in stap 1. Los eventuele verschillen op voordat u doorgaat.

Het bootstrap-script vereist curl, jq en tar op de host en stopt als een ervan ontbreekt. De flexknooppuntagent installeert de resterende runtimepakketten tijdens bootstrap.

Installeer een van deze drie die nog niet in uw image is opgenomen:

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

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

Sluit de hostsessie af:

exit

Lees de werkelijke Linux-hostnaam uit uw Bash-omgeving:

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

Ga door wanneer de opdracht de verwachte hostnaam retourneert.

Haal de FQDN van de AKS-API-server op en controleer de naamomzetting en HTTPS-connectiviteit van de host:

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

Als de naamomzetting of de TCP-verbinding mislukt, corrigeert u DNS, routering of netwerkbeheer voordat u doorgaat. Een openbaar AKS-cluster maakt gebruik van de openbare API-FQDN. Voor een privé-AKS-cluster moeten uw Bash-omgeving en flexknooppunthostnetwerk de FQDN van de privé-API oplossen en routeren.

Noteer de hostwaarden. In het bestand met de gedeelde omgeving worden paden en niet-secret-id's opgeslagen, geen sleutel- of referentie-inhoud.

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. De AKS-rol toewijzen

De huidige previewworkflow maakt gebruik van de rol Inzender van Azure Kubernetes Service op het exacte bereik van het AKS-cluster. Alle drie de identiteitsopties maken gebruik van een service-principal-object-id voor Azure op rollen gebaseerd toegangsbeheer. Gebruik een toegewezen hostidentiteit en verwijder deze toewijzing wanneer u de host verwijdert zoals beschreven in Flexknooppunten beheren en verwijderen in AKS.

De geselecteerde principal-object-id weergeven:

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

Ga alleen door wanneer de waarde is ingevuld en toebehoort aan de geselecteerde VM-identiteit, Arc-machine of service-principal.

Controleer of de toewijzing al bestaat:

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

Als de opdracht geen rij retourneert, maakt u de toewijzing:

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

Voer de lijstopdracht opnieuw uit. Ga door wanneer de principal-id en het bereik overeenkomen met de geselecteerde identiteit en AKS_RESOURCE_ID. De propagatie van de roltoewijzing kan enkele minuten duren.

5. Controleer de geselecteerde identiteit

Voordat u de host opstart, moet u controleren of de geselecteerde identiteit het exacte AKS-doelcluster kan verifiëren en lezen. Voltooi alleen de sectie voor uw identiteitsoptie.

Een Azure Arc beheerde identiteit controleren

Geef in uw Bash-omgeving de nietsecret AKS-resource-id door aan de server met Azure Arc:

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

Vraag op de server met Azure Arc ingeschakeld een Azure Resource Manager token aan bij de Hybrid Instance Metadata Service (HIMDS) en gebruik dit om de AKS-resource te lezen. Voor het lezen van het challenge-token zijn rootrechten of lidmaatschap van de groep himds vereist:

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

Verwachte uitvoer: AKS_ARM_HTTP=200. Voer exit uit om de Azure Arc-serversessie te verlaten.

Een service-principal verifiëren

Gebruik in uw Bash-omgeving het gecombineerde PEM-bestand uit de voorbereidingsstappen van de service-principal. Als u een nieuwe sessie hebt gestart of een bestaande identiteit hebt geselecteerd, stelt u het beveiligde pad opnieuw in:

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

Stop als het bestand niet bestaat of leeg is. Voeg dit pad niet toe aan het gedeelde omgevingsbestand.

Controleer eerst de verificatie van certificaten met een geïsoleerd Azure CLI profiel. De subshell verwijdert de tijdelijke tokencache, zelfs wanneer een opdracht mislukt en uw normale Azure CLI aanmelding niet wijzigt.

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

Controleer of Tenant overeenkomt met SP_TENANT_ID en of het token niet is verlopen. Met deze opdracht worden alleen de tenant en vervaldatum afgedrukt, niet het toegangstoken. --allow-no-subscriptionshiermee kunt u verificatie testen voordat u Azure toegang verleent. Geslaagde verificatie bewijst niet dat u gemachtigd bent om het AKS-cluster te lezen of te registreren.

Nadat de AKS-roltoewijzing in stap 4 is doorgegeven, controleert u de toegang tot het exacte doelcluster:

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

Ga alleen door wanneer de geretourneerde resource-id overeenkomt met AKS_RESOURCE_ID en de inrichtingsstatus gelijk is aan Succeeded. Als de authenticatie slaagt maar de clusteraanvraag wordt geweigerd, controleer dan de object-id van de service-principal, het exacte bereik van de roltoewijzing en de propagatie voordat u het opnieuw probeert. Deze controle bewijst dat de service-principal en het bijbehorende certificaat het doelcluster kunnen lezen. De host gebruikt de voorbereide referentie in Een flexknooppunt koppelen aan een AKS-cluster.

Een beheerde identiteit van een Azure-VM controleren

Geef in uw Bash-omgeving de niet-secret AKS-resource-id en identiteitsclient-id door aan de Azure-VM:

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

Op de Azure-VM vraagt u een Azure Resource Manager token aan bij de geselecteerde beheerde identiteit en gebruikt u dit om de AKS-resource te lezen:

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

Verwachte uitvoer: AKS_ARM_HTTP=200. Voor een door de gebruiker toegewezen identiteit maakt de aanvraag gebruik van hetzelfde HOST_IDENTITY_CLIENT_ID dat de werkstroom voor bijlagen aan --msi-client-id doorgeeft. Voer uit exit om de Azure VM-sessie te verlaten.

De bijlagewerkstroom voert de laatste end-to-end-controle uit wanneer de host de geselecteerde identiteit gebruikt om de bijbehorende Azure Machine-resource te registreren.

Volgende stap

Voeg vervolgens de voorbereide host toe en controleer deze als flexknooppunt.

  • Laatst bijgewerkt om