pulumi-azure-native-kotlin/com.pulumi.azurenative.databox.kotlin/Job

Job

class Job : KotlinCustomResource

Job Resource. API Version: 2020-11-01.

Example Usage

JobsCreate

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var job = new AzureNative.DataBox.Job("job", new()
    {
        Details = new AzureNative.DataBox.Inputs.DataBoxJobDetailsArgs
        {
            ContactDetails = new AzureNative.DataBox.Inputs.ContactDetailsArgs
            {
                ContactName = "XXXX XXXX",
                EmailList = new[]
                {
                    "xxxx@xxxx.xxx",
                },
                Phone = "0000000000",
                PhoneExtension = "",
            },
            DataImportDetails = new[]
            {
                new AzureNative.DataBox.Inputs.DataImportDetailsArgs
                {
                    AccountDetails = new AzureNative.DataBox.Inputs.StorageAccountDetailsArgs
                    {
                        DataAccountType = "StorageAccount",
                        StorageAccountId = "/subscriptions/YourSubscriptionId/resourcegroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
                    },
                },
            },
            JobDetailsType = "DataBox",
            ShippingAddress = new AzureNative.DataBox.Inputs.ShippingAddressArgs
            {
                AddressType = "Commercial",
                City = "XXXX XXXX",
                CompanyName = "XXXX XXXX",
                Country = "XX",
                PostalCode = "00000",
                StateOrProvince = "XX",
                StreetAddress1 = "XXXX XXXX",
                StreetAddress2 = "XXXX XXXX",
            },
        },
        JobName = "TestJobName1",
        Location = "westus",
        ResourceGroupName = "YourResourceGroupName",
        Sku = new AzureNative.DataBox.Inputs.SkuArgs
        {
            Name = "DataBox",
        },
        TransferType = "ImportToAzure",
    });
});
Content copied to clipboard
package main
import (
	databox "github.com/pulumi/pulumi-azure-native-sdk/databox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databox.NewJob(ctx, "job", &databox.JobArgs{
			Details: databox.DataBoxJobDetails{
				ContactDetails: databox.ContactDetails{
					ContactName: "XXXX XXXX",
					EmailList: []string{
						"xxxx@xxxx.xxx",
					},
					Phone:          "0000000000",
					PhoneExtension: "",
				},
				DataImportDetails: []databox.DataImportDetails{
					{
						AccountDetails: {
							DataAccountType:  "StorageAccount",
							StorageAccountId: "/subscriptions/YourSubscriptionId/resourcegroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
						},
					},
				},
				JobDetailsType: "DataBox",
				ShippingAddress: databox.ShippingAddress{
					AddressType:     "Commercial",
					City:            "XXXX XXXX",
					CompanyName:     "XXXX XXXX",
					Country:         "XX",
					PostalCode:      "00000",
					StateOrProvince: "XX",
					StreetAddress1:  "XXXX XXXX",
					StreetAddress2:  "XXXX XXXX",
				},
			},
			JobName:           pulumi.String("TestJobName1"),
			Location:          pulumi.String("westus"),
			ResourceGroupName: pulumi.String("YourResourceGroupName"),
			Sku: &databox.SkuArgs{
				Name: pulumi.String("DataBox"),
			},
			TransferType: pulumi.String("ImportToAzure"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databox.Job;
import com.pulumi.azurenative.databox.JobArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var job = new Job("job", JobArgs.builder()
            .details(Map.ofEntries(
                Map.entry("contactDetails", Map.ofEntries(
                    Map.entry("contactName", "XXXX XXXX"),
                    Map.entry("emailList", "xxxx@xxxx.xxx"),
                    Map.entry("phone", "0000000000"),
                    Map.entry("phoneExtension", "")
                )),
                Map.entry("dataImportDetails", Map.of("accountDetails", Map.ofEntries(
                    Map.entry("dataAccountType", "StorageAccount"),
                    Map.entry("storageAccountId", "/subscriptions/YourSubscriptionId/resourcegroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName")
                ))),
                Map.entry("jobDetailsType", "DataBox"),
                Map.entry("shippingAddress", Map.ofEntries(
                    Map.entry("addressType", "Commercial"),
                    Map.entry("city", "XXXX XXXX"),
                    Map.entry("companyName", "XXXX XXXX"),
                    Map.entry("country", "XX"),
                    Map.entry("postalCode", "00000"),
                    Map.entry("stateOrProvince", "XX"),
                    Map.entry("streetAddress1", "XXXX XXXX"),
                    Map.entry("streetAddress2", "XXXX XXXX")
                ))
            ))
            .jobName("TestJobName1")
            .location("westus")
            .resourceGroupName("YourResourceGroupName")
            .sku(Map.of("name", "DataBox"))
            .transferType("ImportToAzure")
            .build());
    }
}
Content copied to clipboard

JobsCreateDevicePassword

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var job = new AzureNative.DataBox.Job("job", new()
    {
        Details = new AzureNative.DataBox.Inputs.DataBoxJobDetailsArgs
        {
            ContactDetails = new AzureNative.DataBox.Inputs.ContactDetailsArgs
            {
                ContactName = "XXXX XXXX",
                EmailList = new[]
                {
                    "xxxx@xxxx.xxx",
                },
                Phone = "0000000000",
                PhoneExtension = "",
            },
            DataImportDetails = new[]
            {
                new AzureNative.DataBox.Inputs.DataImportDetailsArgs
                {
                    AccountDetails = new AzureNative.DataBox.Inputs.StorageAccountDetailsArgs
                    {
                        DataAccountType = "StorageAccount",
                        SharePassword = "<sharePassword>",
                        StorageAccountId = "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
                    },
                },
            },
            DevicePassword = "<devicePassword>",
            JobDetailsType = "DataBox",
            ShippingAddress = new AzureNative.DataBox.Inputs.ShippingAddressArgs
            {
                AddressType = "Commercial",
                City = "XXXX XXXX",
                CompanyName = "XXXX XXXX",
                Country = "XX",
                PostalCode = "00000",
                StateOrProvince = "XX",
                StreetAddress1 = "XXXX XXXX",
                StreetAddress2 = "XXXX XXXX",
            },
        },
        JobName = "TestJobName1",
        Location = "westus",
        ResourceGroupName = "YourResourceGroupName",
        Sku = new AzureNative.DataBox.Inputs.SkuArgs
        {
            Name = "DataBox",
        },
        TransferType = "ImportToAzure",
    });
});
Content copied to clipboard
package main
import (
	databox "github.com/pulumi/pulumi-azure-native-sdk/databox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databox.NewJob(ctx, "job", &databox.JobArgs{
			Details: databox.DataBoxJobDetails{
				ContactDetails: databox.ContactDetails{
					ContactName: "XXXX XXXX",
					EmailList: []string{
						"xxxx@xxxx.xxx",
					},
					Phone:          "0000000000",
					PhoneExtension: "",
				},
				DataImportDetails: []databox.DataImportDetails{
					{
						AccountDetails: {
							DataAccountType:  "StorageAccount",
							SharePassword:    "<sharePassword>",
							StorageAccountId: "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
						},
					},
				},
				DevicePassword: "<devicePassword>",
				JobDetailsType: "DataBox",
				ShippingAddress: databox.ShippingAddress{
					AddressType:     "Commercial",
					City:            "XXXX XXXX",
					CompanyName:     "XXXX XXXX",
					Country:         "XX",
					PostalCode:      "00000",
					StateOrProvince: "XX",
					StreetAddress1:  "XXXX XXXX",
					StreetAddress2:  "XXXX XXXX",
				},
			},
			JobName:           pulumi.String("TestJobName1"),
			Location:          pulumi.String("westus"),
			ResourceGroupName: pulumi.String("YourResourceGroupName"),
			Sku: &databox.SkuArgs{
				Name: pulumi.String("DataBox"),
			},
			TransferType: pulumi.String("ImportToAzure"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databox.Job;
import com.pulumi.azurenative.databox.JobArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var job = new Job("job", JobArgs.builder()
            .details(Map.ofEntries(
                Map.entry("contactDetails", Map.ofEntries(
                    Map.entry("contactName", "XXXX XXXX"),
                    Map.entry("emailList", "xxxx@xxxx.xxx"),
                    Map.entry("phone", "0000000000"),
                    Map.entry("phoneExtension", "")
                )),
                Map.entry("dataImportDetails", Map.of("accountDetails", Map.ofEntries(
                    Map.entry("dataAccountType", "StorageAccount"),
                    Map.entry("sharePassword", "<sharePassword>"),
                    Map.entry("storageAccountId", "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName")
                ))),
                Map.entry("devicePassword", "<devicePassword>"),
                Map.entry("jobDetailsType", "DataBox"),
                Map.entry("shippingAddress", Map.ofEntries(
                    Map.entry("addressType", "Commercial"),
                    Map.entry("city", "XXXX XXXX"),
                    Map.entry("companyName", "XXXX XXXX"),
                    Map.entry("country", "XX"),
                    Map.entry("postalCode", "00000"),
                    Map.entry("stateOrProvince", "XX"),
                    Map.entry("streetAddress1", "XXXX XXXX"),
                    Map.entry("streetAddress2", "XXXX XXXX")
                ))
            ))
            .jobName("TestJobName1")
            .location("westus")
            .resourceGroupName("YourResourceGroupName")
            .sku(Map.of("name", "DataBox"))
            .transferType("ImportToAzure")
            .build());
    }
}
Content copied to clipboard

JobsCreateDoubleEncryption

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var job = new AzureNative.DataBox.Job("job", new()
    {
        Details = new AzureNative.DataBox.Inputs.DataBoxJobDetailsArgs
        {
            ContactDetails = new AzureNative.DataBox.Inputs.ContactDetailsArgs
            {
                ContactName = "XXXX XXXX",
                EmailList = new[]
                {
                    "xxxx@xxxx.xxx",
                },
                Phone = "0000000000",
                PhoneExtension = "",
            },
            DataImportDetails = new[]
            {
                new AzureNative.DataBox.Inputs.DataImportDetailsArgs
                {
                    AccountDetails = new AzureNative.DataBox.Inputs.StorageAccountDetailsArgs
                    {
                        DataAccountType = "StorageAccount",
                        StorageAccountId = "/subscriptions/YourSubscriptionId/resourcegroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
                    },
                },
            },
            JobDetailsType = "DataBox",
            Preferences = new AzureNative.DataBox.Inputs.PreferencesArgs
            {
                EncryptionPreferences = new AzureNative.DataBox.Inputs.EncryptionPreferencesArgs
                {
                    DoubleEncryption = "Enabled",
                },
            },
            ShippingAddress = new AzureNative.DataBox.Inputs.ShippingAddressArgs
            {
                AddressType = "Commercial",
                City = "XXXX XXXX",
                CompanyName = "XXXX XXXX",
                Country = "XX",
                PostalCode = "00000",
                StateOrProvince = "XX",
                StreetAddress1 = "XXXX XXXX",
                StreetAddress2 = "XXXX XXXX",
            },
        },
        JobName = "TestJobName1",
        Location = "westus",
        ResourceGroupName = "YourResourceGroupName",
        Sku = new AzureNative.DataBox.Inputs.SkuArgs
        {
            Name = "DataBox",
        },
        TransferType = "ImportToAzure",
    });
});
Content copied to clipboard
package main
import (
	databox "github.com/pulumi/pulumi-azure-native-sdk/databox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databox.NewJob(ctx, "job", &databox.JobArgs{
			Details: databox.DataBoxJobDetails{
				ContactDetails: databox.ContactDetails{
					ContactName: "XXXX XXXX",
					EmailList: []string{
						"xxxx@xxxx.xxx",
					},
					Phone:          "0000000000",
					PhoneExtension: "",
				},
				DataImportDetails: []databox.DataImportDetails{
					{
						AccountDetails: {
							DataAccountType:  "StorageAccount",
							StorageAccountId: "/subscriptions/YourSubscriptionId/resourcegroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
						},
					},
				},
				JobDetailsType: "DataBox",
				Preferences: databox.Preferences{
					EncryptionPreferences: databox.EncryptionPreferences{
						DoubleEncryption: "Enabled",
					},
				},
				ShippingAddress: databox.ShippingAddress{
					AddressType:     "Commercial",
					City:            "XXXX XXXX",
					CompanyName:     "XXXX XXXX",
					Country:         "XX",
					PostalCode:      "00000",
					StateOrProvince: "XX",
					StreetAddress1:  "XXXX XXXX",
					StreetAddress2:  "XXXX XXXX",
				},
			},
			JobName:           pulumi.String("TestJobName1"),
			Location:          pulumi.String("westus"),
			ResourceGroupName: pulumi.String("YourResourceGroupName"),
			Sku: &databox.SkuArgs{
				Name: pulumi.String("DataBox"),
			},
			TransferType: pulumi.String("ImportToAzure"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databox.Job;
import com.pulumi.azurenative.databox.JobArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var job = new Job("job", JobArgs.builder()
            .details(Map.ofEntries(
                Map.entry("contactDetails", Map.ofEntries(
                    Map.entry("contactName", "XXXX XXXX"),
                    Map.entry("emailList", "xxxx@xxxx.xxx"),
                    Map.entry("phone", "0000000000"),
                    Map.entry("phoneExtension", "")
                )),
                Map.entry("dataImportDetails", Map.of("accountDetails", Map.ofEntries(
                    Map.entry("dataAccountType", "StorageAccount"),
                    Map.entry("storageAccountId", "/subscriptions/YourSubscriptionId/resourcegroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName")
                ))),
                Map.entry("jobDetailsType", "DataBox"),
                Map.entry("preferences", Map.of("encryptionPreferences", Map.of("doubleEncryption", "Enabled"))),
                Map.entry("shippingAddress", Map.ofEntries(
                    Map.entry("addressType", "Commercial"),
                    Map.entry("city", "XXXX XXXX"),
                    Map.entry("companyName", "XXXX XXXX"),
                    Map.entry("country", "XX"),
                    Map.entry("postalCode", "00000"),
                    Map.entry("stateOrProvince", "XX"),
                    Map.entry("streetAddress1", "XXXX XXXX"),
                    Map.entry("streetAddress2", "XXXX XXXX")
                ))
            ))
            .jobName("TestJobName1")
            .location("westus")
            .resourceGroupName("YourResourceGroupName")
            .sku(Map.of("name", "DataBox"))
            .transferType("ImportToAzure")
            .build());
    }
}
Content copied to clipboard

JobsCreateExport

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var job = new AzureNative.DataBox.Job("job", new()
    {
        Details = new AzureNative.DataBox.Inputs.DataBoxJobDetailsArgs
        {
            ContactDetails = new AzureNative.DataBox.Inputs.ContactDetailsArgs
            {
                ContactName = "XXXX XXXX",
                EmailList = new[]
                {
                    "xxxx@xxxx.xxx",
                },
                Phone = "0000000000",
                PhoneExtension = "",
            },
            DataExportDetails = new[]
            {
                new AzureNative.DataBox.Inputs.DataExportDetailsArgs
                {
                    AccountDetails = new AzureNative.DataBox.Inputs.StorageAccountDetailsArgs
                    {
                        DataAccountType = "StorageAccount",
                        StorageAccountId = "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
                    },
                    TransferConfiguration = new AzureNative.DataBox.Inputs.TransferConfigurationArgs
                    {
                        TransferAllDetails = new AzureNative.DataBox.Inputs.TransferConfigurationTransferAllDetailsArgs
                        {
                            Include = new AzureNative.DataBox.Inputs.TransferAllDetailsArgs
                            {
                                DataAccountType = "StorageAccount",
                                TransferAllBlobs = true,
                                TransferAllFiles = true,
                            },
                        },
                        TransferConfigurationType = "TransferAll",
                    },
                },
            },
            JobDetailsType = "DataBox",
            ShippingAddress = new AzureNative.DataBox.Inputs.ShippingAddressArgs
            {
                AddressType = "Commercial",
                City = "XXXX XXXX",
                CompanyName = "XXXX XXXX",
                Country = "XX",
                PostalCode = "00000",
                StateOrProvince = "XX",
                StreetAddress1 = "XXXX XXXX",
                StreetAddress2 = "XXXX XXXX",
            },
        },
        JobName = "TestJobName1",
        Location = "westus",
        ResourceGroupName = "YourResourceGroupName",
        Sku = new AzureNative.DataBox.Inputs.SkuArgs
        {
            Name = "DataBox",
        },
        TransferType = "ExportFromAzure",
    });
});
Content copied to clipboard
package main
import (
	databox "github.com/pulumi/pulumi-azure-native-sdk/databox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databox.NewJob(ctx, "job", &databox.JobArgs{
			Details: databox.DataBoxJobDetails{
				ContactDetails: databox.ContactDetails{
					ContactName: "XXXX XXXX",
					EmailList: []string{
						"xxxx@xxxx.xxx",
					},
					Phone:          "0000000000",
					PhoneExtension: "",
				},
				DataExportDetails: []databox.DataExportDetails{
					{
						AccountDetails: {
							DataAccountType:  "StorageAccount",
							StorageAccountId: "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
						},
						TransferConfiguration: {
							TransferAllDetails: {
								Include: {
									DataAccountType:  "StorageAccount",
									TransferAllBlobs: true,
									TransferAllFiles: true,
								},
							},
							TransferConfigurationType: "TransferAll",
						},
					},
				},
				JobDetailsType: "DataBox",
				ShippingAddress: databox.ShippingAddress{
					AddressType:     "Commercial",
					City:            "XXXX XXXX",
					CompanyName:     "XXXX XXXX",
					Country:         "XX",
					PostalCode:      "00000",
					StateOrProvince: "XX",
					StreetAddress1:  "XXXX XXXX",
					StreetAddress2:  "XXXX XXXX",
				},
			},
			JobName:           pulumi.String("TestJobName1"),
			Location:          pulumi.String("westus"),
			ResourceGroupName: pulumi.String("YourResourceGroupName"),
			Sku: &databox.SkuArgs{
				Name: pulumi.String("DataBox"),
			},
			TransferType: pulumi.String("ExportFromAzure"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databox.Job;
import com.pulumi.azurenative.databox.JobArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var job = new Job("job", JobArgs.builder()
            .details(Map.ofEntries(
                Map.entry("contactDetails", Map.ofEntries(
                    Map.entry("contactName", "XXXX XXXX"),
                    Map.entry("emailList", "xxxx@xxxx.xxx"),
                    Map.entry("phone", "0000000000"),
                    Map.entry("phoneExtension", "")
                )),
                Map.entry("dataExportDetails", Map.ofEntries(
                    Map.entry("accountDetails", Map.ofEntries(
                        Map.entry("dataAccountType", "StorageAccount"),
                        Map.entry("storageAccountId", "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName")
                    )),
                    Map.entry("transferConfiguration", Map.ofEntries(
                        Map.entry("transferAllDetails", Map.of("include", Map.ofEntries(
                            Map.entry("dataAccountType", "StorageAccount"),
                            Map.entry("transferAllBlobs", true),
                            Map.entry("transferAllFiles", true)
                        ))),
                        Map.entry("transferConfigurationType", "TransferAll")
                    ))
                )),
                Map.entry("jobDetailsType", "DataBox"),
                Map.entry("shippingAddress", Map.ofEntries(
                    Map.entry("addressType", "Commercial"),
                    Map.entry("city", "XXXX XXXX"),
                    Map.entry("companyName", "XXXX XXXX"),
                    Map.entry("country", "XX"),
                    Map.entry("postalCode", "00000"),
                    Map.entry("stateOrProvince", "XX"),
                    Map.entry("streetAddress1", "XXXX XXXX"),
                    Map.entry("streetAddress2", "XXXX XXXX")
                ))
            ))
            .jobName("TestJobName1")
            .location("westus")
            .resourceGroupName("YourResourceGroupName")
            .sku(Map.of("name", "DataBox"))
            .transferType("ExportFromAzure")
            .build());
    }
}
Content copied to clipboard

JobsCreateWithUserAssignedIdentity

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var job = new AzureNative.DataBox.Job("job", new()
    {
        Details = new AzureNative.DataBox.Inputs.DataBoxJobDetailsArgs
        {
            ContactDetails = new AzureNative.DataBox.Inputs.ContactDetailsArgs
            {
                ContactName = "XXXX XXXX",
                EmailList = new[]
                {
                    "xxxx@xxxx.xxx",
                },
                Phone = "0000000000",
                PhoneExtension = "",
            },
            DataImportDetails = new[]
            {
                new AzureNative.DataBox.Inputs.DataImportDetailsArgs
                {
                    AccountDetails = new AzureNative.DataBox.Inputs.StorageAccountDetailsArgs
                    {
                        DataAccountType = "StorageAccount",
                        StorageAccountId = "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
                    },
                },
            },
            JobDetailsType = "DataBox",
            ShippingAddress = new AzureNative.DataBox.Inputs.ShippingAddressArgs
            {
                AddressType = "Commercial",
                City = "XXXX XXXX",
                CompanyName = "XXXX XXXX",
                Country = "XX",
                PostalCode = "00000",
                StateOrProvince = "XX",
                StreetAddress1 = "XXXX XXXX",
                StreetAddress2 = "XXXX XXXX",
            },
        },
        Identity = new AzureNative.DataBox.Inputs.ResourceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testIdentity", null },
            },
        },
        JobName = "TestJobName1",
        Location = "westus",
        ResourceGroupName = "YourResourceGroupName",
        Sku = new AzureNative.DataBox.Inputs.SkuArgs
        {
            Name = "DataBox",
        },
        TransferType = "ImportToAzure",
    });
});
Content copied to clipboard
package main
import (
	databox "github.com/pulumi/pulumi-azure-native-sdk/databox"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databox.NewJob(ctx, "job", &databox.JobArgs{
			Details: databox.DataBoxJobDetails{
				ContactDetails: databox.ContactDetails{
					ContactName: "XXXX XXXX",
					EmailList: []string{
						"xxxx@xxxx.xxx",
					},
					Phone:          "0000000000",
					PhoneExtension: "",
				},
				DataImportDetails: []databox.DataImportDetails{
					{
						AccountDetails: {
							DataAccountType:  "StorageAccount",
							StorageAccountId: "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName",
						},
					},
				},
				JobDetailsType: "DataBox",
				ShippingAddress: databox.ShippingAddress{
					AddressType:     "Commercial",
					City:            "XXXX XXXX",
					CompanyName:     "XXXX XXXX",
					Country:         "XX",
					PostalCode:      "00000",
					StateOrProvince: "XX",
					StreetAddress1:  "XXXX XXXX",
					StreetAddress2:  "XXXX XXXX",
				},
			},
			Identity: &databox.ResourceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testIdentity": nil,
				},
			},
			JobName:           pulumi.String("TestJobName1"),
			Location:          pulumi.String("westus"),
			ResourceGroupName: pulumi.String("YourResourceGroupName"),
			Sku: &databox.SkuArgs{
				Name: pulumi.String("DataBox"),
			},
			TransferType: pulumi.String("ImportToAzure"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.databox.Job;
import com.pulumi.azurenative.databox.JobArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var job = new Job("job", JobArgs.builder()
            .details(Map.ofEntries(
                Map.entry("contactDetails", Map.ofEntries(
                    Map.entry("contactName", "XXXX XXXX"),
                    Map.entry("emailList", "xxxx@xxxx.xxx"),
                    Map.entry("phone", "0000000000"),
                    Map.entry("phoneExtension", "")
                )),
                Map.entry("dataImportDetails", Map.of("accountDetails", Map.ofEntries(
                    Map.entry("dataAccountType", "StorageAccount"),
                    Map.entry("storageAccountId", "/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.Storage/storageAccounts/YourStorageAccountName")
                ))),
                Map.entry("jobDetailsType", "DataBox"),
                Map.entry("shippingAddress", Map.ofEntries(
                    Map.entry("addressType", "Commercial"),
                    Map.entry("city", "XXXX XXXX"),
                    Map.entry("companyName", "XXXX XXXX"),
                    Map.entry("country", "XX"),
                    Map.entry("postalCode", "00000"),
                    Map.entry("stateOrProvince", "XX"),
                    Map.entry("streetAddress1", "XXXX XXXX"),
                    Map.entry("streetAddress2", "XXXX XXXX")
                ))
            ))
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testIdentity", ))
            ))
            .jobName("TestJobName1")
            .location("westus")
            .resourceGroupName("YourResourceGroupName")
            .sku(Map.of("name", "DataBox"))
            .transferType("ImportToAzure")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:databox:Job TestJobName1 /subscriptions/YourSubscriptionId/resourceGroups/YourResourceGroupName/providers/Microsoft.DataBox/jobs/TestJobName1
Content copied to clipboard

Properties

Link copied to clipboard
val cancellationReason: Output<String>

Reason for cancellation.

Link copied to clipboard
val deliveryInfo: Output<JobDeliveryInfoResponse>?

Delivery Info of Job.

Link copied to clipboard
val deliveryType: Output<String>?

Delivery type of Job.

Link copied to clipboard
val details: Output<Any>?

Details of a job run. This field will only be sent for expand details filter.

Link copied to clipboard
val error: Output<CloudErrorResponse>

Top level error for the job.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val identity: Output<ResourceIdentityResponse>?

Msi identity of the resource

Link copied to clipboard
val isCancellable: Output<Boolean>

Describes whether the job is cancellable or not.

Link copied to clipboard
val isCancellableWithoutFee: Output<Boolean>

Flag to indicate cancellation of scheduled job.

Link copied to clipboard
val isDeletable: Output<Boolean>

Describes whether the job is deletable or not.

Link copied to clipboard
val isPrepareToShipEnabled: Output<Boolean>

Is Prepare To Ship Enabled on this job

Link copied to clipboard
val isShippingAddressEditable: Output<Boolean>

Describes whether the shipping address is editable or not.

Link copied to clipboard
val location: Output<String>

The location of the resource. This will be one of the supported and registered Azure Regions (e.g. West US, East US, Southeast Asia, etc.). The region of a resource cannot be changed once it is created, but if an identical region is specified on update the request will succeed.

Link copied to clipboard
val name: Output<String>

Name of the object.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val sku: Output<SkuResponse>

The sku type.

Link copied to clipboard
val startTime: Output<String>

Time at which the job was started in UTC ISO 8601 format.

Link copied to clipboard
val status: Output<String>

Name of the stage which is in progress.

Link copied to clipboard
val systemData: Output<SystemDataResponse>

Metadata pertaining to creation and last modification of the resource.

Link copied to clipboard
val tags: Output<Map<String, String>>?

The list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups).

Link copied to clipboard
val transferType: Output<String>

Type of the data transfer.

Link copied to clipboard
val type: Output<String>

Type of the object.

Link copied to clipboard
val urn: Output<String>