OS disk snapshot

builder/azure/arm/artifact.go

@@ -33,18 +33,22 @@ type Artifact struct {
 	ManagedImageName              string
 	ManagedImageLocation          string
 	ManagedImageId                string
+	ManagedImageOSDiskSnapshotName string
+	ManagedImageDataDiskSnapshotPrefix string
 
 	// Additional Disks
 	AdditionalDisks *[]AdditionalDiskArtifact
 }
 
-func NewManagedImageArtifact(osType, resourceGroup, name, location, id string) (*Artifact, error) {
+func NewManagedImageArtifact(osType, resourceGroup, name, location, id, osDiskSnapshotName, osDiskSnapshotPrefix string) (*Artifact, error) {
 	return &Artifact{
 		ManagedImageResourceGroupName: resourceGroup,
 		ManagedImageName:              name,
 		ManagedImageLocation:          location,
 		ManagedImageId:                id,
 		OSType:                        osType,
+		ManagedImageOSDiskSnapshotName: osDiskSnapshotName,
+		ManagedImageDataDiskSnapshotPrefix: osDiskSnapshotPrefix,
 	}, nil
 }
 
@@ -124,6 +128,14 @@ func (a *Artifact) isManagedImage() bool {
 	return a.ManagedImageResourceGroupName != ""
 }
 
+func (a *Artifact) takeOSDiskSnapshot() bool {
+	return a.ManagedImageOSDiskSnapshotName != ""
+}
+
+func (a *Artifact) takeDataDiskSnapshot() bool {
+	return a.ManagedImageDataDiskSnapshotPrefix != ""
+}
+
 func (*Artifact) BuilderId() string {
 	return BuilderId
 }
@@ -158,6 +170,12 @@ func (a *Artifact) String() string {
 		buf.WriteString(fmt.Sprintf("ManagedImageName: %s\n", a.ManagedImageName))
 		buf.WriteString(fmt.Sprintf("ManagedImageId: %s\n", a.ManagedImageId))
 		buf.WriteString(fmt.Sprintf("ManagedImageLocation: %s\n", a.ManagedImageLocation))
+		if a.takeOSDiskSnapshot() {
+			buf.WriteString(fmt.Sprintf("ManagedImageOSDiskSnapshotName: %s\n", a.ManagedImageOSDiskSnapshotName))
+		}
+		if a.takeDataDiskSnapshot() {
+			buf.WriteString(fmt.Sprintf("ManagedImageDataDiskSnapshotPrefix: %s\n", a.ManagedImageDataDiskSnapshotPrefix))
+		}
 	} else {
 		buf.WriteString(fmt.Sprintf("StorageAccountLocation: %s\n", a.StorageAccountLocation))
 		buf.WriteString(fmt.Sprintf("OSDiskUri: %s\n", a.OSDiskUri))

builder/azure/arm/artifact_test.go

@@ -42,7 +42,7 @@ func TestArtifactIdVHD(t *testing.T) {
 }
 
 func TestArtifactIDManagedImage(t *testing.T) {
-	artifact, err := NewManagedImageArtifact("Linux", "fakeResourceGroup", "fakeName", "fakeLocation", "fakeID")
+	artifact, err := NewManagedImageArtifact("Linux","fakeResourceGroup","fakeName","fakeLocation","fakeID","fakeOSDiskSnapshotName","faksOSDiskSnapshotPrefix")
 	if err != nil {
 		t.Fatalf("err=%s", err)
 	}

builder/azure/arm/azure_client.go

@@ -40,6 +40,7 @@ type AzureClient struct {
 	common.VaultClient
 	armStorage.AccountsClient
 	compute.DisksClient
+	compute.SnapshotsClient
 
 	InspectorMaxLength int
 	Template           *CaptureTemplate
@@ -189,6 +190,12 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.VirtualMachinesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), templateCapture(azureClient), errorCapture(azureClient))
 	azureClient.VirtualMachinesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VirtualMachinesClient.UserAgent)
 
+	azureClient.SnapshotsClient = compute.NewSnapshotsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
+	azureClient.SnapshotsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
+	azureClient.SnapshotsClient.RequestInspector = withInspection(maxlen)
+	azureClient.SnapshotsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), templateCapture(azureClient), errorCapture(azureClient))
+	azureClient.SnapshotsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.SnapshotsClient.UserAgent)
+
 	azureClient.AccountsClient = armStorage.NewAccountsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.AccountsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.AccountsClient.RequestInspector = withInspection(maxlen)

builder/azure/arm/builder.go

@@ -166,7 +166,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	deploymentName := b.stateBag.Get(constants.ArmDeploymentName).(string)
 
 	if b.config.OSType == constants.Target_Linux {
-		steps = []multistep.Step{
+		steps = append(steps,
 				NewStepCreateResourceGroup(azureClient, ui),
 				NewStepValidateTemplate(azureClient, ui, b.config, GetVirtualMachineDeployment),
 				NewStepDeployTemplate(azureClient, ui, b.config, deploymentName, GetVirtualMachineDeployment),
@@ -183,14 +183,10 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 				NewStepGetOSDisk(azureClient, ui),
 				NewStepGetAdditionalDisks(azureClient, ui),
 				NewStepPowerOffCompute(azureClient, ui),
-			NewStepCaptureImage(azureClient, ui),
+			)
-			NewStepDeleteResourceGroup(azureClient, ui),
-			NewStepDeleteOSDisk(azureClient, ui),
-			NewStepDeleteAdditionalDisks(azureClient, ui),
-		}
 	} else if b.config.OSType == constants.Target_Windows {
 		keyVaultDeploymentName := b.stateBag.Get(constants.ArmKeyVaultDeploymentName).(string)
-		steps = []multistep.Step{
+		steps = append(steps,
 			NewStepCreateResourceGroup(azureClient, ui),
 			NewStepValidateTemplate(azureClient, ui, b.config, GetKeyVaultDeployment),
 			NewStepDeployTemplate(azureClient, ui, b.config, keyVaultDeploymentName, GetKeyVaultDeployment),
@@ -218,14 +214,35 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			&packerCommon.StepProvision{},
 			NewStepGetOSDisk(azureClient, ui),
 			NewStepGetAdditionalDisks(azureClient, ui),
+		)
+	} else  {
+		return nil, fmt.Errorf("Builder does not support the os_type '%s'", b.config.OSType)
+	}
+
+	// if managed image create a new step
+	if b.config.isManagedImage() {
+		steps = append(steps,
+			NewStepSnapshotOSDisk(azureClient, ui),
+			//NewStepSnapshotDataDisk(azureClient, ui),
+			)
+	}
+
+	// then add back the remaining steps
+	if b.config.OSType == constants.Target_Linux {
+		steps = append(steps,
+					NewStepCaptureImage(azureClient, ui),
+					NewStepDeleteResourceGroup(azureClient, ui),
+					NewStepDeleteOSDisk(azureClient, ui),
+					NewStepDeleteAdditionalDisks(azureClient, ui),
+			)
+	} else {
+		steps = append(steps,
 			NewStepPowerOffCompute(azureClient, ui),
 			NewStepCaptureImage(azureClient, ui),
 			NewStepDeleteResourceGroup(azureClient, ui),
 			NewStepDeleteOSDisk(azureClient, ui),
 			NewStepDeleteAdditionalDisks(azureClient, ui),
-		}
+		)
-	} else {
-		return nil, fmt.Errorf("Builder does not support the os_type '%s'", b.config.OSType)
 	}
 
 	if b.config.PackerDebug {
@@ -259,7 +276,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 
 	if b.config.isManagedImage() {
 		managedImageID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/images/%s", b.config.SubscriptionID, b.config.ManagedImageResourceGroupName, b.config.ManagedImageName)
-		return NewManagedImageArtifact(b.config.OSType, b.config.ManagedImageResourceGroupName, b.config.ManagedImageName, b.config.manageImageLocation, managedImageID)
+		return NewManagedImageArtifact(b.config.OSType, b.config.ManagedImageResourceGroupName, b.config.ManagedImageName, b.config.manageImageLocation, managedImageID, b.config.ManagedImageOSDiskSnapshotName, b.config.ManagedImageDataDiskSnapshotPrefix)
 	} else if template, ok := b.stateBag.GetOk(constants.ArmCaptureTemplate); ok {
 		return NewArtifact(
 			template.(*CaptureTemplate),
@@ -361,6 +378,8 @@ func (b *Builder) configureStateBag(stateBag multistep.StateBag) {
 	stateBag.Put(constants.ArmIsManagedImage, b.config.isManagedImage())
 	stateBag.Put(constants.ArmManagedImageResourceGroupName, b.config.ManagedImageResourceGroupName)
 	stateBag.Put(constants.ArmManagedImageName, b.config.ManagedImageName)
+	stateBag.Put(constants.ArmManagedImageOSDiskSnapshotName, b.config.ManagedImageOSDiskSnapshotName)
+	stateBag.Put(constants.ArmManagedImageDataDiskSnapshotPrefix, b.config.ManagedImageDataDiskSnapshotPrefix)
 	stateBag.Put(constants.ArmAsyncResourceGroupDelete, b.config.AsyncResourceGroupDelete)
 }
 

builder/azure/arm/config.go

@@ -56,6 +56,7 @@ var (
 	reCaptureNamePrefix    = regexp.MustCompile("^[A-Za-z0-9][A-Za-z0-9_\\-\\.]{0,23}$")
 	reManagedDiskName      = regexp.MustCompile(validManagedDiskName)
 	reResourceGroupName    = regexp.MustCompile(validResourceGroupNameRe)
+	reSnaspshotNameOrPrefix = regexp.MustCompile("^[A-Za-z0-9_]{0,79}$")
 )
 
 type PlanInformation struct {
@@ -107,6 +108,8 @@ type Config struct {
 	ManagedImageResourceGroupName  string `mapstructure:"managed_image_resource_group_name"`
 	ManagedImageName               string `mapstructure:"managed_image_name"`
 	ManagedImageStorageAccountType string `mapstructure:"managed_image_storage_account_type"`
+	ManagedImageOSDiskSnapshotName string `mapstructure:"managed_image_os_disk_snapshot_name"`
+	ManagedImageDataDiskSnapshotPrefix string `mapstructure:"managed_image_data_disk_snapshot_prefix"`
 	managedImageStorageAccountType compute.StorageAccountTypes
 	manageImageLocation            string
 
@@ -688,6 +691,18 @@ func assertRequiredParametersSet(c *Config, errs *packer.MultiError) {
 		}
 	}
 
+	if c.ManagedImageOSDiskSnapshotName != "" {
+		if ok, err := assertManagedImageOSDiskSnapshotNameOrPrefix(c.ManagedImageOSDiskSnapshotName, "managed_image_os_disk_snapshot_name"); !ok {
+			errs = packer.MultiErrorAppend(errs, err)
+		}
+	}
+
+	if c.ManagedImageDataDiskSnapshotPrefix != "" {
+		if ok, err := assertManagedImageOSDiskSnapshotNameOrPrefix(c.ManagedImageDataDiskSnapshotPrefix, "managed_image_data_disk_snapshot_prefix"); !ok {
+			errs = packer.MultiErrorAppend(errs, err)
+		}
+	}
+
 	if c.VirtualNetworkName == "" && c.VirtualNetworkResourceGroupName != "" {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("If virtual_network_resource_group_name is specified, so must virtual_network_name"))
 	}
@@ -741,6 +756,13 @@ func assertManagedImageName(name, setting string) (bool, error) {
 	return true, nil
 }
 
+func assertManagedImageOSDiskSnapshotNameOrPrefix(name, setting string) (bool, error) {
+	if !isValidAzureName(reSnaspshotNameOrPrefix, name) {
+		return false, fmt.Errorf("The setting %s must only contain characters from a-z, A-Z, 0-9 and _ and the maximum length is 80 characters", setting)
+	}
+	return true, nil
+}
+
 func assertResourceGroupName(rgn, setting string) (bool, error) {
 	if !isValidAzureName(reResourceGroupName, rgn) {
 		return false, fmt.Errorf("The setting %s must match the regular expression %q, and not end with a '-' or '.'.", setting, validResourceGroupNameRe)

builder/azure/arm/step_snapshot_os_disk.go

@@ -0,0 +1,75 @@
+package arm
+
+import (
+	"context"
+
+	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute"
+	"github.com/Azure/go-autorest/autorest/to"
+	"github.com/hashicorp/packer/builder/azure/common/constants"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+type StepSnapshotOSDisk struct {
+	client *AzureClient
+	create    func(ctx context.Context, resourceGroupName string, srcUriVhd string, location string, tags map[string]*string, dstSnapshotName string) error
+	say    func(message string)
+	error  func(e error)
+}
+
+func NewStepSnapshotOSDisk(client *AzureClient, ui packer.Ui) *StepSnapshotOSDisk {
+	var step = &StepSnapshotOSDisk{
+		client: client,
+		say:    func(message string) { ui.Say(message) },
+		error:  func(e error) { ui.Error(e.Error()) },
+	}
+
+	step.create = step.createSnapshot
+	return step
+}
+
+func (s *StepSnapshotOSDisk) createSnapshot(ctx context.Context, resourceGroupName string, srcUriVhd string, location string, tags map[string]*string, dstSnapshotName string) error {
+
+	srcVhdToSnapshot := compute.Snapshot{
+		DiskProperties: &compute.DiskProperties{
+			CreationData: &compute.CreationData{
+				CreateOption: compute.Import,
+				SourceURI: to.StringPtr(srcUriVhd),
+			},
+		},
+		Location: to.StringPtr(location),
+		Tags:     tags,
+	}
+
+	f, err := s.client.SnapshotsClient.CreateOrUpdate(ctx, resourceGroupName, dstSnapshotName, srcVhdToSnapshot)
+
+	if err != nil {
+		s.say(s.client.LastError.Error())
+	}
+
+	return f.WaitForCompletion(ctx, s.client.SnapshotsClient.Client)
+}
+
+func (s *StepSnapshotOSDisk) Run(ctx context.Context, stateBag multistep.StateBag) multistep.StepAction {
+	s.say("Taking snapshot of OS disk ...")
+
+	var resourceGroupName = stateBag.Get(constants.ArmResourceGroupName).(string)
+	var location = stateBag.Get(constants.ArmLocation).(string)
+	var tags = stateBag.Get(constants.ArmTags).(map[string]*string)
+	var srcUriVhd = stateBag.Get(constants.ArmOSDiskVhd).(string)
+	var dstSnapshotName = stateBag.Get(constants.ArmManagedImageOSDiskSnapshotName).(string)
+
+	err := s.create(ctx, resourceGroupName, srcUriVhd, location, tags, dstSnapshotName)
+
+	if err != nil {
+		stateBag.Put(constants.Error, err)
+		s.error(err)
+
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (*StepSnapshotOSDisk) Cleanup(multistep.StateBag) {
+}

builder/azure/common/constants/stateBag.go

@@ -35,4 +35,6 @@ const (
 	ArmManagedImageLocation          string = "arm.ManagedImageLocation"
 	ArmManagedImageName              string = "arm.ManagedImageName"
 	ArmAsyncResourceGroupDelete      string = "arm.AsyncResourceGroupDelete"
+	ArmManagedImageOSDiskSnapshotName              string = "arm.ManagedImageOSDiskSnapshotName"
+	ArmManagedImageDataDiskSnapshotPrefix              string = "arm.ManagedImageDataDiskSnapshotPrefix"
 )