// // configureForLinux sets up the VM role for Linux specific configuration // // Paramters: // role: role that needs to be updated with Linux configuration // dnsName: name of the machine that we are trying to create // // Returns: // error: errors from reading certs, getting thumbprint and adding // certificate to hostedservice // func (d *Driver) configureForLinux(role *virtualmachine.Role, dnsName string) error { // Get the Azure client client, err := d.getClient() if err != nil { return err } mediaLink := fmt.Sprintf("http://%s.blob.core.windows.net/vhds/%s.vhd", d.StorageAccount, dnsName) // Setup the image configuration vmutils.ConfigureDeploymentFromPlatformImage( role, d.Image, mediaLink, "") // Read the certificate data, err := ioutil.ReadFile(d.azureCertPath()) if err != nil { return err } // Add the certificate to the hostedservice if _, err := hostedservice.NewClient(client).AddCertificate(dnsName, data, "pfx", ""); err != nil { return err } thumbPrint, err := getServiceCertFingerprint(d.azureCertPath()) if err != nil { return err } vmutils.ConfigureForLinux(role, dnsName, d.SSHUser, d.UserPassword, thumbPrint) vmutils.ConfigureWithPublicSSH(role) role.UseCertAuth = true role.CertPath = d.azureCertPath() // Attach VM to a specific subnet if d.Subnet != "" { err = vmutils.ConfigureWithSubnet(role, d.Subnet) if err != nil { log.Error("failed to configure subnet:", d.Subnet, ", err:", err) return err } log.Debug("subnet is:", d.Subnet) } return nil }
// ConfigureDeploymentFromPublishedVMImage configures VM Role to deploy from // a published (public) VM image. func ConfigureDeploymentFromPublishedVMImage( role *vm.Role, vmImageName string, mediaLocation string, provisionGuestAgent bool) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.VMImageName = vmImageName role.MediaLocation = mediaLocation role.ProvisionGuestAgent = provisionGuestAgent return nil }
// ConfigureDeploymentFromExistingOSDisk configures VM Role to deploy from an // existing disk. 'label' is optional. func ConfigureDeploymentFromExistingOSDisk(role *vm.Role, osDiskName, label string) error { role.OSVirtualHardDisk = &vm.OSVirtualHardDisk{ DiskName: osDiskName, DiskLabel: label, } return nil }
// ConfigureForLinux adds configuration for when deploying a generalized Linux // image. If "password" is left empty, SSH password security will be disabled by // default. Certificates with SSH public keys should already be uploaded to the // cloud service where the VM will be deployed and referenced here only by their // thumbprint. func ConfigureForLinux(role *vm.Role, hostname, user, password string, sshPubkeyCertificateThumbprint ...string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.ConfigurationSets = updateOrAddConfig(role.ConfigurationSets, vm.ConfigurationSetTypeLinuxProvisioning, func(config *vm.ConfigurationSet) { config.HostName = hostname config.UserName = user config.UserPassword = password if password != "" { config.DisableSSHPasswordAuthentication = "false" } if len(sshPubkeyCertificateThumbprint) != 0 { config.SSH = &vm.SSH{} for _, k := range sshPubkeyCertificateThumbprint { config.SSH.PublicKeys = append(config.SSH.PublicKeys, vm.PublicKey{ Fingerprint: k, Path: "/home/" + user + "/.ssh/authorized_keys", }, ) } } }, ) return nil }
// ConfigureDeploymentFromUserVMImage configures VM Role to deploy from a previously // captured (user generated) VM image. func ConfigureDeploymentFromUserVMImage( role *vm.Role, vmImageName string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.VMImageName = vmImageName return nil }
func configureWithCustomData(role *vm.Role, customData string, typ vm.ConfigurationSetType) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.ConfigurationSets = updateOrAddConfig(role.ConfigurationSets, typ, func(config *vm.ConfigurationSet) { config.CustomData = customData }) return nil }
// ConfigureWithSubnet associates the Role with a specific subnet func ConfigureWithSubnet(role *vm.Role, subnet string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.ConfigurationSets = updateOrAddConfig(role.ConfigurationSets, vm.ConfigurationSetTypeNetwork, func(config *vm.ConfigurationSet) { config.SubnetNames = append(config.SubnetNames, subnet) }) return nil }
// ConfigureWithSecurityGroup associates the Role with a specific network security group func ConfigureWithSecurityGroup(role *vm.Role, networkSecurityGroup string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.ConfigurationSets = updateOrAddConfig(role.ConfigurationSets, vm.ConfigurationSetTypeNetwork, func(config *vm.ConfigurationSet) { config.NetworkSecurityGroup = networkSecurityGroup }) return nil }
func AddAzureVMExtensionConfiguration(role *vm.Role, name, publisher, version, referenceName, state string, publicConfigurationValue, privateConfigurationValue []byte) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } extension := vm.ResourceExtensionReference{ Name: name, Publisher: publisher, Version: version, ReferenceName: referenceName, State: state, } if len(privateConfigurationValue) != 0 { extension.ParameterValues = append(extension.ParameterValues, vm.ResourceExtensionParameter{ Key: "ignored", Value: base64.StdEncoding.EncodeToString(privateConfigurationValue), Type: "Private", }) } if len(publicConfigurationValue) != 0 { extension.ParameterValues = append(extension.ParameterValues, vm.ResourceExtensionParameter{ Key: "ignored", Value: base64.StdEncoding.EncodeToString(publicConfigurationValue), Type: "Public", }) } if role.ResourceExtensionReferences == nil { role.ResourceExtensionReferences = &[]vm.ResourceExtensionReference{} } extensionList := append(*role.ResourceExtensionReferences, extension) role.ResourceExtensionReferences = &extensionList return nil }
// ConfigureDeploymentFromPlatformImage configures VM Role to deploy from a // platform image. See osimage package for methods to retrieve a list of the // available platform images. "label" is optional. func ConfigureDeploymentFromPlatformImage( role *vm.Role, imageName string, mediaLink string, label string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.OSVirtualHardDisk = &vm.OSVirtualHardDisk{ SourceImageName: imageName, MediaLink: mediaLink, } return nil }
// ConfigureForWindows adds configuration for when deploying a generalized // Windows image. timeZone can be left empty. For a complete list of supported // time zone entries, you can either refer to the values listed in the registry // entry "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time // Zones" or you can use the tzutil command-line tool to list the valid time. func ConfigureForWindows(role *vm.Role, hostname, user, password string, enableAutomaticUpdates bool, timeZone string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.ConfigurationSets = updateOrAddConfig(role.ConfigurationSets, vm.ConfigurationSetTypeWindowsProvisioning, func(config *vm.ConfigurationSet) { config.ComputerName = hostname config.AdminUsername = user config.AdminPassword = password config.EnableAutomaticUpdates = enableAutomaticUpdates config.TimeZone = timeZone }, ) return nil }
// ConfigureWithExternalPort adds a new InputEndpoint to the Role, exposing a // port externally func ConfigureWithExternalPort(role *vm.Role, name string, localport, externalport int, protocol vm.InputEndpointProtocol) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.ConfigurationSets = updateOrAddConfig(role.ConfigurationSets, vm.ConfigurationSetTypeNetwork, func(config *vm.ConfigurationSet) { config.InputEndpoints = append(config.InputEndpoints, vm.InputEndpoint{ LocalPort: localport, Name: name, Port: externalport, Protocol: protocol, }) }) return nil }
// ConfigureDeploymentFromRemoteImage configures VM Role to deploy from a remote // image source. "remoteImageSourceURL" can be any publically accessible URL to // a VHD file, including but not limited to a SAS Azure Storage blob url. "os" // needs to be either "Linux" or "Windows". "label" is optional. func ConfigureDeploymentFromRemoteImage( role *vm.Role, remoteImageSourceURL string, os string, newDiskName string, destinationVhdStorageURL string, label string) error { if role == nil { return fmt.Errorf(errParamNotSpecified, "role") } role.OSVirtualHardDisk = &vm.OSVirtualHardDisk{ RemoteSourceImageLink: remoteImageSourceURL, MediaLink: destinationVhdStorageURL, DiskName: newDiskName, OS: os, DiskLabel: label, } return nil }
func appendDataDisk(role *vm.Role, disk vm.DataVirtualHardDisk) { disk.Lun = len(role.DataVirtualHardDisks) role.DataVirtualHardDisks = append(role.DataVirtualHardDisks, disk) }