//
// 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)
}