1. Packages
  2. Spotinst
  3. API Docs
  4. StatefulNodeAzure
Spotinst v3.68.0 published on Monday, Feb 19, 2024 by Pulumi

spotinst.StatefulNodeAzure

Explore with Pulumi AI

spotinst logo
Spotinst v3.68.0 published on Monday, Feb 19, 2024 by Pulumi

    Provides a Spotinst stateful node Azure resource.

    Strategy

    • strategy - (Required) Strategy for stateful node.
      • draining_timeout - (Optional, Default 120) Time (in seconds) to allow the VM be drained from incoming TCP connections and detached from MLB before terminating it during a scale down operation.
      • fallback_to_on_demand - (Required) In case of no spots available, Stateful Node will launch an On-demand instance instead.
      • optimization_windows - (Optional) Valid format: “ddd:hh:mm-ddd:hh:mm (day:hour(0-23):minute(0-59))”, not empty if revertToSpot.performAt = timeWindow.
      • preferred_life_cycle - (Optional, Enum "od", "spot", Default "spot") The desired type of VM.
      • revert_to_spot - (Optional) Hold settings for strategy correction - replacing On-Demand for Spot VMs.
        • perform_at - (Required, Enum "timeWindow", "never", "always", Default "always") Settings for maintenance strategy.
      • capacity_reservation - (Optional) On-demand Capacity Reservation group enables you to reserve Compute capacity in an Azure region or an Availability Zone for any duration of time. CRG can only be created on the Azure end.
        • should_utilize - (Required) Determines whether capacity reservations should be utilized.
        • utilization_strategy - (Required, Enum "utilizeOverSpot", "utilizeOverOD") The priority requested for using CRG. This value will determine if CRG is used ahead of spot VMs or On-demand VMs. ("utilizeOverOD"- If picked, we will use CRG only in case On demand should be launched. "utilizeOverSpot"- CRG will be preferred over Spot. Only after CRG is fully used, spot VMs can be used.)
        • capacity_reservation_groups - (Optional) List of the desired CRGs to use under the associated Azure subscription. When null we will utilize any available reservation that matches the launch specification.
          • crg_name - (Required) The name of the CRG.
          • crg_resource_group_name - (Required) Azure resource group name
          • crg_should_prioritize - The desired CRG to utilize ahead of other CRGs in the subscription.

    Compute

    • os - (Required, Enum "Linux", "Windows") Type of operating system.
    • od_sizes - (Required) Available On-Demand sizes.
    • spot_sizes - (Required) Available Spot-VM sizes.
    • preferred_spot_sizes - (Optional) Prioritize Spot VM sizes when launching Spot VMs for the group. If set, must be a sublist of compute.vmSizes.spotSizes.
    • zones - (Optional, Enum "1", "2", "3") List of Azure Availability Zones in the defined region. If not defined, Virtual machines will be launched regionally.
    • preferred_zone - (Optional, Enum "1", "2", "3") The AZ to prioritize when launching VMs. If no markets are available in the Preferred AZ, VMs are launched in the non-preferred AZ. Must be a sublist of compute.zones.
    • custom_data - (Optional) This value will hold the YAML in base64 and will be executed upon VM launch.
    • shutdown_script - (Optional) Shutdown script for the stateful node. Value should be passed as a string encoded at Base64 only.
    • user_data - (Optional) Define a set of scripts or other metadata that’s inserted to an Azure virtual machine at provision time. (Base64 encoded)
    • vm_name - (Optional) Set a VM name that will be persisted throughout the entire node lifecycle.

    Boot Diagnostics

    • boot_diagnostics
      • is_enabled - (Optional) Allows you to enable and disable the configuration of boot diagnostics at launch.
      • storage_url - (Optional) The storage URI that is used if a type is unmanaged. The storage URI must follow the blob storage URI format (“https://.blob.core.windows.net/”). StorageUri is required if the type is unmanaged. StorageUri must be ‘null’ in case the boot diagnostics type is managed.
      • type - (Optional, Enum "managed", "unmanaged") Defines the storage type on VM launch in Azure.

    Data Disks

    • data_disk - (Optional) The definitions of data disks that will be created and attached to the stateful node’s VM.
      • size_gb - (Required) The size of the data disk in GB, required if dataDisks is specified.
      • lun - (Required) The LUN of the data disk.
      • type - (Required, Enum "Standard_LRS", "Premium_LRS", "StandardSSD_LRS", "UltraSSD_LRS") The type of the data disk.

    Extensions

    • extension - (Optional) An object for an azure extension.
      • name - (Required) Required on compute.launchSpecification.extensions object.
      • type - (Required) Required on compute.launchSpecification.extensions object.
      • publisher - (Required) Required on compute.launchSpecification.extensions object.
      • api_version - (Required) The API version of the extension. Required if extension specified.
      • minor_version_auto_upgrade - (Required) Required on compute.launchSpecification.extensions object.
      • protected_settings - (Optional) Object for protected settings.
      • public_settings - (Optional) Object for public settings.

    Image

    • image
      • marketplace_image - (Optional) Select an image from Azure’s Marketplace image catalogue. Required if the custom image or gallery image are not specified.
        • publisher - (Required) Image publisher.
        • offer - (Required) Image offer.
        • sku - (Required) Image Stock Keeping Unit, which is the specific version of the image.
        • version - (Required, Default "latest") Image’s version. if version not provided we use “latest”.
      • gallery_image - (Optional) Gallery image definitions. Required if custom image or marketplace image are not specified.
        • gallery_resource_group_name - (Required) The resource group name for gallery image.
        • gallery_name - (Required) Name of the gallery.
        • image_name - (Required) Name of the gallery image.
        • version_name - (Required) Image’s version. Can be in the format x.x.x or ’latest'.
      • custom_image - (Optional) Custom image definitions. Required if marketplace image or gallery image are not specified.
        • custom_image_resource_group_name - (Required) The resource group name for custom image.
        • name - (Required) The name of the custom image.

    Load Balancer

    • load_balancer - (Optional) Add a load balancer. For Azure Gateway, each Backend Pool is a separate load balancer.
      • type - (Required, Enum "loadBalancer", "applicationGateway") The type of load balancer.
      • resource_group_name - (Required) The Resource Group name of the Load Balancer.
      • name - (Required) Name of the Application Gateway/Load Balancer.
      • sku - (Optional)
        • if type is "LoadBalancer" then possible values are “Standard", "Basic”.
        • If ApplicationGateway then possible values are “Standard_Large”, “Standard_Medium”, “Standard_Small”, “Standard_v2", “WAF_Large”, “WAF_Medium", “WAF_v2".
      • backend_pool_names - (Optional) Name of the Backend Pool to register the Stateful Node VMs to. Each Backend Pool is a separate load balancer. Required if Type is APPLICATION_GATEWAY.

    Login

    • login - (Required) Set admin access for accessing your VMs. Password/SSH is required for Linux.
      • user_name - (Required) username for admin access to VMs.
      • ssh_public_key - (Optional) SSH for admin access to Linux VMs. Optional for Linux.
      • password - (Optional) Password for admin access to Windows VMs. Required for Windows.

    Managed Service Identities

    • managed_service_identities - (Optional) Add a user-assigned managed identity to the Stateful Node’s VM.
      • name - (Required) name of the managed identity.
      • resource_group_name - (Required) The Resource Group that the user-assigned managed identity resides in.

    Proximity Placement Groups

    • proximity_placement_groups - (Optional) Defines the proximity placement group in which the VM will be launched.
      • name - (Required) name of the proximity placement group.
      • resource_group_name - (Required) The Resource Group name of the proximity placement group.

    Network

    • network - (Required) Define the Virtual Network and Subnet for your Stateful Node.
      • network_resource_group_name - (Required) Vnet Resource Group Name.
      • virtual_network_name - (Required) Virtual Network.
      • network_interface - (Required) Define a network interface
        • is_primary - (Required) Defines whether the network interface is primary or not.
        • subnet_name - (Required) Subnet name.
        • assign_public_ip - (Optional) Assign public IP.
        • public_ip_sku - (Optional) Required if assignPublicIp=true values=[Standard/Basic].
        • network_security_group - (Optional) Network Security Group.
          • network_resource_group_name - (Required) Requires valid security group name.
          • name - (Required) Requires valid resource group name.
        • enable_ip_forwarding - (Optional) Enable IP Forwarding.
        • private_ip_addresses - (Optional) A list with unique items that every item is a valid IP.
        • additional_ip_configurations - (Optional) Additional configuration of network interface.
          • name - (Required) Configuration name.
          • private_ip_address_version - (Required, Enum "IPv4", "IPv6" Default "IPv4") Version of the private IP address.
        • public_ips - (Optional) Defined a pool of Public Ips (from Azure), that will be associated to the network interface. We will associate one public ip per instance until the pool is exhausted, in which case, we will create a new one.
          • resource_group_name - (Required) The resource group of the public ip.
          • name - (Required) - The name of the public ip.
        • application_security_groups - (Optional) Network Security Group.
          • resource_group_name - (Required) Requires valid security group name.
          • name - (Required) Requires valid resource group name.

    OS Disk

    • os_disk - (Optional) Specify OS disk specification other than default.
      • size_gb - (Optional, Default "30") The size of the data disk in GB.
      • type - (Required, Enum "Standard_LRS", "Premium_LRS", "StandardSSD_LRS") The type of the OS disk.

    Secret

    • secret - (Optional) Set of certificates that should be installed on the VM.
      • source_vault - (Required) The key vault reference, contains the required certificates.
        • name - (Required) The name of the key vault.
        • resource_group_name - (Required) The resource group name of the key vault.
      • vault_certificates - (Required) The required certificate references.
        • certificate_url - (Optional) The URL of the certificate under the key vault.
        • certificate_store - (Required) The certificate store directory the VM. The directory is created in the LocalMachine account.
          • This field is required only when using Windows OS type
          • This field must be ‘null’ when the OS type is Linux

    Security

    • security - (Optional) Specifies the Security related profile settings for the virtual machine.
      • secure_boot_enabled - (Optional) Specifies whether secure boot should be enabled on the virtual machine.
      • security_type - (Optional) Enum: "Standard", "TrustedLaunch" Security type refers to the different security features of a virtual machine. Security features like Trusted launch virtual machines help to improve the security of Azure generation 2 virtual machines.
      • vtpm_enabled - (Optional) Specifies whether vTPM should be enabled on the virtual machine.

    Tag

    • tag - (Optional) Unique Key-Value pair for all Stateful Node Resources.
      • tag_key - (Optional) Tag Key for Stateful Node Resources.
      • tag_value - (Optional) Tag Value for Stateful Node Resources.

    Health

    • health - (Optional) Set the auto healing preferences for unhealthy VMs.
      • health_check_types - (Optional, Enum "vmState", "applicationGateway") Healthcheck to use to validate VM health.
      • unhealthy_duration - (Optional) Amount of time to be unhealthy before a replacement is triggered.
      • auto_healing - (Required) Enable Autohealing of unhealthy VMs.
      • grace_period - (Optional) Period of time to wait for VM to reach healthiness before monitoring for unhealthiness.

    Persistence

    • should_persist_os_disk - (Required) Should persist os disk.
    • os_disk_persistence_mode - (Optional, Enum "reattach", "onLaunch")
    • should_persist_data_disks - (Required) Should persist data disks.
    • data_disks_persistence_mode - (Optional, Enum "reattach", "onLaunch")
    • should_persist_network - (Required) Should persist network.

    Scheduling Tasks

    • scheduling_task - (Optional) Scheduling settings object for stateful node.
      • is_enabled - (Required) Is scheduled task enabled for stateful node.
      • type - (Required, Enum `“pause”, “resume”, “recycle”) The type of the scheduled task
      • cron_expression (Required) A expression which describes when to execute the scheduled task (UTC).

    Signals

    • signal - (Optional) A signal object defined for the stateful node.
      • type - (Required, Enum "vmReady", "vmReadyToShutdown") The type of the signal defined for the stateful node.
      • timeout - (Required, Default "1800") The timeout in seconds to hold the vm until a signal is sent. If no signal is sent the vm will be replaced (vmReady) or we will terminate the vm (vmReadyToShutdown) after the timeout.

    Attach Data Disk

    • attach_data_disk - (Optional) Create a new data disk and attach it to the stateful node.
      • data_disk_name - (Required) The name of the created data disk.
      • data_disk_resource_group_name - (Required) The resource group name in which the data disk will be created.
      • storage_account_type - (Required, Enum "Standard_LRS", "Premium_LRS", "StandardSSD_LRS", "UltraSSD_LRS") The type of the data disk.
      • size_gb - (Required) The size of the data disk in GB, Required if dataDisks is specified.
      • zone - (Optional, Enum "1", "2", "3") The Availability Zone in which the data disk will be created. If not defined, the data disk will be created regionally.
      • lun - (Optional, Default "orginal") The LUN of the data disk. If not defined, the LUN will be set in order.

    Detach Data Disk

    • detach_data_disk - (Optional) Detach a data disk from a stateful node.
      • data_disk_name - (Required) The name of the detached data disk.
      • data_disk_resource_group_name - (Required) The resource group name in which the data disk exists.
      • should_deallocate - (Required) Indicates whether to delete the data disk in addition to detach.
      • ttl_in_hours - (Required, Default "0") Hours to keep the disk alive before deletion.

    Update State

    • update_state - (Optional) Update the stateful node state.
      • state - (Required, Enum "pause", "resume", "recycle") New state for the stateful node.

    Import VM

    • import_vm - (Optional) Import an Azure VM and create a stateful node by providing a node configuration.
      • resource_group_name - (Required) Name of the Resource Group for Stateful Node.
      • original_vm_name - (Required) Azure Import Stateful Node Name.
      • draining_timeout - (Optional) Hours to keep resources alive.
      • resources_retention_time - (Optional) Hours to keep resources alive.

    Deallocation Config

    • delete - (Required) Specify deallocation parameters for stateful node deletion.
      • should_terminate_vm - (Required) Indicates whether to delete the stateful node’s VM.
      • network_should_deallocate - (Required) Indicates whether to delete the stateful node’s network resources.
      • network_ttl_in_hours - (Optional, Default: 96) Hours to keep the network resource alive before deletion.
      • disk_should_deallocate - (Required) Indicates whether to delete the stateful node’s disk resources.
      • disk_ttl_in_hours - (Optional, Default: 96) Hours to keep the disk resource alive before deletion.
      • snapshot_should_deallocate - (Required) Indicates whether to delete the stateful node’s snapshot resources.
      • snapshot_ttl_in_hours - (Optional, Default: 96) Hours to keep the snapshots alive before deletion.
      • public_ip_should_deallocate - (Required) Indicates whether to delete the stateful node’s public ip resources.
      • public_ip_ttl_in_hours - (Optional, Default: 96) Hours to keep the public ip alive before deletion.

    Example Usage

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using SpotInst = Pulumi.SpotInst;
    
    return await Deployment.RunAsync(() => 
    {
        var testStatefulNodeAzure = new SpotInst.StatefulNodeAzure("testStatefulNodeAzure", new()
        {
            Region = "eastus",
            ResourceGroupName = "spotinst-azure",
            Description = "example_stateful_node_azure_description",
            Strategy = new SpotInst.Inputs.StatefulNodeAzureStrategyArgs
            {
                DrainingTimeout = 30,
                FallbackToOnDemand = true,
                OptimizationWindows = new[]
                {
                    "Tue:19:46-Tue:20:46",
                },
                RevertToSpot = new SpotInst.Inputs.StatefulNodeAzureStrategyRevertToSpotArgs
                {
                    PerformAt = "timeWindow",
                },
                PreferredLifeCycle = "od",
                CapacityReservations = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureStrategyCapacityReservationArgs
                    {
                        ShouldUtilize = true,
                        UtilizationStrategy = "utilizeOverOD",
                        CapacityReservationGroups = new[]
                        {
                            new SpotInst.Inputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs
                            {
                                CrgName = "crg name",
                                CrgResourceGroupName = "resourceGroupName",
                                CrgShouldPrioritize = true,
                            },
                        },
                    },
                },
            },
            Os = "Linux",
            OdSizes = new[]
            {
                "standard_ds1_v2",
                "standard_ds2_v2",
            },
            SpotSizes = new[]
            {
                "standard_ds1_v2",
                "standard_ds2_v2",
            },
            PreferredSpotSizes = new[]
            {
                "standard_ds1_v2",
            },
            Zones = new[]
            {
                "1",
                "3",
            },
            PreferredZone = "1",
            CustomData = "",
            ShutdownScript = "",
            UserData = "",
            VmName = "VMName",
            BootDiagnostics = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureBootDiagnosticArgs
                {
                    IsEnabled = true,
                    StorageUrl = "https://.blob.core.windows.net/test",
                    Type = "unmanaged",
                },
            },
            DataDisks = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureDataDiskArgs
                {
                    SizeGb = 1,
                    Lun = 1,
                    Type = "Standard_LRS",
                },
                new SpotInst.Inputs.StatefulNodeAzureDataDiskArgs
                {
                    SizeGb = 10,
                    Lun = 2,
                    Type = "Standard_LRS",
                },
            },
            Extensions = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureExtensionArgs
                {
                    Name = "extensionName",
                    Type = "customScript",
                    Publisher = "Microsoft.Azure.Extensions",
                    ApiVersion = "2.0",
                    MinorVersionAutoUpgrade = true,
                    ProtectedSettings = 
                    {
                        { "script", "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==" },
                    },
                },
            },
            Image = new SpotInst.Inputs.StatefulNodeAzureImageArgs
            {
                MarketplaceImages = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureImageMarketplaceImageArgs
                    {
                        Publisher = "Canonical",
                        Offer = "UbuntuServer",
                        Sku = "16.04-LTS",
                        Version = "latest",
                    },
                },
            },
            LoadBalancers = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureLoadBalancerArgs
                {
                    Type = "loadBalancer",
                    ResourceGroupName = "testResourceGroup",
                    Name = "testLoadBalancer",
                    Sku = "Standard",
                    BackendPoolNames = new[]
                    {
                        "testBackendPool1",
                        "testBackendPool2",
                    },
                },
            },
            Login = new SpotInst.Inputs.StatefulNodeAzureLoginArgs
            {
                UserName = "admin",
                SshPublicKey = "33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
            },
            ManagedServiceIdentities = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureManagedServiceIdentityArgs
                {
                    Name = "mySI2",
                    ResourceGroupName = "myResourceGroup",
                },
            },
            Network = new SpotInst.Inputs.StatefulNodeAzureNetworkArgs
            {
                NetworkResourceGroupName = "subnetResourceGroup",
                VirtualNetworkName = "vname",
                NetworkInterfaces = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceArgs
                    {
                        IsPrimary = true,
                        SubnetName = "testSubnet",
                        AssignPublicIp = true,
                        PublicIpSku = "Standard",
                        NetworkSecurityGroups = new[]
                        {
                            new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs
                            {
                                NetworkResourceGroupName = "test",
                                Name = "test",
                            },
                        },
                        EnableIpForwarding = true,
                        PrivateIpAddresses = new[]
                        {
                            "172.23.4.20",
                        },
                        AdditionalIpConfigurations = new[]
                        {
                            new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs
                            {
                                Name = "test",
                                PrivateIpAddressVersion = "IPv4",
                            },
                        },
                        PublicIps = new[]
                        {
                            new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs
                            {
                                NetworkResourceGroupName = "resourceGroup",
                                Name = "test",
                            },
                        },
                        ApplicationSecurityGroups = new[]
                        {
                            new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs
                            {
                                NetworkResourceGroupName = "AsgResourceGroup",
                                Name = "AsgName",
                            },
                        },
                    },
                },
            },
            OsDisk = new SpotInst.Inputs.StatefulNodeAzureOsDiskArgs
            {
                SizeGb = 30,
                Type = "Standard_LRS",
            },
            Secrets = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureSecretArgs
                {
                    SourceVaults = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureSecretSourceVaultArgs
                        {
                            Name = "string",
                            ResourceGroupName = "string",
                        },
                    },
                    VaultCertificates = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureSecretVaultCertificateArgs
                        {
                            CertificateUrl = "string",
                            CertificateStore = "string",
                        },
                    },
                },
            },
            Security = new SpotInst.Inputs.StatefulNodeAzureSecurityArgs
            {
                SecurityType = "Standard",
                SecureBootEnabled = false,
                VtpmEnabled = false,
            },
            Tags = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureTagArgs
                {
                    TagKey = "Creator",
                    TagValue = "string",
                },
            },
            Health = new SpotInst.Inputs.StatefulNodeAzureHealthArgs
            {
                HealthCheckTypes = new[]
                {
                    "vmState",
                },
                UnhealthyDuration = 300,
                GracePeriod = 120,
                AutoHealing = true,
            },
            ShouldPersistOsDisk = false,
            OsDiskPersistenceMode = "reattach",
            ShouldPersistDataDisks = true,
            DataDisksPersistenceMode = "reattach",
            ShouldPersistNetwork = true,
            SchedulingTasks = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
                {
                    IsEnabled = true,
                    Type = "pause",
                    CronExpression = "44 10 * * *",
                },
                new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
                {
                    IsEnabled = true,
                    Type = "resume",
                    CronExpression = "48 10 * * *",
                },
                new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
                {
                    IsEnabled = true,
                    Type = "recycle",
                    CronExpression = "52 10 * * *",
                },
            },
            Signals = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureSignalArgs
                {
                    Type = "vmReady",
                    Timeout = 20,
                },
                new SpotInst.Inputs.StatefulNodeAzureSignalArgs
                {
                    Type = "vmReady",
                    Timeout = 40,
                },
            },
            ProximityPlacementGroups = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureProximityPlacementGroupArgs
                {
                    Name = "TestPPG",
                    ResourceGroupName = "TestResourceGroup",
                },
            },
            Deletes = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureDeleteArgs
                {
                    ShouldTerminateVm = true,
                    NetworkShouldDeallocate = true,
                    NetworkTtlInHours = 0,
                    DiskShouldDeallocate = true,
                    DiskTtlInHours = 0,
                    SnapshotShouldDeallocate = true,
                    SnapshotTtlInHours = 0,
                    PublicIpShouldDeallocate = true,
                    PublicIpTtlInHours = 0,
                },
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-spotinst/sdk/v3/go/spotinst"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := spotinst.NewStatefulNodeAzure(ctx, "testStatefulNodeAzure", &spotinst.StatefulNodeAzureArgs{
    			Region:            pulumi.String("eastus"),
    			ResourceGroupName: pulumi.String("spotinst-azure"),
    			Description:       pulumi.String("example_stateful_node_azure_description"),
    			Strategy: &spotinst.StatefulNodeAzureStrategyArgs{
    				DrainingTimeout:    pulumi.Int(30),
    				FallbackToOnDemand: pulumi.Bool(true),
    				OptimizationWindows: pulumi.StringArray{
    					pulumi.String("Tue:19:46-Tue:20:46"),
    				},
    				RevertToSpot: &spotinst.StatefulNodeAzureStrategyRevertToSpotArgs{
    					PerformAt: pulumi.String("timeWindow"),
    				},
    				PreferredLifeCycle: pulumi.String("od"),
    				CapacityReservations: spotinst.StatefulNodeAzureStrategyCapacityReservationArray{
    					&spotinst.StatefulNodeAzureStrategyCapacityReservationArgs{
    						ShouldUtilize:       pulumi.Bool(true),
    						UtilizationStrategy: pulumi.String("utilizeOverOD"),
    						CapacityReservationGroups: spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArray{
    							&spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs{
    								CrgName:              pulumi.String("crg name"),
    								CrgResourceGroupName: pulumi.String("resourceGroupName"),
    								CrgShouldPrioritize:  pulumi.Bool(true),
    							},
    						},
    					},
    				},
    			},
    			Os: pulumi.String("Linux"),
    			OdSizes: pulumi.StringArray{
    				pulumi.String("standard_ds1_v2"),
    				pulumi.String("standard_ds2_v2"),
    			},
    			SpotSizes: pulumi.StringArray{
    				pulumi.String("standard_ds1_v2"),
    				pulumi.String("standard_ds2_v2"),
    			},
    			PreferredSpotSizes: pulumi.StringArray{
    				pulumi.String("standard_ds1_v2"),
    			},
    			Zones: pulumi.StringArray{
    				pulumi.String("1"),
    				pulumi.String("3"),
    			},
    			PreferredZone:  pulumi.String("1"),
    			CustomData:     pulumi.String(""),
    			ShutdownScript: pulumi.String(""),
    			UserData:       pulumi.String(""),
    			VmName:         pulumi.String("VMName"),
    			BootDiagnostics: spotinst.StatefulNodeAzureBootDiagnosticArray{
    				&spotinst.StatefulNodeAzureBootDiagnosticArgs{
    					IsEnabled:  pulumi.Bool(true),
    					StorageUrl: pulumi.String("https://.blob.core.windows.net/test"),
    					Type:       pulumi.String("unmanaged"),
    				},
    			},
    			DataDisks: spotinst.StatefulNodeAzureDataDiskArray{
    				&spotinst.StatefulNodeAzureDataDiskArgs{
    					SizeGb: pulumi.Int(1),
    					Lun:    pulumi.Int(1),
    					Type:   pulumi.String("Standard_LRS"),
    				},
    				&spotinst.StatefulNodeAzureDataDiskArgs{
    					SizeGb: pulumi.Int(10),
    					Lun:    pulumi.Int(2),
    					Type:   pulumi.String("Standard_LRS"),
    				},
    			},
    			Extensions: spotinst.StatefulNodeAzureExtensionArray{
    				&spotinst.StatefulNodeAzureExtensionArgs{
    					Name:                    pulumi.String("extensionName"),
    					Type:                    pulumi.String("customScript"),
    					Publisher:               pulumi.String("Microsoft.Azure.Extensions"),
    					ApiVersion:              pulumi.String("2.0"),
    					MinorVersionAutoUpgrade: pulumi.Bool(true),
    					ProtectedSettings: pulumi.Map{
    						"script": pulumi.Any("IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg=="),
    					},
    				},
    			},
    			Image: &spotinst.StatefulNodeAzureImageArgs{
    				MarketplaceImages: spotinst.StatefulNodeAzureImageMarketplaceImageArray{
    					&spotinst.StatefulNodeAzureImageMarketplaceImageArgs{
    						Publisher: pulumi.String("Canonical"),
    						Offer:     pulumi.String("UbuntuServer"),
    						Sku:       pulumi.String("16.04-LTS"),
    						Version:   pulumi.String("latest"),
    					},
    				},
    			},
    			LoadBalancers: spotinst.StatefulNodeAzureLoadBalancerArray{
    				&spotinst.StatefulNodeAzureLoadBalancerArgs{
    					Type:              pulumi.String("loadBalancer"),
    					ResourceGroupName: pulumi.String("testResourceGroup"),
    					Name:              pulumi.String("testLoadBalancer"),
    					Sku:               pulumi.String("Standard"),
    					BackendPoolNames: pulumi.StringArray{
    						pulumi.String("testBackendPool1"),
    						pulumi.String("testBackendPool2"),
    					},
    				},
    			},
    			Login: &spotinst.StatefulNodeAzureLoginArgs{
    				UserName:     pulumi.String("admin"),
    				SshPublicKey: pulumi.String("33a2s1f3g5a1df5g1ad3f2g1adfg56dfg=="),
    			},
    			ManagedServiceIdentities: spotinst.StatefulNodeAzureManagedServiceIdentityArray{
    				&spotinst.StatefulNodeAzureManagedServiceIdentityArgs{
    					Name:              pulumi.String("mySI2"),
    					ResourceGroupName: pulumi.String("myResourceGroup"),
    				},
    			},
    			Network: &spotinst.StatefulNodeAzureNetworkArgs{
    				NetworkResourceGroupName: pulumi.String("subnetResourceGroup"),
    				VirtualNetworkName:       pulumi.String("vname"),
    				NetworkInterfaces: spotinst.StatefulNodeAzureNetworkNetworkInterfaceArray{
    					&spotinst.StatefulNodeAzureNetworkNetworkInterfaceArgs{
    						IsPrimary:      pulumi.Bool(true),
    						SubnetName:     pulumi.String("testSubnet"),
    						AssignPublicIp: pulumi.Bool(true),
    						PublicIpSku:    pulumi.String("Standard"),
    						NetworkSecurityGroups: spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArray{
    							&spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs{
    								NetworkResourceGroupName: pulumi.String("test"),
    								Name:                     pulumi.String("test"),
    							},
    						},
    						EnableIpForwarding: pulumi.Bool(true),
    						PrivateIpAddresses: pulumi.StringArray{
    							pulumi.String("172.23.4.20"),
    						},
    						AdditionalIpConfigurations: spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArray{
    							&spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs{
    								Name:                    pulumi.String("test"),
    								PrivateIpAddressVersion: pulumi.String("IPv4"),
    							},
    						},
    						PublicIps: spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArray{
    							&spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs{
    								NetworkResourceGroupName: pulumi.String("resourceGroup"),
    								Name:                     pulumi.String("test"),
    							},
    						},
    						ApplicationSecurityGroups: spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArray{
    							&spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs{
    								NetworkResourceGroupName: pulumi.String("AsgResourceGroup"),
    								Name:                     pulumi.String("AsgName"),
    							},
    						},
    					},
    				},
    			},
    			OsDisk: &spotinst.StatefulNodeAzureOsDiskArgs{
    				SizeGb: pulumi.Int(30),
    				Type:   pulumi.String("Standard_LRS"),
    			},
    			Secrets: spotinst.StatefulNodeAzureSecretArray{
    				&spotinst.StatefulNodeAzureSecretArgs{
    					SourceVaults: spotinst.StatefulNodeAzureSecretSourceVaultArray{
    						&spotinst.StatefulNodeAzureSecretSourceVaultArgs{
    							Name:              pulumi.String("string"),
    							ResourceGroupName: pulumi.String("string"),
    						},
    					},
    					VaultCertificates: spotinst.StatefulNodeAzureSecretVaultCertificateArray{
    						&spotinst.StatefulNodeAzureSecretVaultCertificateArgs{
    							CertificateUrl:   pulumi.String("string"),
    							CertificateStore: pulumi.String("string"),
    						},
    					},
    				},
    			},
    			Security: &spotinst.StatefulNodeAzureSecurityArgs{
    				SecurityType:      pulumi.String("Standard"),
    				SecureBootEnabled: pulumi.Bool(false),
    				VtpmEnabled:       pulumi.Bool(false),
    			},
    			Tags: spotinst.StatefulNodeAzureTagArray{
    				&spotinst.StatefulNodeAzureTagArgs{
    					TagKey:   pulumi.String("Creator"),
    					TagValue: pulumi.String("string"),
    				},
    			},
    			Health: &spotinst.StatefulNodeAzureHealthArgs{
    				HealthCheckTypes: pulumi.StringArray{
    					pulumi.String("vmState"),
    				},
    				UnhealthyDuration: pulumi.Int(300),
    				GracePeriod:       pulumi.Int(120),
    				AutoHealing:       pulumi.Bool(true),
    			},
    			ShouldPersistOsDisk:      pulumi.Bool(false),
    			OsDiskPersistenceMode:    pulumi.String("reattach"),
    			ShouldPersistDataDisks:   pulumi.Bool(true),
    			DataDisksPersistenceMode: pulumi.String("reattach"),
    			ShouldPersistNetwork:     pulumi.Bool(true),
    			SchedulingTasks: spotinst.StatefulNodeAzureSchedulingTaskArray{
    				&spotinst.StatefulNodeAzureSchedulingTaskArgs{
    					IsEnabled:      pulumi.Bool(true),
    					Type:           pulumi.String("pause"),
    					CronExpression: pulumi.String("44 10 * * *"),
    				},
    				&spotinst.StatefulNodeAzureSchedulingTaskArgs{
    					IsEnabled:      pulumi.Bool(true),
    					Type:           pulumi.String("resume"),
    					CronExpression: pulumi.String("48 10 * * *"),
    				},
    				&spotinst.StatefulNodeAzureSchedulingTaskArgs{
    					IsEnabled:      pulumi.Bool(true),
    					Type:           pulumi.String("recycle"),
    					CronExpression: pulumi.String("52 10 * * *"),
    				},
    			},
    			Signals: spotinst.StatefulNodeAzureSignalArray{
    				&spotinst.StatefulNodeAzureSignalArgs{
    					Type:    pulumi.String("vmReady"),
    					Timeout: pulumi.Int(20),
    				},
    				&spotinst.StatefulNodeAzureSignalArgs{
    					Type:    pulumi.String("vmReady"),
    					Timeout: pulumi.Int(40),
    				},
    			},
    			ProximityPlacementGroups: spotinst.StatefulNodeAzureProximityPlacementGroupArray{
    				&spotinst.StatefulNodeAzureProximityPlacementGroupArgs{
    					Name:              pulumi.String("TestPPG"),
    					ResourceGroupName: pulumi.String("TestResourceGroup"),
    				},
    			},
    			Deletes: spotinst.StatefulNodeAzureDeleteArray{
    				&spotinst.StatefulNodeAzureDeleteArgs{
    					ShouldTerminateVm:        pulumi.Bool(true),
    					NetworkShouldDeallocate:  pulumi.Bool(true),
    					NetworkTtlInHours:        pulumi.Int(0),
    					DiskShouldDeallocate:     pulumi.Bool(true),
    					DiskTtlInHours:           pulumi.Int(0),
    					SnapshotShouldDeallocate: pulumi.Bool(true),
    					SnapshotTtlInHours:       pulumi.Int(0),
    					PublicIpShouldDeallocate: pulumi.Bool(true),
    					PublicIpTtlInHours:       pulumi.Int(0),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.spotinst.StatefulNodeAzure;
    import com.pulumi.spotinst.StatefulNodeAzureArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureStrategyArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureStrategyRevertToSpotArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureBootDiagnosticArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureDataDiskArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureExtensionArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureImageArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureLoadBalancerArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureLoginArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureManagedServiceIdentityArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureNetworkArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureOsDiskArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureSecretArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureSecurityArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureTagArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureHealthArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureSchedulingTaskArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureSignalArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureProximityPlacementGroupArgs;
    import com.pulumi.spotinst.inputs.StatefulNodeAzureDeleteArgs;
    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 testStatefulNodeAzure = new StatefulNodeAzure("testStatefulNodeAzure", StatefulNodeAzureArgs.builder()        
                .region("eastus")
                .resourceGroupName("spotinst-azure")
                .description("example_stateful_node_azure_description")
                .strategy(StatefulNodeAzureStrategyArgs.builder()
                    .drainingTimeout(30)
                    .fallbackToOnDemand(true)
                    .optimizationWindows("Tue:19:46-Tue:20:46")
                    .revertToSpot(StatefulNodeAzureStrategyRevertToSpotArgs.builder()
                        .performAt("timeWindow")
                        .build())
                    .preferredLifeCycle("od")
                    .capacityReservations(StatefulNodeAzureStrategyCapacityReservationArgs.builder()
                        .shouldUtilize(true)
                        .utilizationStrategy("utilizeOverOD")
                        .capacityReservationGroups(StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs.builder()
                            .crgName("crg name")
                            .crgResourceGroupName("resourceGroupName")
                            .crgShouldPrioritize(true)
                            .build())
                        .build())
                    .build())
                .os("Linux")
                .odSizes(            
                    "standard_ds1_v2",
                    "standard_ds2_v2")
                .spotSizes(            
                    "standard_ds1_v2",
                    "standard_ds2_v2")
                .preferredSpotSizes("standard_ds1_v2")
                .zones(            
                    "1",
                    "3")
                .preferredZone("1")
                .customData("")
                .shutdownScript("")
                .userData("")
                .vmName("VMName")
                .bootDiagnostics(StatefulNodeAzureBootDiagnosticArgs.builder()
                    .isEnabled(true)
                    .storageUrl("https://.blob.core.windows.net/test")
                    .type("unmanaged")
                    .build())
                .dataDisks(            
                    StatefulNodeAzureDataDiskArgs.builder()
                        .sizeGb(1)
                        .lun(1)
                        .type("Standard_LRS")
                        .build(),
                    StatefulNodeAzureDataDiskArgs.builder()
                        .sizeGb(10)
                        .lun(2)
                        .type("Standard_LRS")
                        .build())
                .extensions(StatefulNodeAzureExtensionArgs.builder()
                    .name("extensionName")
                    .type("customScript")
                    .publisher("Microsoft.Azure.Extensions")
                    .apiVersion("2.0")
                    .minorVersionAutoUpgrade(true)
                    .protectedSettings(Map.of("script", "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg=="))
                    .build())
                .image(StatefulNodeAzureImageArgs.builder()
                    .marketplaceImages(StatefulNodeAzureImageMarketplaceImageArgs.builder()
                        .publisher("Canonical")
                        .offer("UbuntuServer")
                        .sku("16.04-LTS")
                        .version("latest")
                        .build())
                    .build())
                .loadBalancers(StatefulNodeAzureLoadBalancerArgs.builder()
                    .type("loadBalancer")
                    .resourceGroupName("testResourceGroup")
                    .name("testLoadBalancer")
                    .sku("Standard")
                    .backendPoolNames(                
                        "testBackendPool1",
                        "testBackendPool2")
                    .build())
                .login(StatefulNodeAzureLoginArgs.builder()
                    .userName("admin")
                    .sshPublicKey("33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==")
                    .build())
                .managedServiceIdentities(StatefulNodeAzureManagedServiceIdentityArgs.builder()
                    .name("mySI2")
                    .resourceGroupName("myResourceGroup")
                    .build())
                .network(StatefulNodeAzureNetworkArgs.builder()
                    .networkResourceGroupName("subnetResourceGroup")
                    .virtualNetworkName("vname")
                    .networkInterfaces(StatefulNodeAzureNetworkNetworkInterfaceArgs.builder()
                        .isPrimary(true)
                        .subnetName("testSubnet")
                        .assignPublicIp(true)
                        .publicIpSku("Standard")
                        .networkSecurityGroups(StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs.builder()
                            .networkResourceGroupName("test")
                            .name("test")
                            .build())
                        .enableIpForwarding(true)
                        .privateIpAddresses("172.23.4.20")
                        .additionalIpConfigurations(StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs.builder()
                            .name("test")
                            .privateIpAddressVersion("IPv4")
                            .build())
                        .publicIps(StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs.builder()
                            .networkResourceGroupName("resourceGroup")
                            .name("test")
                            .build())
                        .applicationSecurityGroups(StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs.builder()
                            .networkResourceGroupName("AsgResourceGroup")
                            .name("AsgName")
                            .build())
                        .build())
                    .build())
                .osDisk(StatefulNodeAzureOsDiskArgs.builder()
                    .sizeGb(30)
                    .type("Standard_LRS")
                    .build())
                .secrets(StatefulNodeAzureSecretArgs.builder()
                    .sourceVaults(StatefulNodeAzureSecretSourceVaultArgs.builder()
                        .name("string")
                        .resourceGroupName("string")
                        .build())
                    .vaultCertificates(StatefulNodeAzureSecretVaultCertificateArgs.builder()
                        .certificateUrl("string")
                        .certificateStore("string")
                        .build())
                    .build())
                .security(StatefulNodeAzureSecurityArgs.builder()
                    .securityType("Standard")
                    .secureBootEnabled(false)
                    .vtpmEnabled(false)
                    .build())
                .tags(StatefulNodeAzureTagArgs.builder()
                    .tagKey("Creator")
                    .tagValue("string")
                    .build())
                .health(StatefulNodeAzureHealthArgs.builder()
                    .healthCheckTypes("vmState")
                    .unhealthyDuration(300)
                    .gracePeriod(120)
                    .autoHealing(true)
                    .build())
                .shouldPersistOsDisk(false)
                .osDiskPersistenceMode("reattach")
                .shouldPersistDataDisks(true)
                .dataDisksPersistenceMode("reattach")
                .shouldPersistNetwork(true)
                .schedulingTasks(            
                    StatefulNodeAzureSchedulingTaskArgs.builder()
                        .isEnabled(true)
                        .type("pause")
                        .cronExpression("44 10 * * *")
                        .build(),
                    StatefulNodeAzureSchedulingTaskArgs.builder()
                        .isEnabled(true)
                        .type("resume")
                        .cronExpression("48 10 * * *")
                        .build(),
                    StatefulNodeAzureSchedulingTaskArgs.builder()
                        .isEnabled(true)
                        .type("recycle")
                        .cronExpression("52 10 * * *")
                        .build())
                .signals(            
                    StatefulNodeAzureSignalArgs.builder()
                        .type("vmReady")
                        .timeout(20)
                        .build(),
                    StatefulNodeAzureSignalArgs.builder()
                        .type("vmReady")
                        .timeout(40)
                        .build())
                .proximityPlacementGroups(StatefulNodeAzureProximityPlacementGroupArgs.builder()
                    .name("TestPPG")
                    .resourceGroupName("TestResourceGroup")
                    .build())
                .deletes(StatefulNodeAzureDeleteArgs.builder()
                    .shouldTerminateVm(true)
                    .networkShouldDeallocate(true)
                    .networkTtlInHours(0)
                    .diskShouldDeallocate(true)
                    .diskTtlInHours(0)
                    .snapshotShouldDeallocate(true)
                    .snapshotTtlInHours(0)
                    .publicIpShouldDeallocate(true)
                    .publicIpTtlInHours(0)
                    .build())
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_spotinst as spotinst
    
    test_stateful_node_azure = spotinst.StatefulNodeAzure("testStatefulNodeAzure",
        region="eastus",
        resource_group_name="spotinst-azure",
        description="example_stateful_node_azure_description",
        strategy=spotinst.StatefulNodeAzureStrategyArgs(
            draining_timeout=30,
            fallback_to_on_demand=True,
            optimization_windows=["Tue:19:46-Tue:20:46"],
            revert_to_spot=spotinst.StatefulNodeAzureStrategyRevertToSpotArgs(
                perform_at="timeWindow",
            ),
            preferred_life_cycle="od",
            capacity_reservations=[spotinst.StatefulNodeAzureStrategyCapacityReservationArgs(
                should_utilize=True,
                utilization_strategy="utilizeOverOD",
                capacity_reservation_groups=[spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs(
                    crg_name="crg name",
                    crg_resource_group_name="resourceGroupName",
                    crg_should_prioritize=True,
                )],
            )],
        ),
        os="Linux",
        od_sizes=[
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        spot_sizes=[
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        preferred_spot_sizes=["standard_ds1_v2"],
        zones=[
            "1",
            "3",
        ],
        preferred_zone="1",
        custom_data="",
        shutdown_script="",
        user_data="",
        vm_name="VMName",
        boot_diagnostics=[spotinst.StatefulNodeAzureBootDiagnosticArgs(
            is_enabled=True,
            storage_url="https://.blob.core.windows.net/test",
            type="unmanaged",
        )],
        data_disks=[
            spotinst.StatefulNodeAzureDataDiskArgs(
                size_gb=1,
                lun=1,
                type="Standard_LRS",
            ),
            spotinst.StatefulNodeAzureDataDiskArgs(
                size_gb=10,
                lun=2,
                type="Standard_LRS",
            ),
        ],
        extensions=[spotinst.StatefulNodeAzureExtensionArgs(
            name="extensionName",
            type="customScript",
            publisher="Microsoft.Azure.Extensions",
            api_version="2.0",
            minor_version_auto_upgrade=True,
            protected_settings={
                "script": "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==",
            },
        )],
        image=spotinst.StatefulNodeAzureImageArgs(
            marketplace_images=[spotinst.StatefulNodeAzureImageMarketplaceImageArgs(
                publisher="Canonical",
                offer="UbuntuServer",
                sku="16.04-LTS",
                version="latest",
            )],
        ),
        load_balancers=[spotinst.StatefulNodeAzureLoadBalancerArgs(
            type="loadBalancer",
            resource_group_name="testResourceGroup",
            name="testLoadBalancer",
            sku="Standard",
            backend_pool_names=[
                "testBackendPool1",
                "testBackendPool2",
            ],
        )],
        login=spotinst.StatefulNodeAzureLoginArgs(
            user_name="admin",
            ssh_public_key="33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
        ),
        managed_service_identities=[spotinst.StatefulNodeAzureManagedServiceIdentityArgs(
            name="mySI2",
            resource_group_name="myResourceGroup",
        )],
        network=spotinst.StatefulNodeAzureNetworkArgs(
            network_resource_group_name="subnetResourceGroup",
            virtual_network_name="vname",
            network_interfaces=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceArgs(
                is_primary=True,
                subnet_name="testSubnet",
                assign_public_ip=True,
                public_ip_sku="Standard",
                network_security_groups=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs(
                    network_resource_group_name="test",
                    name="test",
                )],
                enable_ip_forwarding=True,
                private_ip_addresses=["172.23.4.20"],
                additional_ip_configurations=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs(
                    name="test",
                    private_ip_address_version="IPv4",
                )],
                public_ips=[spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs(
                    network_resource_group_name="resourceGroup",
                    name="test",
                )],
                application_security_groups=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs(
                    network_resource_group_name="AsgResourceGroup",
                    name="AsgName",
                )],
            )],
        ),
        os_disk=spotinst.StatefulNodeAzureOsDiskArgs(
            size_gb=30,
            type="Standard_LRS",
        ),
        secrets=[spotinst.StatefulNodeAzureSecretArgs(
            source_vaults=[spotinst.StatefulNodeAzureSecretSourceVaultArgs(
                name="string",
                resource_group_name="string",
            )],
            vault_certificates=[spotinst.StatefulNodeAzureSecretVaultCertificateArgs(
                certificate_url="string",
                certificate_store="string",
            )],
        )],
        security=spotinst.StatefulNodeAzureSecurityArgs(
            security_type="Standard",
            secure_boot_enabled=False,
            vtpm_enabled=False,
        ),
        tags=[spotinst.StatefulNodeAzureTagArgs(
            tag_key="Creator",
            tag_value="string",
        )],
        health=spotinst.StatefulNodeAzureHealthArgs(
            health_check_types=["vmState"],
            unhealthy_duration=300,
            grace_period=120,
            auto_healing=True,
        ),
        should_persist_os_disk=False,
        os_disk_persistence_mode="reattach",
        should_persist_data_disks=True,
        data_disks_persistence_mode="reattach",
        should_persist_network=True,
        scheduling_tasks=[
            spotinst.StatefulNodeAzureSchedulingTaskArgs(
                is_enabled=True,
                type="pause",
                cron_expression="44 10 * * *",
            ),
            spotinst.StatefulNodeAzureSchedulingTaskArgs(
                is_enabled=True,
                type="resume",
                cron_expression="48 10 * * *",
            ),
            spotinst.StatefulNodeAzureSchedulingTaskArgs(
                is_enabled=True,
                type="recycle",
                cron_expression="52 10 * * *",
            ),
        ],
        signals=[
            spotinst.StatefulNodeAzureSignalArgs(
                type="vmReady",
                timeout=20,
            ),
            spotinst.StatefulNodeAzureSignalArgs(
                type="vmReady",
                timeout=40,
            ),
        ],
        proximity_placement_groups=[spotinst.StatefulNodeAzureProximityPlacementGroupArgs(
            name="TestPPG",
            resource_group_name="TestResourceGroup",
        )],
        deletes=[spotinst.StatefulNodeAzureDeleteArgs(
            should_terminate_vm=True,
            network_should_deallocate=True,
            network_ttl_in_hours=0,
            disk_should_deallocate=True,
            disk_ttl_in_hours=0,
            snapshot_should_deallocate=True,
            snapshot_ttl_in_hours=0,
            public_ip_should_deallocate=True,
            public_ip_ttl_in_hours=0,
        )])
    
    import * as pulumi from "@pulumi/pulumi";
    import * as spotinst from "@pulumi/spotinst";
    
    const testStatefulNodeAzure = new spotinst.StatefulNodeAzure("testStatefulNodeAzure", {
        region: "eastus",
        resourceGroupName: "spotinst-azure",
        description: "example_stateful_node_azure_description",
        strategy: {
            drainingTimeout: 30,
            fallbackToOnDemand: true,
            optimizationWindows: ["Tue:19:46-Tue:20:46"],
            revertToSpot: {
                performAt: "timeWindow",
            },
            preferredLifeCycle: "od",
            capacityReservations: [{
                shouldUtilize: true,
                utilizationStrategy: "utilizeOverOD",
                capacityReservationGroups: [{
                    crgName: "crg name",
                    crgResourceGroupName: "resourceGroupName",
                    crgShouldPrioritize: true,
                }],
            }],
        },
        os: "Linux",
        odSizes: [
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        spotSizes: [
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        preferredSpotSizes: ["standard_ds1_v2"],
        zones: [
            "1",
            "3",
        ],
        preferredZone: "1",
        customData: "",
        shutdownScript: "",
        userData: "",
        vmName: "VMName",
        bootDiagnostics: [{
            isEnabled: true,
            storageUrl: "https://.blob.core.windows.net/test",
            type: "unmanaged",
        }],
        dataDisks: [
            {
                sizeGb: 1,
                lun: 1,
                type: "Standard_LRS",
            },
            {
                sizeGb: 10,
                lun: 2,
                type: "Standard_LRS",
            },
        ],
        extensions: [{
            name: "extensionName",
            type: "customScript",
            publisher: "Microsoft.Azure.Extensions",
            apiVersion: "2.0",
            minorVersionAutoUpgrade: true,
            protectedSettings: {
                script: "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==",
            },
        }],
        image: {
            marketplaceImages: [{
                publisher: "Canonical",
                offer: "UbuntuServer",
                sku: "16.04-LTS",
                version: "latest",
            }],
        },
        loadBalancers: [{
            type: "loadBalancer",
            resourceGroupName: "testResourceGroup",
            name: "testLoadBalancer",
            sku: "Standard",
            backendPoolNames: [
                "testBackendPool1",
                "testBackendPool2",
            ],
        }],
        login: {
            userName: "admin",
            sshPublicKey: "33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
        },
        managedServiceIdentities: [{
            name: "mySI2",
            resourceGroupName: "myResourceGroup",
        }],
        network: {
            networkResourceGroupName: "subnetResourceGroup",
            virtualNetworkName: "vname",
            networkInterfaces: [{
                isPrimary: true,
                subnetName: "testSubnet",
                assignPublicIp: true,
                publicIpSku: "Standard",
                networkSecurityGroups: [{
                    networkResourceGroupName: "test",
                    name: "test",
                }],
                enableIpForwarding: true,
                privateIpAddresses: ["172.23.4.20"],
                additionalIpConfigurations: [{
                    name: "test",
                    privateIpAddressVersion: "IPv4",
                }],
                publicIps: [{
                    networkResourceGroupName: "resourceGroup",
                    name: "test",
                }],
                applicationSecurityGroups: [{
                    networkResourceGroupName: "AsgResourceGroup",
                    name: "AsgName",
                }],
            }],
        },
        osDisk: {
            sizeGb: 30,
            type: "Standard_LRS",
        },
        secrets: [{
            sourceVaults: [{
                name: "string",
                resourceGroupName: "string",
            }],
            vaultCertificates: [{
                certificateUrl: "string",
                certificateStore: "string",
            }],
        }],
        security: {
            securityType: "Standard",
            secureBootEnabled: false,
            vtpmEnabled: false,
        },
        tags: [{
            tagKey: "Creator",
            tagValue: "string",
        }],
        health: {
            healthCheckTypes: ["vmState"],
            unhealthyDuration: 300,
            gracePeriod: 120,
            autoHealing: true,
        },
        shouldPersistOsDisk: false,
        osDiskPersistenceMode: "reattach",
        shouldPersistDataDisks: true,
        dataDisksPersistenceMode: "reattach",
        shouldPersistNetwork: true,
        schedulingTasks: [
            {
                isEnabled: true,
                type: "pause",
                cronExpression: "44 10 * * *",
            },
            {
                isEnabled: true,
                type: "resume",
                cronExpression: "48 10 * * *",
            },
            {
                isEnabled: true,
                type: "recycle",
                cronExpression: "52 10 * * *",
            },
        ],
        signals: [
            {
                type: "vmReady",
                timeout: 20,
            },
            {
                type: "vmReady",
                timeout: 40,
            },
        ],
        proximityPlacementGroups: [{
            name: "TestPPG",
            resourceGroupName: "TestResourceGroup",
        }],
        deletes: [{
            shouldTerminateVm: true,
            networkShouldDeallocate: true,
            networkTtlInHours: 0,
            diskShouldDeallocate: true,
            diskTtlInHours: 0,
            snapshotShouldDeallocate: true,
            snapshotTtlInHours: 0,
            publicIpShouldDeallocate: true,
            publicIpTtlInHours: 0,
        }],
    });
    
    resources:
      testStatefulNodeAzure:
        type: spotinst:StatefulNodeAzure
        properties:
          region: eastus
          resourceGroupName: spotinst-azure
          description: example_stateful_node_azure_description
          strategy: # -------------------------------------------------------------------
            drainingTimeout: 30
            fallbackToOnDemand: true
            optimizationWindows:
              - Tue:19:46-Tue:20:46
            revertToSpot:
              performAt: timeWindow
            preferredLifeCycle: od
            capacityReservations:
              - shouldUtilize: true
                utilizationStrategy: utilizeOverOD
                capacityReservationGroups:
                  - crgName: crg name
                    crgResourceGroupName: resourceGroupName
                    crgShouldPrioritize: true
          # --- COMPUTE -------------------------------------------------------
          os: Linux
          odSizes:
            - standard_ds1_v2
            - standard_ds2_v2
          spotSizes:
            - standard_ds1_v2
            - standard_ds2_v2
          preferredSpotSizes:
            - standard_ds1_v2
          zones:
            - '1'
            - '3'
          preferredZone: '1'
          customData:
          shutdownScript:
          userData:
          vmName: VMName # -------------------------------------------------------------------
          # --- BOOT DIAGNOSTICS ----------------------------------------------
          bootDiagnostics: # -------------------------------------------------------------------
            - isEnabled: true
              storageUrl: https://.blob.core.windows.net/test
              type: unmanaged
          # --- DATA DISKS ----------------------------------------------------
          dataDisks: # -------------------------------------------------------------------
            - sizeGb: 1
              lun: 1
              type: Standard_LRS
            - sizeGb: 10
              lun: 2
              type: Standard_LRS
          # --- EXTENSIONS ----------------------------------------------------
          extensions: # -------------------------------------------------------------------
            - name: extensionName
              type: customScript
              publisher: Microsoft.Azure.Extensions
              apiVersion: '2.0'
              minorVersionAutoUpgrade: true
              protectedSettings:
                script: IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==
          image: # -------------------------------------------------------------------
            marketplaceImages:
              - publisher: Canonical
                offer: UbuntuServer
                sku: 16.04-LTS
                version: latest
          # --- LOAD BALANCERS ------------------------------------------------
          loadBalancers: # -------------------------------------------------------------------
            - type: loadBalancer
              resourceGroupName: testResourceGroup
              name: testLoadBalancer
              sku: Standard
              backendPoolNames:
                - testBackendPool1
                - testBackendPool2
          login: # -------------------------------------------------------------------
            userName: admin
            sshPublicKey: 33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==
          # --- MANAGED SERVICE IDENTITIES ------------------------------------
          managedServiceIdentities: # -------------------------------------------------------------------
            - name: mySI2
              resourceGroupName: myResourceGroup
          network: # -------------------------------------------------------------------
            networkResourceGroupName: subnetResourceGroup
            virtualNetworkName: vname
            networkInterfaces:
              - isPrimary: true
                subnetName: testSubnet
                assignPublicIp: true
                publicIpSku: Standard
                networkSecurityGroups:
                  - networkResourceGroupName: test
                    name: test
                enableIpForwarding: true
                privateIpAddresses:
                  - 172.23.4.20
                additionalIpConfigurations:
                  - name: test
                    privateIpAddressVersion: IPv4
                publicIps:
                  - networkResourceGroupName: resourceGroup
                    name: test
                applicationSecurityGroups:
                  - networkResourceGroupName: AsgResourceGroup
                    name: AsgName
          osDisk: # -------------------------------------------------------------------
            sizeGb: 30
            type: Standard_LRS
          # --- SECRETS -------------------------------------------------------
          secrets: # --- Security ------------------------------------------------------
            - sourceVaults:
                - name: string
                  resourceGroupName: string
              vaultCertificates:
                - certificateUrl: string
                  certificateStore: string
          security: # -------------------------------------------------------------------
            securityType: Standard
            secureBootEnabled: false
            vtpmEnabled: false
          # --- TAGS ----------------------------------------------------------
          tags:
            - tagKey: Creator
              tagValue: string
          health: # -------------------------------------------------------------------
            healthCheckTypes:
              - vmState
            unhealthyDuration: 300
            gracePeriod: 120
            autoHealing: true
          # --- PERSISTENCE ---------------------------------------------------
          shouldPersistOsDisk: false
          osDiskPersistenceMode: reattach
          shouldPersistDataDisks: true
          dataDisksPersistenceMode: reattach
          shouldPersistNetwork: true # -------------------------------------------------------------------
          # --- SCHEDULING TASKS ----------------------------------------------
          schedulingTasks: # -------------------------------------------------------------------
            - isEnabled: true
              type: pause
              cronExpression: 44 10 * * *
            - isEnabled: true
              type: resume
              cronExpression: 48 10 * * *
            - isEnabled: true
              type: recycle
              cronExpression: 52 10 * * *
          # --- SIGNALS -------------------------------------------------------
          signals: # -------------------------------------------------------------------
            - type: vmReady
              timeout: 20
            - type: vmReady
              timeout: 40
          # --- PROMXIMITY PLACEMENTS GROUPS -----------------------------------
          proximityPlacementGroups: # -------------------------------------------------------------------
            - name: TestPPG
              resourceGroupName: TestResourceGroup
          # ---DELETE----------------------------------------------------------
          deletes:
            - shouldTerminateVm: true
              networkShouldDeallocate: true
              networkTtlInHours: 0
              diskShouldDeallocate: true
              diskTtlInHours: 0
              snapshotShouldDeallocate: true
              snapshotTtlInHours: 0
              publicIpShouldDeallocate: true
              publicIpTtlInHours: 0
    

    Create StatefulNodeAzure Resource

    new StatefulNodeAzure(name: string, args: StatefulNodeAzureArgs, opts?: CustomResourceOptions);
    @overload
    def StatefulNodeAzure(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          attach_data_disks: Optional[Sequence[StatefulNodeAzureAttachDataDiskArgs]] = None,
                          boot_diagnostics: Optional[Sequence[StatefulNodeAzureBootDiagnosticArgs]] = None,
                          custom_data: Optional[str] = None,
                          data_disks: Optional[Sequence[StatefulNodeAzureDataDiskArgs]] = None,
                          data_disks_persistence_mode: Optional[str] = None,
                          deletes: Optional[Sequence[StatefulNodeAzureDeleteArgs]] = None,
                          description: Optional[str] = None,
                          detach_data_disks: Optional[Sequence[StatefulNodeAzureDetachDataDiskArgs]] = None,
                          extensions: Optional[Sequence[StatefulNodeAzureExtensionArgs]] = None,
                          health: Optional[StatefulNodeAzureHealthArgs] = None,
                          image: Optional[StatefulNodeAzureImageArgs] = None,
                          import_vms: Optional[Sequence[StatefulNodeAzureImportVmArgs]] = None,
                          load_balancers: Optional[Sequence[StatefulNodeAzureLoadBalancerArgs]] = None,
                          login: Optional[StatefulNodeAzureLoginArgs] = None,
                          managed_service_identities: Optional[Sequence[StatefulNodeAzureManagedServiceIdentityArgs]] = None,
                          name: Optional[str] = None,
                          network: Optional[StatefulNodeAzureNetworkArgs] = None,
                          od_sizes: Optional[Sequence[str]] = None,
                          os: Optional[str] = None,
                          os_disk: Optional[StatefulNodeAzureOsDiskArgs] = None,
                          os_disk_persistence_mode: Optional[str] = None,
                          preferred_spot_sizes: Optional[Sequence[str]] = None,
                          preferred_zone: Optional[str] = None,
                          proximity_placement_groups: Optional[Sequence[StatefulNodeAzureProximityPlacementGroupArgs]] = None,
                          region: Optional[str] = None,
                          resource_group_name: Optional[str] = None,
                          scheduling_tasks: Optional[Sequence[StatefulNodeAzureSchedulingTaskArgs]] = None,
                          secrets: Optional[Sequence[StatefulNodeAzureSecretArgs]] = None,
                          security: Optional[StatefulNodeAzureSecurityArgs] = None,
                          should_persist_data_disks: Optional[bool] = None,
                          should_persist_network: Optional[bool] = None,
                          should_persist_os_disk: Optional[bool] = None,
                          should_persist_vm: Optional[bool] = None,
                          shutdown_script: Optional[str] = None,
                          signals: Optional[Sequence[StatefulNodeAzureSignalArgs]] = None,
                          spot_sizes: Optional[Sequence[str]] = None,
                          strategy: Optional[StatefulNodeAzureStrategyArgs] = None,
                          tags: Optional[Sequence[StatefulNodeAzureTagArgs]] = None,
                          update_states: Optional[Sequence[StatefulNodeAzureUpdateStateArgs]] = None,
                          user_data: Optional[str] = None,
                          vm_name: Optional[str] = None,
                          zones: Optional[Sequence[str]] = None)
    @overload
    def StatefulNodeAzure(resource_name: str,
                          args: StatefulNodeAzureArgs,
                          opts: Optional[ResourceOptions] = None)
    func NewStatefulNodeAzure(ctx *Context, name string, args StatefulNodeAzureArgs, opts ...ResourceOption) (*StatefulNodeAzure, error)
    public StatefulNodeAzure(string name, StatefulNodeAzureArgs args, CustomResourceOptions? opts = null)
    public StatefulNodeAzure(String name, StatefulNodeAzureArgs args)
    public StatefulNodeAzure(String name, StatefulNodeAzureArgs args, CustomResourceOptions options)
    
    type: spotinst:StatefulNodeAzure
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    name string
    The unique name of the resource.
    args StatefulNodeAzureArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args StatefulNodeAzureArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args StatefulNodeAzureArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args StatefulNodeAzureArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args StatefulNodeAzureArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    StatefulNodeAzure Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The StatefulNodeAzure resource accepts the following input properties:

    OdSizes List<string>
    Os string
    Region string
    ResourceGroupName string
    ShouldPersistDataDisks bool
    ShouldPersistNetwork bool
    ShouldPersistOsDisk bool
    SpotSizes List<string>
    Strategy Pulumi.SpotInst.Inputs.StatefulNodeAzureStrategy
    AttachDataDisks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureAttachDataDisk>
    BootDiagnostics List<Pulumi.SpotInst.Inputs.StatefulNodeAzureBootDiagnostic>
    CustomData string
    DataDisks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureDataDisk>
    DataDisksPersistenceMode string
    Deletes List<Pulumi.SpotInst.Inputs.StatefulNodeAzureDelete>
    Description string
    DetachDataDisks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureDetachDataDisk>
    Extensions List<Pulumi.SpotInst.Inputs.StatefulNodeAzureExtension>
    Health Pulumi.SpotInst.Inputs.StatefulNodeAzureHealth
    Image Pulumi.SpotInst.Inputs.StatefulNodeAzureImage
    ImportVms List<Pulumi.SpotInst.Inputs.StatefulNodeAzureImportVm>
    LoadBalancers List<Pulumi.SpotInst.Inputs.StatefulNodeAzureLoadBalancer>
    Login Pulumi.SpotInst.Inputs.StatefulNodeAzureLogin
    ManagedServiceIdentities List<Pulumi.SpotInst.Inputs.StatefulNodeAzureManagedServiceIdentity>
    Name string
    Network Pulumi.SpotInst.Inputs.StatefulNodeAzureNetwork
    OsDisk Pulumi.SpotInst.Inputs.StatefulNodeAzureOsDisk
    OsDiskPersistenceMode string
    PreferredSpotSizes List<string>
    PreferredZone string
    ProximityPlacementGroups List<Pulumi.SpotInst.Inputs.StatefulNodeAzureProximityPlacementGroup>
    SchedulingTasks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureSchedulingTask>
    Secrets List<Pulumi.SpotInst.Inputs.StatefulNodeAzureSecret>
    Security Pulumi.SpotInst.Inputs.StatefulNodeAzureSecurity
    ShouldPersistVm bool
    ShutdownScript string
    Signals List<Pulumi.SpotInst.Inputs.StatefulNodeAzureSignal>
    Tags List<Pulumi.SpotInst.Inputs.StatefulNodeAzureTag>
    UpdateStates List<Pulumi.SpotInst.Inputs.StatefulNodeAzureUpdateState>
    UserData string
    VmName string
    Zones List<string>
    OdSizes []string
    Os string
    Region string
    ResourceGroupName string
    ShouldPersistDataDisks bool
    ShouldPersistNetwork bool
    ShouldPersistOsDisk bool
    SpotSizes []string
    Strategy StatefulNodeAzureStrategyArgs
    AttachDataDisks []StatefulNodeAzureAttachDataDiskArgs
    BootDiagnostics []StatefulNodeAzureBootDiagnosticArgs
    CustomData string
    DataDisks []StatefulNodeAzureDataDiskArgs
    DataDisksPersistenceMode string
    Deletes []StatefulNodeAzureDeleteArgs
    Description string
    DetachDataDisks []StatefulNodeAzureDetachDataDiskArgs
    Extensions []StatefulNodeAzureExtensionArgs
    Health StatefulNodeAzureHealthArgs
    Image StatefulNodeAzureImageArgs
    ImportVms []StatefulNodeAzureImportVmArgs
    LoadBalancers []StatefulNodeAzureLoadBalancerArgs
    Login StatefulNodeAzureLoginArgs
    ManagedServiceIdentities []StatefulNodeAzureManagedServiceIdentityArgs
    Name string
    Network StatefulNodeAzureNetworkArgs
    OsDisk StatefulNodeAzureOsDiskArgs
    OsDiskPersistenceMode string
    PreferredSpotSizes []string
    PreferredZone string
    ProximityPlacementGroups []StatefulNodeAzureProximityPlacementGroupArgs
    SchedulingTasks []StatefulNodeAzureSchedulingTaskArgs
    Secrets []StatefulNodeAzureSecretArgs
    Security StatefulNodeAzureSecurityArgs
    ShouldPersistVm bool
    ShutdownScript string
    Signals []StatefulNodeAzureSignalArgs
    Tags []StatefulNodeAzureTagArgs
    UpdateStates []StatefulNodeAzureUpdateStateArgs
    UserData string
    VmName string
    Zones []string
    odSizes List<String>
    os String
    region String
    resourceGroupName String
    shouldPersistDataDisks Boolean
    shouldPersistNetwork Boolean
    shouldPersistOsDisk Boolean
    spotSizes List<String>
    strategy StatefulNodeAzureStrategy
    attachDataDisks List<StatefulNodeAzureAttachDataDisk>
    bootDiagnostics List<StatefulNodeAzureBootDiagnostic>
    customData String
    dataDisks List<StatefulNodeAzureDataDisk>
    dataDisksPersistenceMode String
    deletes List<StatefulNodeAzureDelete>
    description String
    detachDataDisks List<StatefulNodeAzureDetachDataDisk>
    extensions List<StatefulNodeAzureExtension>
    health StatefulNodeAzureHealth
    image StatefulNodeAzureImage
    importVms List<StatefulNodeAzureImportVm>
    loadBalancers List<StatefulNodeAzureLoadBalancer>
    login StatefulNodeAzureLogin
    managedServiceIdentities List<StatefulNodeAzureManagedServiceIdentity>
    name String
    network StatefulNodeAzureNetwork
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode String
    preferredSpotSizes List<String>
    preferredZone String
    proximityPlacementGroups List<StatefulNodeAzureProximityPlacementGroup>
    schedulingTasks List<StatefulNodeAzureSchedulingTask>
    secrets List<StatefulNodeAzureSecret>
    security StatefulNodeAzureSecurity
    shouldPersistVm Boolean
    shutdownScript String
    signals List<StatefulNodeAzureSignal>
    tags List<StatefulNodeAzureTag>
    updateStates List<StatefulNodeAzureUpdateState>
    userData String
    vmName String
    zones List<String>
    odSizes string[]
    os string
    region string
    resourceGroupName string
    shouldPersistDataDisks boolean
    shouldPersistNetwork boolean
    shouldPersistOsDisk boolean
    spotSizes string[]
    strategy StatefulNodeAzureStrategy
    attachDataDisks StatefulNodeAzureAttachDataDisk[]
    bootDiagnostics StatefulNodeAzureBootDiagnostic[]
    customData string
    dataDisks StatefulNodeAzureDataDisk[]
    dataDisksPersistenceMode string
    deletes StatefulNodeAzureDelete[]
    description string
    detachDataDisks StatefulNodeAzureDetachDataDisk[]
    extensions StatefulNodeAzureExtension[]
    health StatefulNodeAzureHealth
    image StatefulNodeAzureImage
    importVms StatefulNodeAzureImportVm[]
    loadBalancers StatefulNodeAzureLoadBalancer[]
    login StatefulNodeAzureLogin
    managedServiceIdentities StatefulNodeAzureManagedServiceIdentity[]
    name string
    network StatefulNodeAzureNetwork
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode string
    preferredSpotSizes string[]
    preferredZone string
    proximityPlacementGroups StatefulNodeAzureProximityPlacementGroup[]
    schedulingTasks StatefulNodeAzureSchedulingTask[]
    secrets StatefulNodeAzureSecret[]
    security StatefulNodeAzureSecurity
    shouldPersistVm boolean
    shutdownScript string
    signals StatefulNodeAzureSignal[]
    tags StatefulNodeAzureTag[]
    updateStates StatefulNodeAzureUpdateState[]
    userData string
    vmName string
    zones string[]
    od_sizes Sequence[str]
    os str
    region str
    resource_group_name str
    should_persist_data_disks bool
    should_persist_network bool
    should_persist_os_disk bool
    spot_sizes Sequence[str]
    strategy StatefulNodeAzureStrategyArgs
    attach_data_disks Sequence[StatefulNodeAzureAttachDataDiskArgs]
    boot_diagnostics Sequence[StatefulNodeAzureBootDiagnosticArgs]
    custom_data str
    data_disks Sequence[StatefulNodeAzureDataDiskArgs]
    data_disks_persistence_mode str
    deletes Sequence[StatefulNodeAzureDeleteArgs]
    description str
    detach_data_disks Sequence[StatefulNodeAzureDetachDataDiskArgs]
    extensions Sequence[StatefulNodeAzureExtensionArgs]
    health StatefulNodeAzureHealthArgs
    image StatefulNodeAzureImageArgs
    import_vms Sequence[StatefulNodeAzureImportVmArgs]
    load_balancers Sequence[StatefulNodeAzureLoadBalancerArgs]
    login StatefulNodeAzureLoginArgs
    managed_service_identities Sequence[StatefulNodeAzureManagedServiceIdentityArgs]
    name str
    network StatefulNodeAzureNetworkArgs
    os_disk StatefulNodeAzureOsDiskArgs
    os_disk_persistence_mode str
    preferred_spot_sizes Sequence[str]
    preferred_zone str
    proximity_placement_groups Sequence[StatefulNodeAzureProximityPlacementGroupArgs]
    scheduling_tasks Sequence[StatefulNodeAzureSchedulingTaskArgs]
    secrets Sequence[StatefulNodeAzureSecretArgs]
    security StatefulNodeAzureSecurityArgs
    should_persist_vm bool
    shutdown_script str
    signals Sequence[StatefulNodeAzureSignalArgs]
    tags Sequence[StatefulNodeAzureTagArgs]
    update_states Sequence[StatefulNodeAzureUpdateStateArgs]
    user_data str
    vm_name str
    zones Sequence[str]
    odSizes List<String>
    os String
    region String
    resourceGroupName String
    shouldPersistDataDisks Boolean
    shouldPersistNetwork Boolean
    shouldPersistOsDisk Boolean
    spotSizes List<String>
    strategy Property Map
    attachDataDisks List<Property Map>
    bootDiagnostics List<Property Map>
    customData String
    dataDisks List<Property Map>
    dataDisksPersistenceMode String
    deletes List<Property Map>
    description String
    detachDataDisks List<Property Map>
    extensions List<Property Map>
    health Property Map
    image Property Map
    importVms List<Property Map>
    loadBalancers List<Property Map>
    login Property Map
    managedServiceIdentities List<Property Map>
    name String
    network Property Map
    osDisk Property Map
    osDiskPersistenceMode String
    preferredSpotSizes List<String>
    preferredZone String
    proximityPlacementGroups List<Property Map>
    schedulingTasks List<Property Map>
    secrets List<Property Map>
    security Property Map
    shouldPersistVm Boolean
    shutdownScript String
    signals List<Property Map>
    tags List<Property Map>
    updateStates List<Property Map>
    userData String
    vmName String
    zones List<String>

    Outputs

    All input properties are implicitly available as output properties. Additionally, the StatefulNodeAzure resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing StatefulNodeAzure Resource

    Get an existing StatefulNodeAzure resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: StatefulNodeAzureState, opts?: CustomResourceOptions): StatefulNodeAzure
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            attach_data_disks: Optional[Sequence[StatefulNodeAzureAttachDataDiskArgs]] = None,
            boot_diagnostics: Optional[Sequence[StatefulNodeAzureBootDiagnosticArgs]] = None,
            custom_data: Optional[str] = None,
            data_disks: Optional[Sequence[StatefulNodeAzureDataDiskArgs]] = None,
            data_disks_persistence_mode: Optional[str] = None,
            deletes: Optional[Sequence[StatefulNodeAzureDeleteArgs]] = None,
            description: Optional[str] = None,
            detach_data_disks: Optional[Sequence[StatefulNodeAzureDetachDataDiskArgs]] = None,
            extensions: Optional[Sequence[StatefulNodeAzureExtensionArgs]] = None,
            health: Optional[StatefulNodeAzureHealthArgs] = None,
            image: Optional[StatefulNodeAzureImageArgs] = None,
            import_vms: Optional[Sequence[StatefulNodeAzureImportVmArgs]] = None,
            load_balancers: Optional[Sequence[StatefulNodeAzureLoadBalancerArgs]] = None,
            login: Optional[StatefulNodeAzureLoginArgs] = None,
            managed_service_identities: Optional[Sequence[StatefulNodeAzureManagedServiceIdentityArgs]] = None,
            name: Optional[str] = None,
            network: Optional[StatefulNodeAzureNetworkArgs] = None,
            od_sizes: Optional[Sequence[str]] = None,
            os: Optional[str] = None,
            os_disk: Optional[StatefulNodeAzureOsDiskArgs] = None,
            os_disk_persistence_mode: Optional[str] = None,
            preferred_spot_sizes: Optional[Sequence[str]] = None,
            preferred_zone: Optional[str] = None,
            proximity_placement_groups: Optional[Sequence[StatefulNodeAzureProximityPlacementGroupArgs]] = None,
            region: Optional[str] = None,
            resource_group_name: Optional[str] = None,
            scheduling_tasks: Optional[Sequence[StatefulNodeAzureSchedulingTaskArgs]] = None,
            secrets: Optional[Sequence[StatefulNodeAzureSecretArgs]] = None,
            security: Optional[StatefulNodeAzureSecurityArgs] = None,
            should_persist_data_disks: Optional[bool] = None,
            should_persist_network: Optional[bool] = None,
            should_persist_os_disk: Optional[bool] = None,
            should_persist_vm: Optional[bool] = None,
            shutdown_script: Optional[str] = None,
            signals: Optional[Sequence[StatefulNodeAzureSignalArgs]] = None,
            spot_sizes: Optional[Sequence[str]] = None,
            strategy: Optional[StatefulNodeAzureStrategyArgs] = None,
            tags: Optional[Sequence[StatefulNodeAzureTagArgs]] = None,
            update_states: Optional[Sequence[StatefulNodeAzureUpdateStateArgs]] = None,
            user_data: Optional[str] = None,
            vm_name: Optional[str] = None,
            zones: Optional[Sequence[str]] = None) -> StatefulNodeAzure
    func GetStatefulNodeAzure(ctx *Context, name string, id IDInput, state *StatefulNodeAzureState, opts ...ResourceOption) (*StatefulNodeAzure, error)
    public static StatefulNodeAzure Get(string name, Input<string> id, StatefulNodeAzureState? state, CustomResourceOptions? opts = null)
    public static StatefulNodeAzure get(String name, Output<String> id, StatefulNodeAzureState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AttachDataDisks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureAttachDataDisk>
    BootDiagnostics List<Pulumi.SpotInst.Inputs.StatefulNodeAzureBootDiagnostic>
    CustomData string
    DataDisks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureDataDisk>
    DataDisksPersistenceMode string
    Deletes List<Pulumi.SpotInst.Inputs.StatefulNodeAzureDelete>
    Description string
    DetachDataDisks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureDetachDataDisk>
    Extensions List<Pulumi.SpotInst.Inputs.StatefulNodeAzureExtension>
    Health Pulumi.SpotInst.Inputs.StatefulNodeAzureHealth
    Image Pulumi.SpotInst.Inputs.StatefulNodeAzureImage
    ImportVms List<Pulumi.SpotInst.Inputs.StatefulNodeAzureImportVm>
    LoadBalancers List<Pulumi.SpotInst.Inputs.StatefulNodeAzureLoadBalancer>
    Login Pulumi.SpotInst.Inputs.StatefulNodeAzureLogin
    ManagedServiceIdentities List<Pulumi.SpotInst.Inputs.StatefulNodeAzureManagedServiceIdentity>
    Name string
    Network Pulumi.SpotInst.Inputs.StatefulNodeAzureNetwork
    OdSizes List<string>
    Os string
    OsDisk Pulumi.SpotInst.Inputs.StatefulNodeAzureOsDisk
    OsDiskPersistenceMode string
    PreferredSpotSizes List<string>
    PreferredZone string
    ProximityPlacementGroups List<Pulumi.SpotInst.Inputs.StatefulNodeAzureProximityPlacementGroup>
    Region string
    ResourceGroupName string
    SchedulingTasks List<Pulumi.SpotInst.Inputs.StatefulNodeAzureSchedulingTask>
    Secrets List<Pulumi.SpotInst.Inputs.StatefulNodeAzureSecret>
    Security Pulumi.SpotInst.Inputs.StatefulNodeAzureSecurity
    ShouldPersistDataDisks bool
    ShouldPersistNetwork bool
    ShouldPersistOsDisk bool
    ShouldPersistVm bool
    ShutdownScript string
    Signals List<Pulumi.SpotInst.Inputs.StatefulNodeAzureSignal>
    SpotSizes List<string>
    Strategy Pulumi.SpotInst.Inputs.StatefulNodeAzureStrategy
    Tags List<Pulumi.SpotInst.Inputs.StatefulNodeAzureTag>
    UpdateStates List<Pulumi.SpotInst.Inputs.StatefulNodeAzureUpdateState>
    UserData string
    VmName string
    Zones List<string>
    AttachDataDisks []StatefulNodeAzureAttachDataDiskArgs
    BootDiagnostics []StatefulNodeAzureBootDiagnosticArgs
    CustomData string
    DataDisks []StatefulNodeAzureDataDiskArgs
    DataDisksPersistenceMode string
    Deletes []StatefulNodeAzureDeleteArgs
    Description string
    DetachDataDisks []StatefulNodeAzureDetachDataDiskArgs
    Extensions []StatefulNodeAzureExtensionArgs
    Health StatefulNodeAzureHealthArgs
    Image StatefulNodeAzureImageArgs
    ImportVms []StatefulNodeAzureImportVmArgs
    LoadBalancers []StatefulNodeAzureLoadBalancerArgs
    Login StatefulNodeAzureLoginArgs
    ManagedServiceIdentities []StatefulNodeAzureManagedServiceIdentityArgs
    Name string
    Network StatefulNodeAzureNetworkArgs
    OdSizes []string
    Os string
    OsDisk StatefulNodeAzureOsDiskArgs
    OsDiskPersistenceMode string
    PreferredSpotSizes []string
    PreferredZone string
    ProximityPlacementGroups []StatefulNodeAzureProximityPlacementGroupArgs
    Region string
    ResourceGroupName string
    SchedulingTasks []StatefulNodeAzureSchedulingTaskArgs
    Secrets []StatefulNodeAzureSecretArgs
    Security StatefulNodeAzureSecurityArgs
    ShouldPersistDataDisks bool
    ShouldPersistNetwork bool
    ShouldPersistOsDisk bool
    ShouldPersistVm bool
    ShutdownScript string
    Signals []StatefulNodeAzureSignalArgs
    SpotSizes []string
    Strategy StatefulNodeAzureStrategyArgs
    Tags []StatefulNodeAzureTagArgs
    UpdateStates []StatefulNodeAzureUpdateStateArgs
    UserData string
    VmName string
    Zones []string
    attachDataDisks List<StatefulNodeAzureAttachDataDisk>
    bootDiagnostics List<StatefulNodeAzureBootDiagnostic>
    customData String
    dataDisks List<StatefulNodeAzureDataDisk>
    dataDisksPersistenceMode String
    deletes List<StatefulNodeAzureDelete>
    description String
    detachDataDisks List<StatefulNodeAzureDetachDataDisk>
    extensions List<StatefulNodeAzureExtension>
    health StatefulNodeAzureHealth
    image StatefulNodeAzureImage
    importVms List<StatefulNodeAzureImportVm>
    loadBalancers List<StatefulNodeAzureLoadBalancer>
    login StatefulNodeAzureLogin
    managedServiceIdentities List<StatefulNodeAzureManagedServiceIdentity>
    name String
    network StatefulNodeAzureNetwork
    odSizes List<String>
    os String
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode String
    preferredSpotSizes List<String>
    preferredZone String
    proximityPlacementGroups List<StatefulNodeAzureProximityPlacementGroup>
    region String
    resourceGroupName String
    schedulingTasks List<StatefulNodeAzureSchedulingTask>
    secrets List<StatefulNodeAzureSecret>
    security StatefulNodeAzureSecurity
    shouldPersistDataDisks Boolean
    shouldPersistNetwork Boolean
    shouldPersistOsDisk Boolean
    shouldPersistVm Boolean
    shutdownScript String
    signals List<StatefulNodeAzureSignal>
    spotSizes List<String>
    strategy StatefulNodeAzureStrategy
    tags List<StatefulNodeAzureTag>
    updateStates List<StatefulNodeAzureUpdateState>
    userData String
    vmName String
    zones List<String>
    attachDataDisks StatefulNodeAzureAttachDataDisk[]
    bootDiagnostics StatefulNodeAzureBootDiagnostic[]
    customData string
    dataDisks StatefulNodeAzureDataDisk[]
    dataDisksPersistenceMode string
    deletes StatefulNodeAzureDelete[]
    description string
    detachDataDisks StatefulNodeAzureDetachDataDisk[]
    extensions StatefulNodeAzureExtension[]
    health StatefulNodeAzureHealth
    image StatefulNodeAzureImage
    importVms StatefulNodeAzureImportVm[]
    loadBalancers StatefulNodeAzureLoadBalancer[]
    login StatefulNodeAzureLogin
    managedServiceIdentities StatefulNodeAzureManagedServiceIdentity[]
    name string
    network StatefulNodeAzureNetwork
    odSizes string[]
    os string
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode string
    preferredSpotSizes string[]
    preferredZone string
    proximityPlacementGroups StatefulNodeAzureProximityPlacementGroup[]
    region string
    resourceGroupName string
    schedulingTasks StatefulNodeAzureSchedulingTask[]
    secrets StatefulNodeAzureSecret[]
    security StatefulNodeAzureSecurity
    shouldPersistDataDisks boolean
    shouldPersistNetwork boolean
    shouldPersistOsDisk boolean
    shouldPersistVm boolean
    shutdownScript string
    signals StatefulNodeAzureSignal[]
    spotSizes string[]
    strategy StatefulNodeAzureStrategy
    tags StatefulNodeAzureTag[]
    updateStates StatefulNodeAzureUpdateState[]
    userData string
    vmName string
    zones string[]
    attach_data_disks Sequence[StatefulNodeAzureAttachDataDiskArgs]
    boot_diagnostics Sequence[StatefulNodeAzureBootDiagnosticArgs]
    custom_data str
    data_disks Sequence[StatefulNodeAzureDataDiskArgs]
    data_disks_persistence_mode str
    deletes Sequence[StatefulNodeAzureDeleteArgs]
    description str
    detach_data_disks Sequence[StatefulNodeAzureDetachDataDiskArgs]
    extensions Sequence[StatefulNodeAzureExtensionArgs]
    health StatefulNodeAzureHealthArgs
    image StatefulNodeAzureImageArgs
    import_vms Sequence[StatefulNodeAzureImportVmArgs]
    load_balancers Sequence[StatefulNodeAzureLoadBalancerArgs]
    login StatefulNodeAzureLoginArgs
    managed_service_identities Sequence[StatefulNodeAzureManagedServiceIdentityArgs]
    name str
    network StatefulNodeAzureNetworkArgs
    od_sizes Sequence[str]
    os str
    os_disk StatefulNodeAzureOsDiskArgs
    os_disk_persistence_mode str
    preferred_spot_sizes Sequence[str]
    preferred_zone str
    proximity_placement_groups Sequence[StatefulNodeAzureProximityPlacementGroupArgs]
    region str
    resource_group_name str
    scheduling_tasks Sequence[StatefulNodeAzureSchedulingTaskArgs]
    secrets Sequence[StatefulNodeAzureSecretArgs]
    security StatefulNodeAzureSecurityArgs
    should_persist_data_disks bool
    should_persist_network bool
    should_persist_os_disk bool
    should_persist_vm bool
    shutdown_script str
    signals Sequence[StatefulNodeAzureSignalArgs]
    spot_sizes Sequence[str]
    strategy StatefulNodeAzureStrategyArgs
    tags Sequence[StatefulNodeAzureTagArgs]
    update_states Sequence[StatefulNodeAzureUpdateStateArgs]
    user_data str
    vm_name str
    zones Sequence[str]
    attachDataDisks List<Property Map>
    bootDiagnostics List<Property Map>
    customData String
    dataDisks List<Property Map>
    dataDisksPersistenceMode String
    deletes List<Property Map>
    description String
    detachDataDisks List<Property Map>
    extensions List<Property Map>
    health Property Map
    image Property Map
    importVms List<Property Map>
    loadBalancers List<Property Map>
    login Property Map
    managedServiceIdentities List<Property Map>
    name String
    network Property Map
    odSizes List<String>
    os String
    osDisk Property Map
    osDiskPersistenceMode String
    preferredSpotSizes List<String>
    preferredZone String
    proximityPlacementGroups List<Property Map>
    region String
    resourceGroupName String
    schedulingTasks List<Property Map>
    secrets List<Property Map>
    security Property Map
    shouldPersistDataDisks Boolean
    shouldPersistNetwork Boolean
    shouldPersistOsDisk Boolean
    shouldPersistVm Boolean
    shutdownScript String
    signals List<Property Map>
    spotSizes List<String>
    strategy Property Map
    tags List<Property Map>
    updateStates List<Property Map>
    userData String
    vmName String
    zones List<String>

    Supporting Types

    StatefulNodeAzureAttachDataDisk, StatefulNodeAzureAttachDataDiskArgs

    StatefulNodeAzureBootDiagnostic, StatefulNodeAzureBootDiagnosticArgs

    IsEnabled bool
    StorageUrl string
    Type string
    IsEnabled bool
    StorageUrl string
    Type string
    isEnabled Boolean
    storageUrl String
    type String
    isEnabled boolean
    storageUrl string
    type string
    isEnabled Boolean
    storageUrl String
    type String

    StatefulNodeAzureDataDisk, StatefulNodeAzureDataDiskArgs

    Lun int
    SizeGb int
    Type string
    Lun int
    SizeGb int
    Type string
    lun Integer
    sizeGb Integer
    type String
    lun number
    sizeGb number
    type string
    lun int
    size_gb int
    type str
    lun Number
    sizeGb Number
    type String

    StatefulNodeAzureDelete, StatefulNodeAzureDeleteArgs

    StatefulNodeAzureDetachDataDisk, StatefulNodeAzureDetachDataDiskArgs

    StatefulNodeAzureExtension, StatefulNodeAzureExtensionArgs

    ApiVersion string
    MinorVersionAutoUpgrade bool
    Name string
    Publisher string
    Type string
    ProtectedSettings Dictionary<string, object>
    PublicSettings Dictionary<string, object>
    ApiVersion string
    MinorVersionAutoUpgrade bool
    Name string
    Publisher string
    Type string
    ProtectedSettings map[string]interface{}
    PublicSettings map[string]interface{}
    apiVersion String
    minorVersionAutoUpgrade Boolean
    name String
    publisher String
    type String
    protectedSettings Map<String,Object>
    publicSettings Map<String,Object>
    apiVersion string
    minorVersionAutoUpgrade boolean
    name string
    publisher string
    type string
    protectedSettings {[key: string]: any}
    publicSettings {[key: string]: any}
    apiVersion String
    minorVersionAutoUpgrade Boolean
    name String
    publisher String
    type String
    protectedSettings Map<Any>
    publicSettings Map<Any>

    StatefulNodeAzureHealth, StatefulNodeAzureHealthArgs

    autoHealing Boolean
    healthCheckTypes List<String>
    gracePeriod Integer
    unhealthyDuration Integer

    StatefulNodeAzureImage, StatefulNodeAzureImageArgs

    StatefulNodeAzureImageCustomImage, StatefulNodeAzureImageCustomImageArgs

    StatefulNodeAzureImageGallery, StatefulNodeAzureImageGalleryArgs

    StatefulNodeAzureImageMarketplaceImage, StatefulNodeAzureImageMarketplaceImageArgs

    Offer string
    Publisher string
    Sku string
    Version string
    Offer string
    Publisher string
    Sku string
    Version string
    offer String
    publisher String
    sku String
    version String
    offer string
    publisher string
    sku string
    version string
    offer str
    publisher str
    sku str
    version str
    offer String
    publisher String
    sku String
    version String

    StatefulNodeAzureImportVm, StatefulNodeAzureImportVmArgs

    StatefulNodeAzureLoadBalancer, StatefulNodeAzureLoadBalancerArgs

    BackendPoolNames List<string>
    Name string
    ResourceGroupName string
    Type string
    Sku string
    BackendPoolNames []string
    Name string
    ResourceGroupName string
    Type string
    Sku string
    backendPoolNames List<String>
    name String
    resourceGroupName String
    type String
    sku String
    backendPoolNames string[]
    name string
    resourceGroupName string
    type string
    sku string
    backendPoolNames List<String>
    name String
    resourceGroupName String
    type String
    sku String

    StatefulNodeAzureLogin, StatefulNodeAzureLoginArgs

    UserName string
    Password string
    SshPublicKey string
    UserName string
    Password string
    SshPublicKey string
    userName String
    password String
    sshPublicKey String
    userName string
    password string
    sshPublicKey string
    userName String
    password String
    sshPublicKey String

    StatefulNodeAzureManagedServiceIdentity, StatefulNodeAzureManagedServiceIdentityArgs

    Name string
    ResourceGroupName string
    Name string
    ResourceGroupName string
    name String
    resourceGroupName String
    name string
    resourceGroupName string
    name String
    resourceGroupName String

    StatefulNodeAzureNetwork, StatefulNodeAzureNetworkArgs

    StatefulNodeAzureNetworkNetworkInterface, StatefulNodeAzureNetworkNetworkInterfaceArgs

    StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration, StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs

    StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup, StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs

    StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup, StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs

    StatefulNodeAzureNetworkNetworkInterfacePublicIp, StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs

    StatefulNodeAzureOsDisk, StatefulNodeAzureOsDiskArgs

    Type string
    SizeGb int
    Type string
    SizeGb int
    type String
    sizeGb Integer
    type string
    sizeGb number
    type str
    size_gb int
    type String
    sizeGb Number

    StatefulNodeAzureProximityPlacementGroup, StatefulNodeAzureProximityPlacementGroupArgs

    Name string
    ResourceGroupName string
    Name string
    ResourceGroupName string
    name String
    resourceGroupName String
    name string
    resourceGroupName string
    name String
    resourceGroupName String

    StatefulNodeAzureSchedulingTask, StatefulNodeAzureSchedulingTaskArgs

    CronExpression string
    IsEnabled bool
    Type string
    CronExpression string
    IsEnabled bool
    Type string
    cronExpression String
    isEnabled Boolean
    type String
    cronExpression string
    isEnabled boolean
    type string
    cronExpression String
    isEnabled Boolean
    type String

    StatefulNodeAzureSecret, StatefulNodeAzureSecretArgs

    StatefulNodeAzureSecretSourceVault, StatefulNodeAzureSecretSourceVaultArgs

    Name string
    ResourceGroupName string
    Name string
    ResourceGroupName string
    name String
    resourceGroupName String
    name string
    resourceGroupName string
    name String
    resourceGroupName String

    StatefulNodeAzureSecretVaultCertificate, StatefulNodeAzureSecretVaultCertificateArgs

    StatefulNodeAzureSecurity, StatefulNodeAzureSecurityArgs

    StatefulNodeAzureSignal, StatefulNodeAzureSignalArgs

    Timeout int
    Type string
    Timeout int
    Type string
    timeout Integer
    type String
    timeout number
    type string
    timeout int
    type str
    timeout Number
    type String

    StatefulNodeAzureStrategy, StatefulNodeAzureStrategyArgs

    StatefulNodeAzureStrategyCapacityReservation, StatefulNodeAzureStrategyCapacityReservationArgs

    StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup, StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs

    StatefulNodeAzureStrategyRevertToSpot, StatefulNodeAzureStrategyRevertToSpotArgs

    PerformAt string
    PerformAt string
    performAt String
    performAt string
    performAt String

    StatefulNodeAzureTag, StatefulNodeAzureTagArgs

    TagKey string
    TagValue string
    TagKey string
    TagValue string
    tagKey String
    tagValue String
    tagKey string
    tagValue string
    tagKey String
    tagValue String

    StatefulNodeAzureUpdateState, StatefulNodeAzureUpdateStateArgs

    State string
    State string
    state String
    state string
    state str
    state String

    Package Details

    Repository
    Spotinst pulumi/pulumi-spotinst
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the spotinst Terraform Provider.
    spotinst logo
    Spotinst v3.68.0 published on Monday, Feb 19, 2024 by Pulumi