in pkg/engine/virtualmachines.go [314:564]
func createAgentAvailabilitySetVM(cs *api.ContainerService, profile *api.AgentPoolProfile) VirtualMachineARM {
var dependencies []string
isStorageAccount := profile.IsStorageAccount()
hasDisks := profile.HasDisks()
kubernetesConfig := cs.Properties.OrchestratorProfile.KubernetesConfig
var useManagedIdentity, userAssignedIDEnabled bool
if kubernetesConfig != nil {
useManagedIdentity = to.Bool(kubernetesConfig.UseManagedIdentity)
userAssignedIDEnabled = kubernetesConfig.UserAssignedIDEnabled()
}
if isStorageAccount {
storageDep := fmt.Sprintf("[concat('Microsoft.Storage/storageAccounts/',variables('storageAccountPrefixes')[mod(add(div(copyIndex(variables('%[1]sOffset')),variables('maxVMsPerStorageAccount')),variables('%[1]sStorageAccountOffset')),variables('storageAccountPrefixesCount'))],variables('storageAccountPrefixes')[div(add(div(copyIndex(variables('%[1]sOffset')),variables('maxVMsPerStorageAccount')),variables('%[1]sStorageAccountOffset')),variables('storageAccountPrefixesCount'))],variables('%[1]sAccountName'))]", profile.Name)
dependencies = append(dependencies, storageDep)
if hasDisks {
dataDiskDep := fmt.Sprintf("[concat('Microsoft.Storage/storageAccounts/',variables('storageAccountPrefixes')[mod(add(add(div(copyIndex(variables('%[1]sOffset')),variables('maxVMsPerStorageAccount')),variables('%[1]sStorageAccountOffset')),variables('dataStorageAccountPrefixSeed')),variables('storageAccountPrefixesCount'))],variables('storageAccountPrefixes')[div(add(add(div(copyIndex(variables('%[1]sOffset')),variables('maxVMsPerStorageAccount')),variables('%[1]sStorageAccountOffset')),variables('dataStorageAccountPrefixSeed')),variables('storageAccountPrefixesCount'))],variables('%[1]sDataAccountName'))]", profile.Name)
dependencies = append(dependencies, dataDiskDep)
}
}
dependencies = append(dependencies, fmt.Sprintf("[concat('Microsoft.Network/networkInterfaces/', variables('%[1]sVMNamePrefix'), 'nic-', copyIndex(variables('%[1]sOffset')))]", profile.Name))
dependencies = append(dependencies, fmt.Sprintf("[concat('Microsoft.Compute/availabilitySets/', variables('%[1]sAvailabilitySet'))]", profile.Name))
if profile.IsWindows() {
windowsProfile := cs.Properties.WindowsProfile
// Add dependency for Image resource created by createWindowsImage()
if windowsProfile.HasCustomImage() {
dependencies = append(dependencies, fmt.Sprintf("%sCustomWindowsImage", profile.Name))
}
}
tags := map[string]*string{
"creationSource": to.StringPtr(fmt.Sprintf("[concat(parameters('generatorCode'), '-', variables('%[1]sVMNamePrefix'), copyIndex(variables('%[1]sOffset')))]", profile.Name)),
"orchestrator": to.StringPtr("[variables('orchestratorNameVersionTag')]"),
"aksEngineVersion": to.StringPtr("[parameters('aksEngineVersion')]"),
"poolName": to.StringPtr(profile.Name),
}
if profile.IsWindows() {
tags["resourceNameSuffix"] = to.StringPtr("[variables('winResourceNamePrefix')]")
} else {
tags["resourceNameSuffix"] = to.StringPtr("[parameters('nameSuffix')]")
}
armResource := ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
DependsOn: dependencies,
Copy: map[string]string{
"count": fmt.Sprintf("[sub(variables('%[1]sCount'), variables('%[1]sOffset'))]", profile.Name),
"name": "vmLoopNode",
},
}
virtualMachine := compute.VirtualMachine{
Location: to.StringPtr("[variables('location')]"),
Name: to.StringPtr(fmt.Sprintf("[concat(variables('%[1]sVMNamePrefix'), copyIndex(variables('%[1]sOffset')))]", profile.Name)),
Type: to.StringPtr("Microsoft.Compute/virtualMachines"),
VirtualMachineProperties: &compute.VirtualMachineProperties{
NetworkProfile: &compute.NetworkProfile{
NetworkInterfaces: &[]compute.NetworkInterfaceReference{
{
ID: to.StringPtr(fmt.Sprintf("[resourceId('Microsoft.Network/networkInterfaces',concat(variables('%[1]sVMNamePrefix'), 'nic-', copyIndex(variables('%[1]sOffset'))))]", profile.Name)),
},
},
},
},
Tags: tags,
}
if profile.IsFlatcar() {
virtualMachine.Plan = &compute.Plan{
Publisher: to.StringPtr(fmt.Sprintf("[parameters('%sosImagePublisher')]", profile.Name)),
Name: to.StringPtr(fmt.Sprintf("[parameters('%sosImageSKU')]", profile.Name)),
Product: to.StringPtr(fmt.Sprintf("[parameters('%sosImageOffer')]", profile.Name)),
}
}
addCustomTagsToVM(profile.CustomVMTags, &virtualMachine)
if useManagedIdentity {
if userAssignedIDEnabled && !profile.IsWindows() {
virtualMachine.Identity = &compute.VirtualMachineIdentity{
Type: compute.ResourceIdentityTypeUserAssigned,
UserAssignedIdentities: map[string]*compute.VirtualMachineIdentityUserAssignedIdentitiesValue{
"[variables('userAssignedIDReference')]": {},
},
}
} else {
virtualMachine.Identity = &compute.VirtualMachineIdentity{
Type: compute.ResourceIdentityTypeSystemAssigned,
}
}
}
virtualMachine.AvailabilitySet = &compute.SubResource{
ID: to.StringPtr(fmt.Sprintf("[resourceId('Microsoft.Compute/availabilitySets',variables('%sAvailabilitySet'))]", profile.Name)),
}
vmSize := fmt.Sprintf("[variables('%sVMSize')]", profile.Name)
virtualMachine.HardwareProfile = &compute.HardwareProfile{
VMSize: compute.VirtualMachineSizeTypes(vmSize),
}
osProfile := compute.OSProfile{
ComputerName: to.StringPtr(fmt.Sprintf("[concat(variables('%[1]sVMNamePrefix'), copyIndex(variables('%[1]sOffset')))]", profile.Name)),
}
t, err := InitializeTemplateGenerator(Context{})
if !profile.IsWindows() {
osProfile.AdminUsername = to.StringPtr("[parameters('linuxAdminUsername')]")
osProfile.LinuxConfiguration = &compute.LinuxConfiguration{
DisablePasswordAuthentication: to.BoolPtr(true),
}
linuxProfile := cs.Properties.LinuxProfile
if linuxProfile != nil && len(linuxProfile.SSH.PublicKeys) > 1 {
publicKeyPath := "[variables('sshKeyPath')]"
publicKeys := []compute.SSHPublicKey{}
for _, publicKey := range linuxProfile.SSH.PublicKeys {
publicKeyTrimmed := strings.TrimSpace(publicKey.KeyData)
publicKeys = append(publicKeys, compute.SSHPublicKey{
Path: &publicKeyPath,
KeyData: &publicKeyTrimmed,
})
}
osProfile.LinuxConfiguration.SSH = &compute.SSHConfiguration{
PublicKeys: &publicKeys,
}
} else {
osProfile.LinuxConfiguration.SSH = &compute.SSHConfiguration{
PublicKeys: &[]compute.SSHPublicKey{
{
KeyData: to.StringPtr("[parameters('sshRSAPublicKey')]"),
Path: to.StringPtr("[variables('sshKeyPath')]"),
},
},
}
}
if err != nil {
panic(err)
}
agentCustomData := getCustomDataFromJSON(t.GetKubernetesLinuxNodeCustomDataJSONObject(cs, profile))
osProfile.CustomData = to.StringPtr(agentCustomData)
if linuxProfile != nil && linuxProfile.HasSecrets() {
vsg := getVaultSecretGroup(linuxProfile)
osProfile.Secrets = &vsg
}
} else {
osProfile.AdminUsername = to.StringPtr("[parameters('windowsAdminUsername')]")
osProfile.AdminPassword = to.StringPtr("[parameters('windowsAdminPassword')]")
osProfile.WindowsConfiguration = &compute.WindowsConfiguration{
EnableAutomaticUpdates: to.BoolPtr(cs.Properties.WindowsProfile.GetEnableWindowsUpdate()),
}
agentCustomData := getCustomDataFromJSON(t.GetKubernetesWindowsNodeCustomDataJSONObject(cs, profile))
osProfile.CustomData = to.StringPtr(agentCustomData)
if cs.Properties.WindowsProfile.HasEnableAHUB() {
licenseType := api.WindowsLicenseTypeNone
if cs.Properties.WindowsProfile.GetEnableAHUB() {
licenseType = api.WindowsLicenseTypeServer
}
virtualMachine.LicenseType = &licenseType
}
}
virtualMachine.OsProfile = &osProfile
storageProfile := compute.StorageProfile{}
if profile.IsWindows() {
storageProfile.ImageReference = createWindowsImageReference(profile.Name, cs.Properties.WindowsProfile)
if profile.HasDisks() {
storageProfile.DataDisks = getArmDataDisks(profile)
}
} else {
imageRef := profile.ImageRef
if profile.HasImageRef() {
if profile.HasImageGallery() {
storageProfile.ImageReference = &compute.ImageReference{
ID: to.StringPtr(fmt.Sprintf("[concat('/subscriptions/', '%s', '/resourceGroups/', parameters('%sosImageResourceGroup'), '/providers/Microsoft.Compute/galleries/', '%s', '/images/', parameters('%sosImageName'), '/versions/', '%s')]", imageRef.SubscriptionID, profile.Name, imageRef.Gallery, profile.Name, imageRef.Version)),
}
} else {
storageProfile.ImageReference = &compute.ImageReference{
ID: to.StringPtr(fmt.Sprintf("[resourceId(variables('%[1]sosImageResourceGroup'), 'Microsoft.Compute/images', variables('%[1]sosImageName'))]", profile.Name)),
}
}
} else {
storageProfile.ImageReference = &compute.ImageReference{
Offer: to.StringPtr(fmt.Sprintf("[variables('%sosImageOffer')]", profile.Name)),
Publisher: to.StringPtr(fmt.Sprintf("[variables('%sosImagePublisher')]", profile.Name)),
Sku: to.StringPtr(fmt.Sprintf("[variables('%sosImageSKU')]", profile.Name)),
Version: to.StringPtr(fmt.Sprintf("[variables('%sosImageVersion')]", profile.Name)),
}
storageProfile.DataDisks = getArmDataDisks(profile)
}
}
osDisk := compute.OSDisk{
CreateOption: compute.DiskCreateOptionTypesFromImage,
Caching: compute.CachingTypes(profile.OSDiskCachingType),
}
if profile.IsStorageAccount() {
osDisk.Name = to.StringPtr(fmt.Sprintf("[concat(variables('%[1]sVMNamePrefix'), copyIndex(variables('%[1]sOffset')),'-osdisk')]", profile.Name))
osDisk.Vhd = &compute.VirtualHardDisk{
URI: to.StringPtr(fmt.Sprintf("[concat(reference(concat('Microsoft.Storage/storageAccounts/',variables('storageAccountPrefixes')[mod(add(div(copyIndex(variables('%[1]sOffset')),variables('maxVMsPerStorageAccount')),variables('%[1]sStorageAccountOffset')),variables('storageAccountPrefixesCount'))],variables('storageAccountPrefixes')[div(add(div(copyIndex(variables('%[1]sOffset')),variables('maxVMsPerStorageAccount')),variables('%[1]sStorageAccountOffset')),variables('storageAccountPrefixesCount'))],variables('%[1]sAccountName')),variables('apiVersionStorage')).primaryEndpoints.blob,'osdisk/', variables('%[1]sVMNamePrefix'), copyIndex(variables('%[1]sOffset')), '-osdisk.vhd')]", profile.Name)),
}
}
if profile.IsEphemeral() {
osDisk.DiffDiskSettings = &compute.DiffDiskSettings{
Option: compute.Local,
}
}
if profile.OSDiskSizeGB > 0 {
osDisk.DiskSizeGB = to.Int32Ptr(int32(profile.OSDiskSizeGB))
}
if profile.DiskEncryptionSetID != "" {
osDisk.ManagedDisk = &compute.ManagedDiskParameters{
DiskEncryptionSet: &compute.DiskEncryptionSetParameters{ID: to.StringPtr(profile.DiskEncryptionSetID)},
}
}
if to.Bool(profile.UltraSSDEnabled) {
virtualMachine.AdditionalCapabilities = &compute.AdditionalCapabilities{
UltraSSDEnabled: to.BoolPtr(true),
}
}
storageProfile.OsDisk = &osDisk
virtualMachine.StorageProfile = &storageProfile
return VirtualMachineARM{
ARMResource: armResource,
VirtualMachine: virtualMachine,
}
}