Przygotowanie hosta i tożsamości węzła Flex (wersja zapoznawcza)

Ważna

Funkcje usługi AKS w wersji zapoznawczej są dostępne na zasadzie samoobsługi i wymagają zapisania się. Wersje zapoznawcze są udostępniane w wersji "as is" i "jako dostępne" i są wykluczone z umów dotyczących poziomu usług i ograniczonej gwarancji. Wersje zapoznawcze usługi AKS są częściowo objęte pomocą techniczną dla klientów, świadczoną w miarę możliwości. W związku z tym te funkcje nie są przeznaczone do użytku produkcyjnego. Aby uzyskać więcej informacji, zobacz następujące artykuły pomocy technicznej:

• Zasady wsparcia technicznego AKS
• pomoc techniczna platformy Azure — często zadawane pytania

Przed dołączeniem hosta z systemem Linux jako węzła flex przygotuj hosta, skonfiguruj tożsamość wybraną podczas planowania i przyznaj tej tożsamości dostęp do klastra Azure Kubernetes Service (AKS).

W tym artykule dowiesz się:

• Przejrzyj wymagania dotyczące hosta, a następnie aprowizuj lub wybierz hosta z systemem Linux i jego tożsamość Azure.
• Przygotuj i sprawdź hosta oraz zapisz wartości używane w przepływie pracy dołączania.
• Przypisz tożsamości uprawnienia dostępu w zakresie klastra AKS i zweryfikuj tę tożsamość.

Uruchom polecenia administracyjne opisane w tym artykule w środowisku Bash zgodnym z systemem Linux, które ma wymagane narzędzia i dostęp do sieci. Ten artykuł nazywa to środowisko Twoim środowiskiem Bash. Oddzielna maszyna dołączona do klastra to host węzła elastycznego; uruchamiaj na niej polecenia tylko wtedy, gdy dany krok wyraźnie to wskazuje.

Zanim rozpoczniesz

• Ukończ konfigurowanie sieci i tworzenie elastycznej puli węzłów w AKS.
• Zapoznaj się z pojęciami dotyczącymi tożsamości i dostępu dla węzłów flex i wybierz jedną opcję tożsamości.
• Użyj konta Azure, które może sprawdzać zasób hosta i utworzyć przypisanie roli w zakresie klastra AKS. Role Based Access Control Administrator i User Access Administrator są przykładami ról, które mogą utworzyć przypisanie.
• Zainstaluj Azure CLI i klienta OpenSSH w środowisku powłoki Bash.
• Przygotuj parę kluczy SSH zaakceptowaną przez hosta.

Ładowanie środowiska wdrażania

Uruchom nową sesję Bash, zidentyfikuj plik konfiguracyjny środowiska wskazany w artykule dotyczącym planowania i wczytaj go. Zastąp <deployment-name> element etykietą wdrożenia.

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

Plik zmiennych środowiskowych zawiera współdzielone wartości wdrożenia, z których korzysta ten artykuł, w tym WORK_DIR, katalog w Twoim środowisku Bash, w którym są zapisywane pobrane i wygenerowane pliki. Domyślnie WORK_DIR jest ~/.local/share/aksflexnode/<deployment-name>. Artykuł wyprowadza wszystkie inne zmienne, których potrzebuje. Jeśli plik środowiska nie został jeszcze utworzony, najpierw ukończ planowanie wdrożenia węzłów flex .

Jeśli plik nie został znaleziony lub nie można go załadować, przed kontynuowaniem zatrzymaj i wróć do artykułu planowania.

Ustaw aktywną subskrypcję i potwierdź wybrany klaster:

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

Kontynuuj, gdy identyfikator zasobu jest zgodny z AKS_RESOURCE_ID, a stan aprowizacji to Succeeded.

1. Przejrzyj wymagania dotyczące hosta

Użyj dedykowanego hosta spełniającego następujące wymagania:

• Host AMD64 lub ARM64 z systemem Ubuntu 24.04 LTS, Azure Linux 3.x lub Red Hat Enterprise Linux (RHEL) 9 lub 10.
• Unikatowa nazwa hosta, która jest prawidłową nazwą poddomeny DNS. Agent konwertuje go na małe litery podczas rejestrowania węzła.
• Co najmniej cztery procesory wirtualne i co najmniej 8 GiB bezpłatnie w obszarze /var/lib.
• Konto SSH z dostępem głównym lub bez sudo hasła na hoście.
• Dostęp sieciowy do serwera interfejsu API usługi AKS, usługi Azure Resource Manager, usługi Microsoft Entra ID, wybranej wersji węzła Flex i repozytorium lustrzanego artefaktów oraz do wymaganych rejestrów kontenerów.
• Istniejąca łączność warstwy 3 między siecią hosta Flex Node a siecią węzłów zarządzanych przez usługę AKS. Host i klaster usługi AKS nie muszą znajdować się w tym samym regionie Azure.

Środowisko Bash musi również umożliwiać nawiązanie połączenia z hostem węzła flex przez SSH. Publiczny adres IP nie jest wymagany, jeśli masz inną zatwierdzoną ścieżkę zarządzania.

2. Skonfiguruj lub wybierz hosta i tożsamość

Uzupełnij tylko sekcję dla opcji tożsamości wybranej w Pojęcia dotyczące tożsamości i dostępu dla węzłów flex. Nie konfiguruj więcej niż jednego trwałego trybu tożsamości Azure dla tego samego hosta.

Wskazówka

Łączenie maszyny spoza platformy Azure? Użyj tożsamości zarządzanej usługi Azure Arc, jeśli komputer jest już włączony do usługi Arc, lub użyj nazwy głównej usługi. Użyj tożsamości zarządzanej maszyny wirtualnej platformy Azure tylko wtedy, gdy host węzła Flex działa na maszynie wirtualnej platformy Azure.

Ustaw ścieżki kluczy SSH używane przez każdą opcję tożsamości:

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

Każda opcja tożsamości ustanawia również dwa adresy hosta. FLEX_HOST_SSH_TARGET to adres używany przez środowisko Bash. FLEX_HOST_PRIVATE_IP to adres hosta dostępny z sieci węzłów zarządzanych przez AKS. Potwierdź u administratora sieci, że FLEX_HOST_PRIVATE_IP należy do FLEX_HOST_SUBNET_CIDR i jest adresem osiągalnym z sieci węzłów zarządzanych przez AKS. Nie używaj oddzielnego adresu publicznego ani adresu używanego wyłącznie do zarządzania jako adresu węzła flex.

Użyj tożsamości zarządzanej Azure Arc

Użyj tej opcji dla hosta, który jest już połączony z Azure Arc. W razie potrzeby postępuj zgodnie z instrukcjami Connect hybrid machines with Azure Arc-enabled servers (Łączenie maszyn hybrydowych z serwerami z obsługą Azure Arc).

Ustaw wartości zasobów usługi Arc i adresy hostów:

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

Pobierz identyfikator zasobu, stan połączenia i identyfikator obiektu głównego:

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

Kontynuuj, gdy stan to Connected , a wartość PrincipalId jest wypełniana.

Sprawdź agenta Connected Machine i usługę Hybrid Instance Metadata Service na hoście:

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

Upewnij się, że azcmagent show raportuje ten sam identyfikator subskrypcji, grupę zasobów i nazwę maszyny jako ARC_RESOURCE_ID, ARC_RESOURCE_GROUPi ARC_MACHINE_NAME. Upewnij się również, że himdsd jest aktywny. Jeśli zasób nie odpowiada, przerwij i popraw wartości zasobu Arc przed przypisaniem dostępu.

Zapisz wartości Arc i tożsamości:

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

Użycie głównego elementu usługi

Użyj tej opcji dla innej obsługiwanej maszyny wirtualnej lub hosta bez systemu operacyjnego. Preferuj poświadczenie oparte na certyfikacie zamiast długotrwałego klucza tajnego klienta. Poniższe kroki umożliwiają utworzenie dedykowanej aplikacji i jednostki usługi z certyfikatem z podpisem własnym na potrzeby oceny. Nie tworzą klucza tajnego klienta ani nie przypisują roli Azure. W kroku 4 przyznajesz dostęp do docelowego klastra AKS.

Przed kontynuowaniem:

• Zainstaluj OpenSSL w środowisku Bash i użyj aktualnej wersji Azure CLI, która obsługuje az login --certificate.
• Zaloguj się przy użyciu konta, które może rejestrować aplikacje i tworzyć jednostki usługi w dzierżawie Microsoft Entra skojarzonej z subskrypcją docelową. Samo posiadanie subskrypcji platformy Azure nie przyznaje tych uprawnień do katalogu. Jeśli dzierżawa ogranicza rejestrację aplikacji, poproś administratora dzierżawy o pomoc. Zobacz Tworzenie jednostki usługi Azure przy użyciu Azure CLI.
• Upewnij się, że organizacja zezwala na certyfikaty z podpisem własnym do oceny. W przypadku istniejącej zatwierdzonej tożsamości użyj identyfikatora dzierżawy, identyfikatora klienta aplikacji, identyfikatora obiektu jednostki usługi i chronionego pliku PEM, a następnie przejdź do pozycji Rejestrowanie wartości jednostki usługi i hosta.

Nie przechowuj poświadczeń, klucza prywatnego ani ścieżki poświadczeń w pliku środowiska udostępnionego. Nie drukuj pliku PEM ani nie dołączaj go do kontroli źródła. Plik PEM zawiera niezaszyfrowany klucz prywatny, dzięki czemu agent może uwierzytelniać się bez interakcyjnego monitu o hasło. Chroń go przy użyciu uprawnień do plików i zatwierdzonych mechanizmów kontroli dostępu hosta.

Utwórz nazwę główną usługi opartą na certyfikacie

Uruchom te polecenia w środowisku Bash po zalogowaniu się na konto operatora.

1. Potwierdź subskrypcję, dzierżawę i zalogowane konto.

   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
   

   Kontynuuj tylko wtedy, gdy subskrypcja i dzierżawa są właściwymi elementami docelowymi.

2. Wybierz unikatową nazwę wyświetlaną aplikacji i utwórz chroniony katalog poświadczeń.

   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. Utwórz 30-dniowy certyfikat i połączony plik PEM zawierający certyfikat i klucz prywatny.

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

   Zatrzymaj, jeśli tworzenie certyfikatu zakończy się niepowodzeniem. Upewnij się, że uprawnienia pliku PEM wynoszą 600. 30-dniowa ważność dotyczy oceny, a nie zasad rotacji. Wymień poświadczenie zgodnie z zatwierdzoną procedurą przed jego wygaśnięciem, jeśli host nadal jest dołączony.

4. Utwórz aplikację i jednostkę usługi głównej, przesyłając tylko certyfikat publiczny.

   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
   

   Kontynuuj tylko wtedy, gdy polecenie zakończy się pomyślnie i zwróci identyfikator klienta aplikacji. Polecenie może poinformować, że dostosowało datę wygaśnięcia poświadczenia tak, aby odpowiadała dacie wygaśnięcia certyfikatu. Nie dodawaj --role ani --scopes; późniejsze przypisanie roli jest ograniczone do klastra AKS. Nie uruchamiaj ponownie procesu tworzenia w przypadku istniejącej aplikacji, aby zmienić jej poświadczenia.

5. Pobierz identyfikator obiektu jednostki usługi i sprawdź zarejestrowane poświadczenia.

   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
   

   Upewnij się, że identyfikator obiektu nazwy głównej usługi jest ustawiony, oba identyfikatory klienta są zgodne z SP_CLIENT_ID, PasswordCredentials ma wartość 0, a dokładnie jeden certyfikat jest zarejestrowany z oczekiwaną datą wygaśnięcia. Jeśli replikacja katalogów opóźni wyszukiwanie, zaczekaj chwilę i spróbuj ponownie wyszukać zamiast tworzyć inną aplikację.

W przypadku testu opartego wyłącznie na poświadczeniach uruchom tylko sprawdzanie uwierzytelniania certyfikatem w sekcji Weryfikowanie jednostki usługi. Nie musisz przypisywać roli Azure ani przygotowywać hosta do tego sprawdzenia. Po zakończeniu testu usuń dedykowaną aplikację testowa i poświadczenia lokalne.

Zanotuj wartości nazwy głównej usługi i hosta

Ustaw adresy hostów. Jeśli wybrano istniejącą tożsamość, najpierw ustaw SP_TENANT_ID, SP_CLIENT_ID i SP_OBJECT_ID na jej identyfikatory.

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 to identyfikator obiektu aplikacji dla przedsiębiorstw, nazywany również identyfikatorem obiektu jednostki usługi. Nie jest to identyfikator obiektu rejestracji aplikacji. Upewnij się, że SP_CLIENT_ID, SP_OBJECT_ID i certyfikat należą do tej samej nazwy głównej usługi.

Bootstrap przypisuje SP_TENANT_ID i azure.servicePrincipal.tenantId do SP_CLIENT_ID i azure.servicePrincipal.clientId w wygenerowanej konfiguracji agenta. SP_OBJECT_IDjest używany dla przypisania roli Azure, a nie jako identyfikator klienta agenta. Informacje o polu certificate-file, pełnej strukturze zredagowanej konfiguracji i bezpiecznych poleceniach weryfikacyjnych znajdziesz w sekcji Sprawdzanie wygenerowanej konfiguracji service principal.

Zachowaj chroniony plik PEM na potrzeby weryfikacji tożsamości i uruchamiania hosta. Udostępnij go na hoście za pośrednictwem zatwierdzonego procesu zarządzania poświadczeniami przed załącznikiem. Zapisz informację o jego lokalizacji w zatwierdzonym procesie zarządzania poświadczeniami, a nie we współdzielonym pliku środowiskowym. Przejdź do Przygotuj i sprawdź hosta, a następnie przypisz rolę AKS.

Używanie tożsamości zarządzanej maszyny wirtualnej Azure

Użyj tej opcji dla maszyny wirtualnej Azure. Utwórz maszynę wirtualną, wykonując czynności opisane w przewodniku Szybki start: utwórz maszynę wirtualną z systemem Linux przy użyciu Azure CLI lub wybierz istniejącą maszynę wirtualną. Umieść maszynę wirtualną w sieci hosta węzła Flex przeznaczonej dla tego wdrożenia. Nie potrzebujesz publicznego adresu IP, jeśli środowisko Bash ma dostęp przez inną zatwierdzoną ścieżkę SSH.

Ustaw wartości maszyny wirtualnej:

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

Pobierz identyfikator zasobu maszyny wirtualnej i adresy hosta. Docelowy protokół SSH używa publicznego adresu IP, gdy maszyna wirtualna ma jeden, a adres prywatny w przeciwnym razie:

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

Potwierdź adres prywatny zwrócony dla maszyny wirtualnej:

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

Kontynuuj tylko wtedy, gdy FLEX_HOST_PRIVATE_IP zawiera jeden prywatny adres, do którego należy FLEX_HOST_SUBNET_CIDR i jest osiągalny z sieci węzłów zarządzanych przez usługę AKS. Jeśli platforma Azure zwraca więcej niż jeden adres, przed kontynuowaniem ustaw adres FLEX_HOST_PRIVATE_IP na adres planowanego węzła flex.

Jeśli maszyna wirtualna nie ma publicznego adresu IP lub środowisko Bash łączy się z hostem za pośrednictwem innego zatwierdzonego sposobu zarządzania, ustaw FLEX_HOST_SSH_TARGET na adres lub nazwę hosta, z którym środowisko Bash może się połączyć.

Uzupełnij jedną z poniższych opcji tożsamości zarządzanej.

Tożsamość zarządzana przypisana przez system

Włącz tożsamość zarządzaną przypisaną przez system:

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

Pobierz identyfikator obiektu głównego:

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

Tożsamość zarządzana przypisana użytkownikowi

Utwórz lub wybierz tożsamość, postępując zgodnie z instrukcjami Zarządzanie tożsamościami zarządzanymi przypisanymi przez użytkownika przy użyciu Azure CLI.

Ustaw wartości tożsamości:

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

Pobierz identyfikatory tożsamości:

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

Przypisz tożsamość do maszyny wirtualnej:

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

Sprawdź, czy maszyna wirtualna wyświetla wybraną tożsamość:

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

Kontynuuj, gdy dane wyjściowe zawierają USER_ASSIGNED_IDENTITY_RESOURCE_ID.

Rejestrowanie tożsamości maszyny wirtualnej

Zarejestruj wartości maszyny wirtualnej i tożsamości:

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. Przygotowanie i inspekcja hosta

Połącz się z hostem:

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

Na hoście sprawdź system operacyjny, architekturę, nazwę hosta, procesor i dostępne miejsce na dysku:

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

Porównaj wyniki z wymaganiami dotyczącymi hosta w kroku 1. Rozwiąż wszelkie różnice przed kontynuowaniem.

Skrypt bootstrap wymaga curl, jqi tar na hoście i zatrzymuje się, jeśli brakuje któregokolwiek z nich. Agent flex node instaluje pozostałe pakiety środowiska uruchomieniowego podczas uruchamiania.

Zainstaluj dowolny z trzech elementów, których nie ma jeszcze w obrazie systemu:

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

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

Zamknij sesję hosta:

exit

Odczytaj rzeczywistą nazwę hosta Linux ze środowiska 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}"

Kontynuuj, gdy polecenie zwraca oczekiwaną nazwę hosta.

Pobierz adres FQDN serwera interfejsu API AKS i sprawdź rozwiązywanie nazw oraz łączność HTTPS z hosta:

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

Jeśli rozwiązywanie nazw lub połączenie TCP nie powiedzie się, przed kontynuowaniem skoryguj ustawienia DNS, routingu lub zabezpieczenia sieciowe. Publiczny klaster AKS używa publicznej nazwy FQDN interfejsu API. W prywatnym klastrze AKS środowisko Bash i sieć hosta węzła elastycznego muszą umożliwiać rozpoznawanie prywatnej w pełni kwalifikowanej nazwy domenowej (FQDN) interfejsu API oraz kierowanie ruchu do niej.

Zapisz wartości hosta. Plik środowiska udostępnionego przechowuje ścieżki i identyfikatory niezabezpieczone, a nie klucz lub zawartość poświadczeń.

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. Przypisz rolę AKS

Bieżący przepływ pracy w wersji zapoznawczej używa roli Azure Kubernetes Service Contributor Role w zakresie dokładnie tego klastra AKS. Wszystkie trzy opcje tożsamości używają identyfikatora obiektu jednostki usługi na potrzeby kontroli dostępu opartej na rolach platformy Azure. Użyj dedykowanej tożsamości hosta i usuń to przypisanie podczas usuwania hosta, zgodnie z opisem w artykule Zarządzanie węzłami flex w usłudze AKS i usuwanie ich.

Wyświetl wybrany identyfikator obiektu podmiotu zabezpieczeń:

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

Kontynuuj tylko wtedy, gdy wartość jest uzupełniona i należy do wybranej tożsamości maszyny wirtualnej, maszyny Arc lub jednostki usługi.

Sprawdź, czy przypisanie już istnieje:

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

Jeśli polecenie nie zwraca żadnego wiersza, utwórz przypisanie:

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

Uruchom ponownie polecenie listy. Kontynuuj, gdy identyfikator i zakres podmiotu zabezpieczeń są zgodne z wybraną tożsamością i AKS_RESOURCE_ID. Propagacja przypisania roli może potrwać kilka minut.

5. Sprawdź wybraną tożsamość

Przed rozpoczęciem uruchamiania hosta upewnij się, że wybrana tożsamość może się uwierzytelnić i odczytać dokładny docelowy klaster usługi AKS. Ukończ tylko sekcję dotyczącą opcji tożsamości.

Weryfikowanie tożsamości zarządzanej w usłudze Azure Arc

W środowisku powłoki Bash przekaż niezabezpieczony identyfikator zasobu usługi AKS do serwera z obsługą 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"

Na serwerze z obsługą Azure Arc zażądaj tokenu Azure Resource Manager z usługi metadanych wystąpienia hybrydowego (HIMDS) i użyj go do odczytania zasobu usługi AKS. Odczytanie tokenu wyzwania wymaga uprawnień roota lub członkostwa w grupie 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}"

Oczekiwany rezultat: AKS_ARM_HTTP=200. Uruchom polecenie exit , aby opuścić sesję serwera z obsługą Azure Arc.

Weryfikowanie nazwy głównej usługi

W środowisku Bash użyj scalonego pliku PEM z kroków przygotowania jednostki usługi. Jeśli uruchomiono nową sesję lub wybrano istniejącą tożsamość, ustaw ponownie ścieżkę chronioną:

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

Zatrzymaj, jeśli plik nie istnieje lub jest pusty. Nie dodawaj tej ścieżki do pliku środowiska udostępnionego.

Najpierw zweryfikuj uwierzytelnianie certyfikatu przy użyciu izolowanego profilu Azure CLI. Podshell usuwa tymczasową pamięć podręczną tokenów nawet wtedy, gdy polecenie kończy się niepowodzeniem i nie zmienia normalnego Azure CLI logowania.

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

Upewnij się, że Tenant pasuje do SP_TENANT_ID oraz że token nie wygasł. To polecenie wyświetla tylko dzierżawcę i datę wygaśnięcia, a nie token dostępu. --allow-no-subscriptionsumożliwia przetestowanie uwierzytelniania przed udzieleniem Azure dostępu. Pomyślne uwierzytelnienie nie dowodzi, że użytkownik ma uprawnienia do odczytu ani do rejestracji w klastrze AKS.

Po propagacji przypisania roli usługi AKS w kroku 4 sprawdź dostęp do dokładnego klastra docelowego:

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

Kontynuuj tylko wtedy, gdy zwrócony identyfikator zasobu odpowiada AKS_RESOURCE_ID, a stan aprowizacji to Succeeded. Jeśli uwierzytelnianie powiedzie się, ale żądanie klastra zostanie odrzucone, sprawdź identyfikator obiektu jednostki usługi, dokładny zakres przypisania roli i propagację przed ponowieniem próby. Ta kontrola potwierdza, że jednostka usługi i jego certyfikat mogą odczytać klaster docelowy. Host używa przygotowanych poświadczeń w artykule Dołączanie węzła flex do klastra usługi AKS.

Weryfikowanie tożsamości zarządzanej maszyny wirtualnej Azure

W środowisku powłoki Bash przekaż niezabezpieczony identyfikator zasobu usługi AKS i identyfikator klienta tożsamości do maszyny wirtualnej Azure:

[[ "${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 maszynie wirtualnej Azure zażądaj tokenu Azure Resource Manager z wybranej tożsamości zarządzanej i użyj go do odczytania zasobu usługi 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}"

Oczekiwany rezultat: AKS_ARM_HTTP=200. W przypadku tożsamości przypisanej przez użytkownika, żądanie używa tego samego HOST_IDENTITY_CLIENT_ID, co przepływ pracy dołączania przekazuje do --msi-client-id. Uruchom polecenie exit , aby opuścić sesję maszyny wirtualnej Azure.

Przepływ pracy dołączania wykonuje końcową kompleksową kontrolę, gdy host używa wybranej tożsamości, aby zarejestrować swój zasób Azure Machine.

Następny krok

Następnie, dołącz i zweryfikuj przygotowany host jako węzeł Flex.