func main() { psPath := "path/to/publishSettings" dnsName := "test-vm-from-go" storageAccount := "mystorageaccount" location := "central us" vmSize := "Small" vmImage := "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04-LTS-amd64-server-20140724-en-us-30GB" userName := "******" userPassword := "******" fmt.Println("Create client") client, err := management.ClientFromPublishSettingsFile(fmt.Sprintf("%s.publishsettings", psPath), "") if err != nil { panic(err) } fmt.Println("Create hosted service") if err := hostedservice.NewClient(client).CreateHostedService(hostedservice.CreateHostedServiceParameters{ ServiceName: dnsName, Location: location, Label: base64.StdEncoding.EncodeToString([]byte(dnsName))}); err != nil { panic(err) } fmt.Println("Create storage account") _, err = storageservice.NewClient(client).CreateStorageService(storageservice.StorageAccountCreateParameters{ ServiceName: storageAccount, Label: base64.URLEncoding.EncodeToString([]byte(storageAccount)), Location: location, AccountType: storageservice.AccountTypeStandardLRS}) if err != nil { panic(err) } fmt.Println("Create virtual machine") role := vmutils.NewVMConfiguration(dnsName, vmSize) vmutils.ConfigureDeploymentFromPlatformImage( &role, vmImage, fmt.Sprintf("http://%s.blob.core.windows.net/%s/%s.vhd", storageAccount, dnsName, dnsName), "") vmutils.ConfigureForLinux(&role, dnsName, userName, userPassword) vmutils.ConfigureWithPublicSSH(&role) fmt.Println("Deploy") operationID, err := virtualmachine.NewClient(client). CreateDeployment(role, dnsName, virtualmachine.CreateDeploymentOptions{}) if err != nil { panic(err) } fmt.Println("Waiting...") if err = client.WaitForOperation(operationID, nil); err != nil { panic(err) } }
func createRole(isOSImage bool, vmName, vmSize, certThumbprint, userName, osImageName, mediaLoc string) (role vm.Role) { role = vmutils.NewVMConfiguration(vmName, vmSize) vmutils.ConfigureForLinux(&role, vmName, userName, "", certThumbprint) vmutils.ConfigureWithPublicSSH(&role) if isOSImage { vmutils.ConfigureDeploymentFromPlatformImage(&role, osImageName, mediaLoc, "") } else { vmutils.ConfigureDeploymentFromVMImage(&role, osImageName, mediaLoc, true) } return role }
func createRole(isOSImage bool, vmName, vmSize, userName, password, osImageName, mediaLoc string) (role vm.Role) { role = vmutils.NewVMConfiguration(vmName, vmSize) vmutils.ConfigureForWindows(&role, vmName, userName, password, true, "") vmutils.ConfigureWithPublicRDP(&role) vmutils.ConfigureWithPublicPowerShell(&role) if isOSImage { vmutils.ConfigureDeploymentFromPlatformImage(&role, osImageName, mediaLoc, "") } else { vmutils.ConfigureDeploymentFromVMImage(&role, osImageName, mediaLoc, true) } return role }
func main() { dnsName := "test-vm-from-go" storageAccount := "gosdktest" location := "West US" vmSize := "Small" vmImage := "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04-LTS-amd64-server-20140724-en-us-30GB" userName := "******" userPassword := "******" client, err := management.ClientFromPublishSettingsFile("/Users/niklasg/Downloads/Internal-credentials.publishsettings", "") if err != nil { panic(err) } // create hosted service if err := hostedservice.NewClient(client).CreateHostedService(hostedservice.CreateHostedServiceParameters{ ServiceName: dnsName, Location: location, Label: base64.StdEncoding.EncodeToString([]byte(dnsName))}); err != nil { if azErr, ok := err.(management.AzureError); !ok || azErr.Code != "ConflictError" { panic(err) } } // create virtual machine role := vmutils.NewVMConfiguration(dnsName, vmSize) vmutils.ConfigureDeploymentFromPlatformImage( &role, vmImage, fmt.Sprintf("http://%s.blob.core.windows.net/sdktest/%s.vhd", storageAccount, dnsName), "") vmutils.ConfigureForLinux(&role, dnsName, userName, userPassword) vmutils.ConfigureWithPublicSSH(&role) operationID, err := virtualmachine.NewClient(client). CreateDeployment(role, dnsName, virtualmachine.CreateDeploymentOptions{}) if err != nil { panic(err) } if err := client.WaitForOperation(operationID, nil); err != nil { panic(err) } }
func resourceAzureInstanceCreate(d *schema.ResourceData, meta interface{}) (err error) { azureClient := meta.(*Client) mc := azureClient.mgmtClient hostedServiceClient := azureClient.hostedServiceClient vmClient := azureClient.vmClient name := d.Get("name").(string) // Compute/set the description description := d.Get("description").(string) if description == "" { description = name } // Retrieve the needed details of the image configureForImage, osType, err := retrieveImageDetails( meta, d.Get("image").(string), name, d.Get("storage_service_name").(string), ) if err != nil { return err } // Verify if we have all required parameters if err := verifyInstanceParameters(d, osType); err != nil { return err } var hostedServiceName string // check if hosted service name parameter was given: if serviceName, ok := d.GetOk("hosted_service_name"); !ok { // if not provided; just use the name of the instance to create a new one: hostedServiceName = name d.Set("hosted_service_name", hostedServiceName) p := hostedservice.CreateHostedServiceParameters{ ServiceName: hostedServiceName, Label: base64.StdEncoding.EncodeToString([]byte(name)), Description: fmt.Sprintf("Cloud Service created automatically for instance %s", name), Location: d.Get("location").(string), ReverseDNSFqdn: d.Get("reverse_dns").(string), } log.Printf("[DEBUG] Creating Cloud Service for instance: %s", name) err = hostedServiceClient.CreateHostedService(p) if err != nil { return fmt.Errorf("Error creating Cloud Service for instance %s: %s", name, err) } } else { // else; use the provided hosted service name: hostedServiceName = serviceName.(string) } // Create a new role for the instance role := vmutils.NewVMConfiguration(name, d.Get("size").(string)) log.Printf("[DEBUG] Configuring deployment from image...") err = configureForImage(&role) if err != nil { return fmt.Errorf("Error configuring the deployment for %s: %s", name, err) } if osType == linux { // This is pretty ugly, but the Azure SDK leaves me no other choice... if tp, ok := d.GetOk("ssh_key_thumbprint"); ok { err = vmutils.ConfigureForLinux( &role, name, d.Get("username").(string), d.Get("password").(string), tp.(string), ) } else { err = vmutils.ConfigureForLinux( &role, name, d.Get("username").(string), d.Get("password").(string), ) } if err != nil { return fmt.Errorf("Error configuring %s for Linux: %s", name, err) } } if osType == windows { err = vmutils.ConfigureForWindows( &role, name, d.Get("username").(string), d.Get("password").(string), d.Get("automatic_updates").(bool), d.Get("time_zone").(string), ) if err != nil { return fmt.Errorf("Error configuring %s for Windows: %s", name, err) } if domain_name, ok := d.GetOk("domain_name"); ok { err = vmutils.ConfigureWindowsToJoinDomain( &role, d.Get("domain_username").(string), d.Get("domain_password").(string), domain_name.(string), d.Get("domain_ou").(string), ) if err != nil { return fmt.Errorf("Error configuring %s for WindowsToJoinDomain: %s", name, err) } } } if s := d.Get("endpoint").(*schema.Set); s.Len() > 0 { for _, v := range s.List() { m := v.(map[string]interface{}) err := vmutils.ConfigureWithExternalPort( &role, m["name"].(string), m["private_port"].(int), m["public_port"].(int), endpointProtocol(m["protocol"].(string)), ) if err != nil { return fmt.Errorf( "Error adding endpoint %s for instance %s: %s", m["name"].(string), name, err) } } } if subnet, ok := d.GetOk("subnet"); ok { err = vmutils.ConfigureWithSubnet(&role, subnet.(string)) if err != nil { return fmt.Errorf( "Error associating subnet %s with instance %s: %s", d.Get("subnet").(string), name, err) } } if sg, ok := d.GetOk("security_group"); ok { err = vmutils.ConfigureWithSecurityGroup(&role, sg.(string)) if err != nil { return fmt.Errorf( "Error associating security group %s with instance %s: %s", sg.(string), name, err) } } options := virtualmachine.CreateDeploymentOptions{ VirtualNetworkName: d.Get("virtual_network").(string), } log.Printf("[DEBUG] Creating the new instance...") req, err := vmClient.CreateDeployment(role, hostedServiceName, options) if err != nil { return fmt.Errorf("Error creating instance %s: %s", name, err) } log.Printf("[DEBUG] Waiting for the new instance to be created...") if err := mc.WaitForOperation(req, nil); err != nil { return fmt.Errorf( "Error waiting for instance %s to be created: %s", name, err) } d.SetId(name) return resourceAzureInstanceRead(d, meta) }
func (*StepValidate) Run(state multistep.StateBag) multistep.StepAction { client := state.Get(constants.RequestManager).(management.Client) ui := state.Get(constants.Ui).(packer.Ui) config := state.Get(constants.Config).(*Config) ui.Say("Validating Azure options...") role := vmutils.NewVMConfiguration(config.tmpVmName, config.InstanceSize) ui.Message("Checking Storage Account...") destinationVhd, err := validateStorageAccount(config, client) if err != nil { err = fmt.Errorf("Error checking storage account: %v", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } ui.Message(fmt.Sprintf("Destination VHD: %s", destinationVhd)) if err := func() error { if config.RemoteSourceImageLink != "" { ui.Message("Checking remote image source link...") response, err := http.DefaultClient.Head(config.RemoteSourceImageLink) if response != nil && response.Body != nil { defer response.Body.Close() } if err != nil { log.Printf("HTTP client returned error: %s", err) return fmt.Errorf("error checking remote image source link: %v", err) } if response.StatusCode != 200 { return fmt.Errorf("Unexpected status while retrieving remote image source at %s: %d %s", config.RemoteSourceImageLink, response.StatusCode, response.Status) } size := float64(response.ContentLength) / 1024 / 1024 / 1024 ui.Say(fmt.Sprintf("Remote image size: %.1f GiB", size)) vmutils.ConfigureDeploymentFromRemoteImage(&role, config.RemoteSourceImageLink, config.OSType, fmt.Sprintf("%s-OSDisk", config.tmpVmName), destinationVhd, "") if config.ResizeOSVhdGB != nil { if float64(*config.ResizeOSVhdGB) < size { return fmt.Errorf("new OS VHD size of %d GiB is smaller than current size of %.1f GiB", *config.ResizeOSVhdGB, size) } ui.Say(fmt.Sprintf("Remote image will be resized to %d GiB", *config.ResizeOSVhdGB)) role.OSVirtualHardDisk.ResizedSizeInGB = *config.ResizeOSVhdGB } } else { ui.Message("Checking image source...") imageList, err := osimage.NewClient(client).ListOSImages() if err != nil { log.Printf("OS image client returned error: %s", err) return err } if osImage, found := FindOSImage(imageList.OSImages, config.OSImageLabel, config.Location); found { vmutils.ConfigureDeploymentFromPlatformImage(&role, osImage.Name, destinationVhd, "") ui.Message(fmt.Sprintf("Image source is OS image %q", osImage.Name)) if osImage.OS != config.OSType { return fmt.Errorf("OS image type (%q) does not match config (%q)", osImage.OS, config.OSType) } if config.ResizeOSVhdGB != nil { if float64(*config.ResizeOSVhdGB) < osImage.LogicalSizeInGB { return fmt.Errorf("new OS VHD size of %d GiB is smaller than current size of %.1f GiB", *config.ResizeOSVhdGB, osImage.LogicalSizeInGB) } ui.Say(fmt.Sprintf("OS image will be resized to %d GiB", *config.ResizeOSVhdGB)) role.OSVirtualHardDisk.ResizedSizeInGB = *config.ResizeOSVhdGB } } else { imageList, err := vmimage.NewClient(client).ListVirtualMachineImages( vmimage.ListParameters{ Location: config.Location, }) if err != nil { log.Printf("VM image client returned error: %s", err) return err } if vmImage, found := FindVmImage(imageList.VMImages, "", config.OSImageLabel); found { if config.ResizeOSVhdGB != nil { return fmt.Errorf("Packer cannot resize VM images") } if vmImage.OSDiskConfiguration.OSState != vmimage.OSStateGeneralized { return fmt.Errorf("Packer can only use VM user images with a generalized OS so that it can be reprovisioned. The specified image OS is not in a generalized state.") } if vmImage.Category == vmimage.CategoryUser { //vmutils.ConfigureDeploymentFromUserVMImage(&role, vmImage.Name) role.VMImageName = vmImage.Name } else { vmutils.ConfigureDeploymentFromPublishedVMImage(&role, vmImage.Name, destinationVhd, true) } ui.Message(fmt.Sprintf("Image source is VM image %q", vmImage.Name)) if vmImage.OSDiskConfiguration.OS != config.OSType { return fmt.Errorf("VM image type (%q) does not match config (%q)", vmImage.OSDiskConfiguration.OS, config.OSType) } } else { return fmt.Errorf("Can't find VM or OS image '%s' Located at '%s'", config.OSImageLabel, config.Location) } } } return nil }(); err != nil { err = fmt.Errorf("Error determining deployment source: %v", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } if config.OSType == constants.Target_Linux { certThumbprint := state.Get(constants.Thumbprint).(string) if len(certThumbprint) == 0 { err := fmt.Errorf("Certificate Thumbprint is empty") state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmutils.ConfigureForLinux(&role, config.tmpVmName, config.UserName, "", certThumbprint) // disallowing password login is irreversible on some images, see https://github.com/Azure/packer-azure/issues/62 for i, _ := range role.ConfigurationSets { if role.ConfigurationSets[i].ConfigurationSetType == vm.ConfigurationSetTypeLinuxProvisioning { role.ConfigurationSets[i].DisableSSHPasswordAuthentication = "false" } } vmutils.ConfigureWithPublicSSH(&role) } else if config.OSType == constants.Target_Windows { password := common.RandomPassword() state.Put("password", password) vmutils.ConfigureForWindows(&role, config.tmpVmName, config.UserName, password, true, "") vmutils.ConfigureWithPublicRDP(&role) vmutils.ConfigureWithPublicPowerShell(&role) } if config.VNet != "" && config.Subnet != "" { ui.Message("Checking VNet...") if err := checkVirtualNetworkConfiguration(client, config.VNet, config.Subnet, config.Location); err != nil { state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmutils.ConfigureWithSubnet(&role, config.Subnet) } for n, d := range config.DataDisks { switch d := d.(type) { case int: ui.Message(fmt.Sprintf("Configuring datadisk %d: new disk with size %d GB...", n, d)) destination := fmt.Sprintf("%s-data-%d.vhd", destinationVhd[:len(destinationVhd)-4], n) ui.Message(fmt.Sprintf("Destination VHD for data disk %s: %d", destinationVhd, n)) vmutils.ConfigureWithNewDataDisk(&role, "", destination, d, vmdisk.HostCachingTypeNone) case string: ui.Message(fmt.Sprintf("Configuring datadisk %d: existing blob (%s)...", n, d)) vmutils.ConfigureWithVhdDataDisk(&role, d, vmdisk.HostCachingTypeNone) default: err := fmt.Errorf("Datadisk %d is not a string nor a number", n) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } } state.Put("role", &role) return multistep.ActionContinue }
func (*StepValidate) Run(state multistep.StateBag) multistep.StepAction { client := state.Get(constants.RequestManager).(management.Client) ui := state.Get(constants.Ui).(packer.Ui) config := state.Get(constants.Config).(*Config) ui.Say("Validating Azure options...") role := vmutils.NewVMConfiguration(config.tmpVmName, config.InstanceSize) ui.Message("Checking Storage Account...") destinationVhd, err := validateStorageAccount(config, client) if err != nil { err = fmt.Errorf("Error checking storage account: %v", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } ui.Message(fmt.Sprintf("Destination VHD: %s", destinationVhd)) if err := func() error { if config.RemoteSourceImageLink != "" { ui.Message("Checking remote image source link...") response, err := http.DefaultClient.Head(config.RemoteSourceImageLink) if response != nil && response.Body != nil { defer response.Body.Close() } if err != nil { log.Printf("HTTP client returned error: %s", err) return fmt.Errorf("error checking remote image source link: %v", err) } if response.StatusCode != 200 { return fmt.Errorf("Unexpected status while retrieving remote image source at %s: %d %s", config.RemoteSourceImageLink, response.StatusCode, response.Status) } size := float64(response.ContentLength) / 1024 / 1024 / 1024 ui.Say(fmt.Sprintf("Remote image size: %.1f GiB", size)) vmutils.ConfigureDeploymentFromRemoteImage(&role, config.RemoteSourceImageLink, config.OSType, fmt.Sprintf("%s-OSDisk", config.tmpVmName), destinationVhd, "") } else { ui.Message("Checking image source...") imageList, err := osimage.NewClient(client).ListOSImages() if err != nil { log.Printf("OS image client returned error: %s", err) return err } if osImage, found := FindOSImage(imageList.OSImages, config.OSImageLabel, config.Location); found { vmutils.ConfigureDeploymentFromPlatformImage(&role, osImage.Name, destinationVhd, "") ui.Message(fmt.Sprintf("Image source is OS image %q", osImage.Name)) if osImage.OS != config.OSType { return fmt.Errorf("OS image type (%q) does not match config (%q)", osImage.OS, config.OSType) } } else { imageList, err := vmimage.NewClient(client).ListVirtualMachineImages() if err != nil { log.Printf("VM image client returned error: %s", err) return err } if vmImage, found := FindVmImage(imageList.VMImages, "", config.OSImageLabel, config.Location); found { vmutils.ConfigureDeploymentFromVMImage(&role, vmImage.Name, destinationVhd, true) ui.Message(fmt.Sprintf("Image source is VM image %q", vmImage.Name)) if vmImage.OSDiskConfiguration.OS != config.OSType { return fmt.Errorf("VM image type (%q) does not match config (%q)", vmImage.OSDiskConfiguration.OS, config.OSType) } } else { return fmt.Errorf("Can't find VM or OS image '%s' Located at '%s'", config.OSImageLabel, config.Location) } } } return nil }(); err != nil { err = fmt.Errorf("Error determining deployment source: %v", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } if config.OSType == constants.Target_Linux { certThumbprint := state.Get(constants.Thumbprint).(string) if len(certThumbprint) == 0 { err := fmt.Errorf("Certificate Thumbprint is empty") state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmutils.ConfigureForLinux(&role, config.tmpVmName, config.UserName, "", certThumbprint) vmutils.ConfigureWithPublicSSH(&role) } else if config.OSType == constants.Target_Windows { password := utils.RandomPassword() state.Put("password", password) vmutils.ConfigureForWindows(&role, config.tmpVmName, config.UserName, password, true, "") vmutils.ConfigureWithPublicRDP(&role) vmutils.ConfigureWithPublicPowerShell(&role) } if config.VNet != "" && config.Subnet != "" { ui.Message("Checking VNet...") if err := checkVirtualNetworkConfiguration(client, config.VNet, config.Subnet, config.Location); err != nil { state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } vmutils.ConfigureWithSubnet(&role, config.Subnet) } state.Put("role", &role) return multistep.ActionContinue }
func (d *Driver) Create() error { var vmDeploymentOptions virtualmachine.CreateDeploymentOptions if err := d.setUserSubscription(); err != nil { return err } log.Info("Creating Azure machine...") client, err := d.getClient() if err != nil { return err } dnsName := d.MachineName // 1. Create the hosted service if err := hostedservice.NewClient(client).CreateHostedService(hostedservice.CreateHostedServiceParameters{ ServiceName: dnsName, Location: d.Location, Label: base64.StdEncoding.EncodeToString([]byte(dnsName))}); err != nil { return err } // 2. Generate certificates log.Debug("Generating certificate for Azure...") if err := d.generateCertForAzure(); err != nil { return err } // 3. Setup VM configuration for creation log.Debug("Setting up VM configuration...") var operationID management.OperationID role := vmutils.NewVMConfiguration(dnsName, d.Size) if d.OS == drivers.LINUX { err := d.configureForLinux(&role, dnsName) if err != nil { goto fail } } else { d.configureForWindows(&role, dnsName) } log.Debug("Authorizing docker ports...") if err := d.addDockerEndpoints(&role); err != nil { goto fail } // 4. Create the VM if d.VNet != "" { vmDeploymentOptions = virtualmachine.CreateDeploymentOptions{ VirtualNetworkName: d.VNet, } } else { vmDeploymentOptions = virtualmachine.CreateDeploymentOptions{} } operationID, err = virtualmachine.NewClient(client). CreateDeployment(role, dnsName, vmDeploymentOptions) if err != nil { goto fail } // 5. Wait for operation err = client.WaitForOperation(operationID, nil) if err != nil { goto fail } goto success fail: hostedservice.NewClient(client).DeleteHostedService(dnsName, true) return err success: return nil }