Esnek düğüm ana bilgisayarı ve kimliği hazırlama (önizleme)

Important

AKS önizleme özellikleri self servis ve kabul temelinde kullanılabilir. Önizlemeler "olduğu gibi" ve "mevcut olduğu şekilde" sağlanmakta olup, hizmet seviyesi anlaşmalarına ve sınırlı garantilere dahil edilmemektedir. AKS önizlemeleri, müşteri desteği ekibi tarafından maksimum çaba gösterilerek kısmen ele alınmaktadır. Bu nedenle, bu özellikler üretim kullanımı için tasarlanmamıştır. Daha fazla bilgi için aşağıdaki destek makalelerine bakın:

• AKS destek politikaları
• Azure Destek Sıkça Sorulan Sorular

Esnek düğüm olarak bir Linux konağı eklemeden önce konağı hazırlayın, planlama sırasında seçtiğiniz kimliği yapılandırın ve bu kimliğe Azure Kubernetes Service (AKS) kümesine erişim verin.

Bu makalede şunları yapacaksınız:

• Konak gereksinimlerini gözden geçirin, ardından Linux ana bilgisayarını ve buna ait Azure kimliğini hazırlayın veya seçin.
• Ana sistemi hazırlayın ve inceleyin, ayrıca ekleme iş akışında kullanılan değerleri kaydedin.
• AKS kümesi kapsamında kimlik erişimini atayın ve bu kimliği doğrulayın.

Bu makaledeki yönetim komutlarını gerekli araçlara ve ağ erişimine sahip Linux uyumlu bir Bash ortamında çalıştırın. Bu makale bu ortamı Bash ortamınız olarak adlandırır. Kümeye katılan ayrı makine esnek düğüm ana bilgisayarıdır; komutları orada yalnızca bir adım bunu açıkça belirttiğinde çalıştırın.

Başlamadan önce

• Ağ yapılandırmasını tamamlayın ve AKS’de esnek bir düğüm havuzu oluşturun.
• Esnek düğümler için Kimlik ve erişim kavramlarını gözden geçirin ve bir kimlik seçeneği belirleyin.
• Konak kaynağını denetleyebilen ve AKS kümesi kapsamında rol ataması oluşturabilen bir Azure hesabı kullanın. Role Based Access Control Administrator ve User Access Administrator atamayı oluşturabilecek rollere örnektir.
• Bash ortamınıza Azure CLI ve bir OpenSSH istemcisi yükleyin.
• Ana bilgisayarın kabul ettiği bir SSH anahtar çifti hazırlayın.

Dağıtım ortamını yükleme

Yeni bir Bash oturumu başlatın, planlama makalesindeki ortam dosyasını belirleyin ve yükleyin. <deployment-name> değerini dağıtım etiketinizle değiştirin.

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

Ortam dosyası, bu makalenin okuduğu paylaşılan dağıtım değerlerini sağlar; bu makalenin indirmeleri ve oluşturulan dosyaları depoladığı Bash ortamınızdaki dizini de dahil olmak üzere WORK_DIR. Varsayılan olarak, WORK_DIR~/.local/share/aksflexnode/<deployment-name>olarak kabul edilir. Makale, ihtiyaç duyduğu diğer değişkenleri türetir. Ortam dosyasını henüz oluşturmadıysanız önce Esnek düğüm dağıtımınızı planlama işlemini tamamlayın.

Dosya bulunamadıysa veya yüklenemediyse, devam etmeden önce durdurun ve planlama makalesine dönün.

Etkin aboneliği ayarlayın ve seçili kümeyi onaylayın:

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

Kaynak kimliği AKS_RESOURCE_ID ile eşleştiğinde ve sağlama durumu Succeeded olduğunda devam edin.

1. Konak gereksinimlerini gözden geçirin

Aşağıdaki gereksinimleri karşılayan özel bir ana bilgisayar kullanın:

• Ubuntu 24.04 LTS, Azure Linux 3.x veya Red Hat Enterprise Linux (RHEL) 9 veya 10 çalıştıran bir AMD64 veya ARM64 konağı.
• Geçerli bir DNS alt etki alanı adı olan benzersiz bir ana bilgisayar adı. Aracı, düğümü kaydederken bunu küçük harfe dönüştürür.
• /var/lib altında en az dört vCPU ve en az 8 GiB kullanılabilir olmalıdır.
• Ana makinede root veya parolasız sudo erişimine sahip bir SSH hesabı.
• AKS API sunucusuna, Azure Resource Manager’a, Microsoft Entra ID’ye, seçilen esnek düğüm sürümüne ve yapı yansısına ve gerekli kapsayıcı kayıt defterlerine ağ erişimi.
• Esnek düğüm konak ağı ile AKS tarafından yönetilen düğüm ağı arasında mevcut Katman 3 bağlantısı. Ana bilgisayar ile AKS kümesinin aynı Azure bölgesinde olması gerekmez.

Bash ortamınızın da SSH aracılığıyla esnek düğüm konağına bağlanabilmesi gerekir. Başka bir onaylı yönetim yolunuz varsa genel IP adresi gerekmez.

2. Konağı ve kimliği sağlama veya seçme

Yalnızca Esnek düğümler için kimlik ve erişim kavramları bölümünde seçilen kimlik seçeneğinin bölümünü tamamlayın. Aynı konak için birden fazla kalıcı Azure kimlik modu yapılandırmayın.

Tip

Azure dışında bir makine mi bağlıyorsunuz? Makine zaten Arc özellikliyse Azure Arc yönetilen kimliği kullanın veya bir hizmet sorumlusu kullanın. Azure VM yönetilen kimliğini yalnızca esnek düğüm konağı bir Azure VM olduğunda kullanın.

Her kimlik seçeneği tarafından kullanılan SSH anahtar yollarını ayarlayın:

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

Her kimlik seçeneği iki ana bilgisayar adresi de oluşturur. FLEX_HOST_SSH_TARGET Bash ortamınız tarafından kullanılan adrestir. FLEX_HOST_PRIVATE_IP AKS tarafından yönetilen düğüm ağından erişilebilen ana bilgisayar adresidir. FLEX_HOST_SUBNET_CIDR öğesinin FLEX_HOST_PRIVATE_IP öğesine ait olduğunu ve AKS tarafından yönetilen düğüm ağından erişilebilen adres olduğunu ağ yöneticinizle doğrulayın. Esnek düğüm adresi olarak ayrı bir genel veya yalnızca yönetim adresi kullanmayın.

Azure Arc yönetilen kimliği kullanma

Bu seçeneği, zaten Azure Arc'a bağlı olan bir ana bilgisayar için kullanın. Gerekirse Azure Arc özellikli sunucularla hibrit makineleri bağlama yönergelerini izleyin.

Arc kaynak değerlerini ve konak adreslerini ayarlayın:

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

Kaynak kimliğini, bağlantı durumunu ve asıl nesne kimliğini alın:

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

DurumConnected olduğunda ve PrincipalId doldurulmuşsa devam edin.

Konakta Connected Machine aracısını ve Hibrit Örnek Meta Veri Hizmeti'ni doğrulayın:

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

ARC_MACHINE_NAME öğesinin, ARC_RESOURCE_GROUP, ARC_RESOURCE_ID ve azcmagent show ile aynı abonelik kimliğini, kaynak grubunu ve makine adını bildirdiğini onaylayın. Ayrıca himdsd etkin olduğunu doğrulayın. Kaynak eşleşmiyorsa, erişim atamadan önce Arc kaynak değerlerini durdurun ve düzeltin.

Arc ve kimlik değerlerini kaydedin:

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

Service principal kullanın

Bu seçeneği, desteklenen başka bir sanal makine veya fiziksel ana bilgisayar için kullanın. Uzun ömürlü bir istemci gizli anahtarı yerine sertifika kimlik bilgisini kullanmayı tercih edin. Aşağıdaki adımlar, değerlendirme için otomatik olarak imzalanan sertifikaya sahip ayrılmış bir uygulama ve hizmet sorumlusu oluşturur. Bunlar bir istemci parolası oluşturmaz ve Azure rolü atamaz. 4. adımda hedef AKS kümesine erişim izni verirsiniz.

Devam etmeden önce:

• Bash ortamınıza OpenSSL yükleyin ve az login --certificate desteği sunan güncel bir Azure CLI kullanın.
• Uygulamaları kaydedebilen ve hedef abonelikle ilişkili Microsoft Entra kiracısında hizmet sorumluları oluşturabilen bir hesapla oturum açın. Azure abonelik sahipliği yalnızca bu dizin izinlerini vermez. Kiracınız uygulama kaydını kısıtlarsa, kiracı yöneticinizden yardım isteyin. Bkz. Azure CLI ile Azure hizmet sorumlusu oluşturma.
• Kuruluşunuzun değerlendirme için otomatik olarak imzalanan sertifikalara izin verdiğini onaylayın. Mevcut onaylanmış bir kimlik için kiracı kimliğini, uygulama istemci kimliğini, hizmet sorumlusu nesne kimliğini ve korumalı PEM dosyasını kullanın ve Hizmet sorumlusu ve ana bilgisayar değerlerini kaydedin bölümüne geçin.

Kimlik bilgilerini, özel anahtarı veya kimlik bilgisi yolunu paylaşılan ortam dosyasında depolamayın. PEM dosyasını yazdırmayın veya kaynak denetimine eklemeyin. PEM dosyası, aracının etkileşimli parola istemi olmadan kimlik doğrulaması yapabilmesi için şifrelenmemiş bir özel anahtar içerir. Dosya izinleri ve onaylı konak erişim denetimleriyle koruyun.

Sertifika tabanlı hizmet sorumlusu oluşturma

Operatör hesabınızla oturum açarken Bash ortamınızda bu komutları çalıştırın.

1. Aboneliği, kiracıyı ve oturum açmış hesabı onaylayın.

   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
   

   Yalnızca abonelik ve kiracı hedef olduğunda devam edin.

2. Benzersiz bir uygulama görünen adı seçin ve korumalı bir kimlik bilgisi dizini oluşturun.

   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. 30 günlük bir sertifika ve sertifikayı ve özel anahtarı içeren birleşik bir PEM dosyası oluşturun.

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

   Sertifika oluşturma işlemi başarısız olursa durdurun. PEM izinlerinin 600 olduğunu doğrulayın. 30 günlük geçerlilik, döndürme ilkesi için değil değerlendirme içindir. Ana bilgisayar bağlı kalırsa süresi dolmadan önce onaylanan işleminiz aracılığıyla kimlik bilgilerini değiştirin.

4. Yalnızca açık anahtar sertifikasını karşıya yükleyerek uygulamayı ve hizmet asıl öğesini oluşturun.

   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
   

   Yalnızca komut başarılı olduğunda ve bir uygulama istemci kimliği döndürdüğünde devam edin. Komut, kimlik bilgisi bitiş tarihini sertifikanın süre sonuyla eşleşecek şekilde ayarlandığını bildirebilir. --scopes veya --role eklemeyin; sonraki rol ataması AKS kümesiyle sınırlıdır. Kimlik bilgilerini döndürmek için mevcut bir uygulamada oluşturma işlemini yeniden çalıştırmayın.

5. Hizmet sorumlusu nesne kimliğini alın ve kayıtlı kimlik bilgilerini inceleyin.

   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
   

   Hizmet sorumlusu nesne kimliğinin doldurulduğunu, her iki istemci kimliğinin eşleştiğini, 0 değerinin SP_CLIENT_ID olduğunu ve beklenen sona erme tarihiyle tam olarak bir sertifikanın kaydedildiğini onaylayın. Dizin çoğaltması aramayı geciktirirse, kısa bir süre bekleyin ve başka bir uygulama oluşturmak yerine aramayı yeniden deneyin.

Yalnızca kimlik bilgileri testi için Hizmet sorumlusunu doğrulama bölümünde yalnızca sertifika-kimlik doğrulaması denetimini çalıştırın. Bir Azure rolü atamanız veya bu denetleme için bir ana bilgisayar hazırlamanız gerekmez. Test tamamlandığında , ayrılmış test uygulamasını ve yerel kimlik bilgilerini silin.

Hizmet asıl adı ve ana bilgisayar değerlerini kaydedin

Ana bilgisayar adreslerini ayarlayın. Var olan bir kimlik seçtiyseniz, önce SP_CLIENT_ID, SP_OBJECT_ID ve SP_TENANT_ID öğelerini onun tanımlayıcıları olarak ayarlayın.

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 , Kurumsal uygulamanın nesne kimliğidir; buna hizmet sorumlusu nesne kimliği de denir. Bu, uygulama kaydının nesne kimliği değildir. SP_OBJECT_ID, SP_CLIENT_ID ve sertifikanın aynı hizmet asıl sorumlusuna ait olduğunu doğrulayın.

Bootstrap, oluşturulan aracı yapılandırmasında SP_CLIENT_ID ve azure.servicePrincipal.tenantId öğelerini azure.servicePrincipal.clientId ve SP_TENANT_ID ile eşler. SP_OBJECT_ID Azure rol ataması için kullanılır, aracının istemci kimliği olarak değil. Sertifika dosyası alanı, tam yeniden işlenmiş yapılandırma şekli ve güvenli doğrulama komutları için bkz. İşlenen hizmet sorumlusu yapılandırmasını inceleme.

Kimlik doğrulaması ve konak önyüklemesi için korumalı PEM dosyasını saklayın. Bağlamadan önce, onaylı kimlik bilgisi yönetimi süreciniz aracılığıyla bunu ana bilgisayarda kullanıma sunun. Konumunu, paylaşılan ortam dosyasına değil, onaylı kimlik bilgisi yönetim süreciniz aracılığıyla kaydedin. Ana bilgisayarı hazırlama ve inceleme ile devam edin ve AKS rolünü atayın.

Azure sanal makinesinin yönetilen kimliğini kullanma

Azure VM için bu seçeneği kullanın. Hızlı Başlangıç'ı izleyerek vm oluşturma: Azure CLI ile bir Linux sanal makinesi oluşturun veya mevcut bir VM'yi seçin. VM'yi bu dağıtım için planlanan esnek düğüm konak ağına yerleştirin. Bash ortamınızda başka bir onaylı SSH yolu varsa genel IP adresine ihtiyacınız yoktur.

VM değerlerini ayarlayın:

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

VM kaynak kimliğini ve konak adreslerini alın. SSH hedefi, VM'de bir ip adresi olduğunda genel IP adresini, diğer durumlarda ise özel adresi kullanır:

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

VM için döndürülen özel adresi onaylayın:

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

Yalnızca FLEX_HOST_PRIVATE_IP, FLEX_HOST_SUBNET_CIDR öğesine ait ve AKS tarafından yönetilen düğüm ağından erişilebilir tek bir özel adres içerdiğinde devam edin. Azure birden fazla adres döndürürse, devam etmeden önce planlanan esnek düğüm adresine ayarlayınFLEX_HOST_PRIVATE_IP.

VM'nin genel kullanıma açık bir IP adresi yoksa veya Bash ortamınız konağa onaylanmış başka bir yönetim yolu üzerinden ulaşıyorsa, FLEX_HOST_SSH_TARGET öğesini Bash ortamınızın ulaşabildiği adres ya da ana bilgisayar adı olarak ayarlayın.

Aşağıdaki yönetilen kimlik seçeneklerinden birini tamamlayın.

Sistem tarafından atanan yönetilen kimlik

Sistem tarafından atanan yönetilen kimliği etkinleştirin:

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

Ana nesne kimliğini alın:

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

Kullanıcı tarafından atanan yönetilen kimlik

Azure CLI kullanarak kullanıcı tarafından atanan yönetilen kimlikleri yönetme bölümündeki adımları izleyerek bir kimlik oluşturun veya seçin.

Kimlik değerlerini ayarlayın:

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

Kimlik tanımlayıcılarını alın:

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

Kimliği VM'ye atayın:

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

VM'nin seçili kimliği listelediğini doğrulayın:

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

Çıktı USER_ASSIGNED_IDENTITY_RESOURCE_ID içerdiğinde devam edin.

VM kimliğini kaydetme

VM ve kimlik değerlerini kaydedin:

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. Konağı hazırlama ve inceleme

Konağa bağlanın:

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

Ana sistem üzerinde işletim sistemini, mimariyi, ana bilgisayar adını, CPU’yu ve kullanılabilir depolama alanını inceleyin:

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

Sonuçları 1. adımda konak gereksinimleriyle karşılaştırın. Devam etmeden önce herhangi bir farkı çözün.

Önyükleme betiği, ana bilgisayarda jq, tar ve curl gerektirir ve bunlardan herhangi biri eksikse çalışmayı durdurur. Esnek düğüm aracısı, bootstrap sırasında kalan çalışma zamanı paketlerini yükler.

Görüntünüzde henüz yer almamış olan üç görüntüden herhangi birini yükleyin:

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

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

Ana bilgisayar oturumundan çıkın:

exit

Bash ortamınızdan gerçek Linux ana bilgisayar adını okuyun:

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

Komut beklenen ana bilgisayar adını döndürdüğünde devam edin.

AKS API sunucusu FQDN'sini alın ve ana bilgisayardan ad çözümlemesini ve HTTPS bağlantısını doğrulayın:

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

Ad çözümlemesi veya TCP bağlantısı başarısız olursa devam etmeden önce DNS, yönlendirme veya ağ denetimlerini düzeltin. Genel AKS kümesi, genel API FQDN'sini kullanır. Özel bir AKS kümesi için Bash ortamınızın ve esnek düğüm ana bilgisayar ağınızın özel API'nin FQDN'sine çözümleme yapabilmesi ve ona yönlendirebilmesi gerekir.

Ana bilgisayar değerlerini kaydedin. Paylaşılan ortam dosyası, anahtar veya kimlik bilgisi içeriklerini değil yolları ve güvenli olmayan tanımlayıcıları depolar.

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. AKS rolünü atayın

Mevcut önizleme iş akışı, doğrudan AKS kümesi kapsamında Azure Kubernetes Service Contributor Role rolünü kullanır. Üç kimlik seçeneği de rol tabanlı erişim denetimi için Azure hizmet sorumlusu nesne kimliği kullanır. Özel bir konak kimliği kullanın ve AKS'de esnek düğümleri yönetme ve kaldırma bölümünde açıklandığı gibi konağı kaldırdığınızda bu atamayı da kaldırın.

Seçili asıl nesne kimliğini görüntüleyin:

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

Yalnızca değer doldurulduğunda ve seçili VM kimliğine, Arc makinesine veya hizmet sorumlusuna ait olduğunda devam edin.

Atamanın zaten var olup olmadığını denetleyin:

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

Komut satır döndürmezse atamayı oluşturun:

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

Liste komutunu yeniden çalıştırın. Asıl kimlik ve kapsam seçili kimlikle ve AKS_RESOURCE_IDile eşleştiğinde devam edin. Rol ataması yayma işlemi birkaç dakika sürebilir.

5. Seçili kimliği doğrulama

Konağı bootstrap etmeden önce, seçilen kimliğin tam olarak hedeflenen AKS kümesinde kimlik doğrulaması yapabildiğini ve bu kümeyi okuyabildiğini doğrulayın. Yalnızca kimlik seçeneğiniz için bölümü tamamlayın.

Azure Arc tarafından yönetilen kimliği doğrulama

Bash ortamınızda, güvenli olmayan AKS kaynak kimliğini Azure Arc etkin sunucuya geçirin:

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

Azure Arc etkin sunucuda Karma Örnek Meta Veri Hizmeti'nden (HIMDS) bir Azure Resource Manager belirteci isteyin ve AKS kaynağını okumak için bunu kullanın. Doğrulama belirtecini okumak için root yetkisi veya himds grubuna üyelik gerekir:

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

Beklenen çıktı: AKS_ARM_HTTP=200. Azure Arc etkin sunucu oturumundan çıkmak için komutunu çalıştırınexit.

Hizmet sorumlusunu doğrulama

Bash ortamınızda, hizmet sorumlusu hazırlama adımlarında oluşturulan birleştirilmiş PEM dosyasını kullanın. Yeni bir oturum başlattıysanız veya mevcut bir kimliği seçtiyseniz, korumalı yolunu yeniden ayarlayın:

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

Dosya yoksa veya boşsa durdurun. Bu yolu paylaşılan ortam dosyasına eklemeyin.

İlk olarak yalıtılmış bir Azure CLI profiliyle sertifika kimlik doğrulamayı doğrulayın. Altshell, bir komut başarısız olsa bile geçici belirteç önbelleğini kaldırır ve normal Azure CLI oturum açma işleminizi değiştirmez.

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

Tenant'ın SP_TENANT_ID ile eşleştiğini ve belirtecin süresinin dolmadığını doğrulayın. Bu komut, erişim belirtecini değil yalnızca kiracıyı ve süre sonunu yazdırır. --allow-no-subscriptionsAzure erişim vermeden önce kimlik doğrulamasını test etmenizi sağlar. Başarılı kimlik doğrulaması, AKS kümesini okuma veya kaydetme iznini kanıtlamaz.

4. adımdaki AKS rol ataması yayıldıktan sonra, tam hedef kümeye erişimi doğrulayın:

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

Yalnızca döndürülen kaynak kimliği AKS_RESOURCE_ID ile eşleştiğinde ve sağlama durumu Succeeded olduğunda devam edin. Kimlik doğrulaması başarılı olursa ancak küme isteği reddedilirse, yeniden denemeden önce hizmet sorumlusu nesne kimliğini, tam rol atama kapsamını ve yayma bilgilerini doğrulayın. Bu denetim, hizmet sorumlusunun ve sertifikasının hedef kümeyi okuyabildiğini kanıtlar. Ana bilgisayar, AKS kümesine esnek düğüm ekleme bölümünde hazırlamış olduğu kimlik bilgilerini kullanır.

Azure sanal makinesinin yönetilen kimliğini doğrulayın

Bash ortamınızda, güvenli olmayan AKS kaynak kimliğini ve kimlik istemci kimliğini Azure VM'ye geçirin:

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

Azure VM'de, seçili yönetilen kimlikten bir Azure Resource Manager belirteci isteyin ve AKS kaynağını okumak için bu belirteci kullanın:

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

Beklenen çıktı: AKS_ARM_HTTP=200. Kullanıcı tarafından atanmış bir kimlik için istek, ek iş akışının HOST_IDENTITY_CLIENT_ID öğesine geçirdiği aynı --msi-client-id öğesini kullanır. Azure VM oturumundan çıkmak için komutunu çalıştırınexit.

İliştirme iş akışı, ana bilgisayar Azure Machine kaynağını kaydetmek için seçilen kimliği kullandığında son uçtan uca denetimi gerçekleştirir.

Sonraki adım

Ardından, hazırlanan ana bilgisayarı bir esnek düğüm olarak ekleyip doğrulayın.