1. Packages
  2. Spotinst
  3. API Docs
  4. StatefulNodeAzure
Spotinst v3.83.0 published on Tuesday, Jul 16, 2024 by Pulumi

spotinst.StatefulNodeAzure

Explore with Pulumi AI

spotinst logo
Spotinst v3.83.0 published on Tuesday, Jul 16, 2024 by Pulumi

    Provides a Spotinst stateful node Azure resource.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as spotinst from "@pulumi/spotinst";
    
    const testStatefulNodeAzure = new spotinst.StatefulNodeAzure("test_stateful_node_azure", {
        name: "example_stateful_node_azure",
        region: "eastus",
        resourceGroupName: "spotinst-azure",
        description: "example_stateful_node_azure_description",
        strategy: {
            drainingTimeout: 30,
            fallbackToOnDemand: true,
            optimizationWindows: ["Tue:19:46-Tue:20:46"],
            odWindows: ["Wed:19:46-Wed:21:46"],
            availabilityVsCost: 100,
            revertToSpot: {
                performAt: "timeWindow",
            },
            preferredLifeCycle: "od",
            capacityReservations: [{
                shouldUtilize: true,
                utilizationStrategy: "utilizeOverOD",
                capacityReservationGroups: [{
                    crgName: "crg name",
                    crgResourceGroupName: "resourceGroupName",
                    crgShouldPrioritize: true,
                }],
            }],
        },
        os: "Linux",
        vmSizes: {
            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",
        vmNamePrefix: "VMNamePrefix",
        licenseType: "SLES_BYOS",
        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==",
            },
            publicSettings: {
                fileUris: ["https://testspot/Azuretest.sh"],
            },
        }],
        image: {
            marketplaceImages: [{
                publisher: "Canonical",
                offer: "UbuntuServer",
                sku: "16.04-LTS",
                version: "latest",
            }],
            customImages: [{
                customImageResourceGroupName: "resourceGroupName",
                name: "imageName",
            }],
            galleries: [{
                galleryResourceGroupName: "resourceGroupName",
                galleryName: "galleryName",
                imageName: "imageName",
                versionName: "1.1.0",
                spotAccountId: "act-123456",
            }],
        },
        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",
            caching: "ReadOnly",
        },
        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,
            shouldDeregisterFromLb: true,
        }],
    });
    
    import pulumi
    import pulumi_spotinst as spotinst
    
    test_stateful_node_azure = spotinst.StatefulNodeAzure("test_stateful_node_azure",
        name="example_stateful_node_azure",
        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"],
            od_windows=["Wed:19:46-Wed:21:46"],
            availability_vs_cost=100,
            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",
        vm_sizes=spotinst.StatefulNodeAzureVmSizesArgs(
            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",
        vm_name_prefix="VMNamePrefix",
        license_type="SLES_BYOS",
        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==",
            },
            public_settings={
                "fileUris": ["https://testspot/Azuretest.sh"],
            },
        )],
        image=spotinst.StatefulNodeAzureImageArgs(
            marketplace_images=[spotinst.StatefulNodeAzureImageMarketplaceImageArgs(
                publisher="Canonical",
                offer="UbuntuServer",
                sku="16.04-LTS",
                version="latest",
            )],
            custom_images=[spotinst.StatefulNodeAzureImageCustomImageArgs(
                custom_image_resource_group_name="resourceGroupName",
                name="imageName",
            )],
            galleries=[spotinst.StatefulNodeAzureImageGalleryArgs(
                gallery_resource_group_name="resourceGroupName",
                gallery_name="galleryName",
                image_name="imageName",
                version_name="1.1.0",
                spot_account_id="act-123456",
            )],
        ),
        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",
            caching="ReadOnly",
        ),
        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,
            should_deregister_from_lb=True,
        )])
    
    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, "test_stateful_node_azure", &spotinst.StatefulNodeAzureArgs{
    			Name:              pulumi.String("example_stateful_node_azure"),
    			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"),
    				},
    				OdWindows: pulumi.StringArray{
    					pulumi.String("Wed:19:46-Wed:21:46"),
    				},
    				AvailabilityVsCost: pulumi.Int(100),
    				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"),
    			VmSizes: &spotinst.StatefulNodeAzureVmSizesArgs{
    				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"),
    			VmNamePrefix:   pulumi.String("VMNamePrefix"),
    			LicenseType:    pulumi.String("SLES_BYOS"),
    			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=="),
    					},
    					PublicSettings: pulumi.Map{
    						"fileUris": pulumi.Any{
    							"https://testspot/Azuretest.sh",
    						},
    					},
    				},
    			},
    			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"),
    					},
    				},
    				CustomImages: spotinst.StatefulNodeAzureImageCustomImageArray{
    					&spotinst.StatefulNodeAzureImageCustomImageArgs{
    						CustomImageResourceGroupName: pulumi.String("resourceGroupName"),
    						Name:                         pulumi.String("imageName"),
    					},
    				},
    				Galleries: spotinst.StatefulNodeAzureImageGalleryArray{
    					&spotinst.StatefulNodeAzureImageGalleryArgs{
    						GalleryResourceGroupName: pulumi.String("resourceGroupName"),
    						GalleryName:              pulumi.String("galleryName"),
    						ImageName:                pulumi.String("imageName"),
    						VersionName:              pulumi.String("1.1.0"),
    						SpotAccountId:            pulumi.String("act-123456"),
    					},
    				},
    			},
    			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"),
    				Caching: pulumi.String("ReadOnly"),
    			},
    			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),
    					ShouldDeregisterFromLb:   pulumi.Bool(true),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using SpotInst = Pulumi.SpotInst;
    
    return await Deployment.RunAsync(() => 
    {
        var testStatefulNodeAzure = new SpotInst.StatefulNodeAzure("test_stateful_node_azure", new()
        {
            Name = "example_stateful_node_azure",
            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",
                },
                OdWindows = new[]
                {
                    "Wed:19:46-Wed:21:46",
                },
                AvailabilityVsCost = 100,
                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",
            VmSizes = new SpotInst.Inputs.StatefulNodeAzureVmSizesArgs
            {
                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",
            VmNamePrefix = "VMNamePrefix",
            LicenseType = "SLES_BYOS",
            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==" },
                    },
                    PublicSettings = 
                    {
                        { "fileUris", new[]
                        {
                            "https://testspot/Azuretest.sh",
                        } },
                    },
                },
            },
            Image = new SpotInst.Inputs.StatefulNodeAzureImageArgs
            {
                MarketplaceImages = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureImageMarketplaceImageArgs
                    {
                        Publisher = "Canonical",
                        Offer = "UbuntuServer",
                        Sku = "16.04-LTS",
                        Version = "latest",
                    },
                },
                CustomImages = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureImageCustomImageArgs
                    {
                        CustomImageResourceGroupName = "resourceGroupName",
                        Name = "imageName",
                    },
                },
                Galleries = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureImageGalleryArgs
                    {
                        GalleryResourceGroupName = "resourceGroupName",
                        GalleryName = "galleryName",
                        ImageName = "imageName",
                        VersionName = "1.1.0",
                        SpotAccountId = "act-123456",
                    },
                },
            },
            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",
                Caching = "ReadOnly",
            },
            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,
                    ShouldDeregisterFromLb = true,
                },
            },
        });
    
    });
    
    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.StatefulNodeAzureVmSizesArgs;
    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()
                .name("example_stateful_node_azure")
                .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")
                    .odWindows("Wed:19:46-Wed:21:46")
                    .availabilityVsCost(100)
                    .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")
                .vmSizes(StatefulNodeAzureVmSizesArgs.builder()
                    .odSizes(                
                        "standard_ds1_v2",
                        "standard_ds2_v2")
                    .spotSizes(                
                        "standard_ds1_v2",
                        "standard_ds2_v2")
                    .preferredSpotSizes("standard_ds1_v2")
                    .build())
                .zones(            
                    "1",
                    "3")
                .preferredZone("1")
                .customData("")
                .shutdownScript("")
                .userData("")
                .vmName("VMName")
                .vmNamePrefix("VMNamePrefix")
                .licenseType("SLES_BYOS")
                .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=="))
                    .publicSettings(Map.of("fileUris", "https://testspot/Azuretest.sh"))
                    .build())
                .image(StatefulNodeAzureImageArgs.builder()
                    .marketplaceImages(StatefulNodeAzureImageMarketplaceImageArgs.builder()
                        .publisher("Canonical")
                        .offer("UbuntuServer")
                        .sku("16.04-LTS")
                        .version("latest")
                        .build())
                    .customImages(StatefulNodeAzureImageCustomImageArgs.builder()
                        .customImageResourceGroupName("resourceGroupName")
                        .name("imageName")
                        .build())
                    .galleries(StatefulNodeAzureImageGalleryArgs.builder()
                        .galleryResourceGroupName("resourceGroupName")
                        .galleryName("galleryName")
                        .imageName("imageName")
                        .versionName("1.1.0")
                        .spotAccountId("act-123456")
                        .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")
                    .caching("ReadOnly")
                    .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)
                    .shouldDeregisterFromLb(true)
                    .build())
                .build());
    
        }
    }
    
    resources:
      testStatefulNodeAzure:
        type: spotinst:StatefulNodeAzure
        name: test_stateful_node_azure
        properties:
          name: example_stateful_node_azure
          region: eastus
          resourceGroupName: spotinst-azure
          description: example_stateful_node_azure_description
          strategy:
            drainingTimeout: 30
            fallbackToOnDemand: true
            optimizationWindows:
              - Tue:19:46-Tue:20:46
            odWindows:
              - Wed:19:46-Wed:21:46
            availabilityVsCost: 100
            revertToSpot:
              performAt: timeWindow
            preferredLifeCycle: od
            capacityReservations:
              - shouldUtilize: true
                utilizationStrategy: utilizeOverOD
                capacityReservationGroups:
                  - crgName: crg name
                    crgResourceGroupName: resourceGroupName
                    crgShouldPrioritize: true
          os: Linux
          vmSizes:
            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
          vmNamePrefix: VMNamePrefix
          licenseType: SLES_BYOS
          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==
              publicSettings:
                fileUris:
                  - https://testspot/Azuretest.sh
          image:
            marketplaceImages:
              - publisher: Canonical
                offer: UbuntuServer
                sku: 16.04-LTS
                version: latest
            customImages:
              - customImageResourceGroupName: resourceGroupName
                name: imageName
            galleries:
              - galleryResourceGroupName: resourceGroupName
                galleryName: galleryName
                imageName: imageName
                versionName: 1.1.0
                spotAccountId: act-123456
          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
            caching: ReadOnly
          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 # --- 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:
            - 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
              shouldDeregisterFromLb: true
    

    Argument Reference

    The following arguments are supported:

    • name - (Required) Azure stateful node name.
    • region - (Required) The Azure region your stateful node will be created in.
    • resource_group_name - (Required) Name of the Resource Group for stateful node.
    • description - (Optional) Describe your Azure stateful node.

    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.
      • availability_vs_cost - (Optional) Set the desired preference for the Spot market VM selection. (100- Availability, 0- cost).
      • 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.
      • od_windows - (Optional) Define the time windows in which the underlying VM will be set as an on-demand lifecycle type. During the entire time window, the rest of the strategy processes will be paused. Switching between on-demand and Spot VM types at the enter/exit of the time window will trigger the recycling of the stateful node. Valid format: “ddd:hh:mm-ddd:hh:mm (day:hour(0-23):minute(0-59))”.
      • 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.
    • vm_sizes - (Required) Defines the VM sizes to use when launching VMs.
      • 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. This can’t be set if vm_name_prefix is set.
    • vm_name_prefix - (Optional) Set a VM name prefix to be used for all launched VMs and the VM resources. This can’t be set if vm_name is set.
    • license_type - (Optional) Specify an existing Azure license type to use when launching new VMs. Valid values for Windows OS: “Windows_Server”, “Windows_Client”, Valid values for Linux OS: “RHEL_BYOS”, “SLES_BYOS”

    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 - (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'.
        • spot_account_id - (Optional) The Spot account ID that connected to the Azure subscription to which the gallery belongs. Relevant only in case of cross-subscription shared galleries. Read more about cross-subscription shared galleries in Elastigroup.
      • 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.
      • caching - (Optional, Enum "None", "ReadOnly", "ReadWrite") Specifies the host caching requirements. With disk caching enabled, VMs can achieve higher levels of performance. If not specified, the Azure default behavior will be applied.

    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.
      • should_deregister_from_lb - (Optional, Default: true) Indicates whether to deregister the stateful node’s VM from any type of load balancer. Can be changed to false only when shouldTerminateVms is ‘false’.

    Create StatefulNodeAzure Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new StatefulNodeAzure(name: string, args: StatefulNodeAzureArgs, opts?: CustomResourceOptions);
    @overload
    def StatefulNodeAzure(resource_name: str,
                          args: StatefulNodeAzureArgs,
                          opts: Optional[ResourceOptions] = None)
    
    @overload
    def StatefulNodeAzure(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          os: Optional[str] = None,
                          vm_sizes: Optional[StatefulNodeAzureVmSizesArgs] = None,
                          strategy: Optional[StatefulNodeAzureStrategyArgs] = None,
                          should_persist_os_disk: Optional[bool] = None,
                          should_persist_network: Optional[bool] = None,
                          should_persist_data_disks: Optional[bool] = None,
                          resource_group_name: Optional[str] = None,
                          region: Optional[str] = None,
                          image: Optional[StatefulNodeAzureImageArgs] = None,
                          scheduling_tasks: Optional[Sequence[StatefulNodeAzureSchedulingTaskArgs]] = None,
                          attach_data_disks: Optional[Sequence[StatefulNodeAzureAttachDataDiskArgs]] = None,
                          import_vms: Optional[Sequence[StatefulNodeAzureImportVmArgs]] = None,
                          license_type: Optional[str] = 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,
                          extensions: Optional[Sequence[StatefulNodeAzureExtensionArgs]] = None,
                          os_disk: Optional[StatefulNodeAzureOsDiskArgs] = None,
                          os_disk_persistence_mode: Optional[str] = None,
                          preferred_zone: Optional[str] = None,
                          proximity_placement_groups: Optional[Sequence[StatefulNodeAzureProximityPlacementGroupArgs]] = None,
                          detach_data_disks: Optional[Sequence[StatefulNodeAzureDetachDataDiskArgs]] = None,
                          description: Optional[str] = None,
                          health: Optional[StatefulNodeAzureHealthArgs] = None,
                          secrets: Optional[Sequence[StatefulNodeAzureSecretArgs]] = None,
                          security: Optional[StatefulNodeAzureSecurityArgs] = None,
                          deletes: Optional[Sequence[StatefulNodeAzureDeleteArgs]] = None,
                          data_disks_persistence_mode: Optional[str] = None,
                          data_disks: Optional[Sequence[StatefulNodeAzureDataDiskArgs]] = None,
                          should_persist_vm: Optional[bool] = None,
                          shutdown_script: Optional[str] = None,
                          signals: Optional[Sequence[StatefulNodeAzureSignalArgs]] = None,
                          custom_data: Optional[str] = None,
                          tags: Optional[Sequence[StatefulNodeAzureTagArgs]] = None,
                          update_states: Optional[Sequence[StatefulNodeAzureUpdateStateArgs]] = None,
                          user_data: Optional[str] = None,
                          vm_name: Optional[str] = None,
                          vm_name_prefix: Optional[str] = None,
                          boot_diagnostics: Optional[Sequence[StatefulNodeAzureBootDiagnosticArgs]] = None,
                          zones: Optional[Sequence[str]] = 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.
    
    

    Parameters

    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.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var statefulNodeAzureResource = new SpotInst.StatefulNodeAzure("statefulNodeAzureResource", new()
    {
        Os = "string",
        VmSizes = new SpotInst.Inputs.StatefulNodeAzureVmSizesArgs
        {
            OdSizes = new[]
            {
                "string",
            },
            SpotSizes = new[]
            {
                "string",
            },
            PreferredSpotSizes = new[]
            {
                "string",
            },
        },
        Strategy = new SpotInst.Inputs.StatefulNodeAzureStrategyArgs
        {
            FallbackToOnDemand = false,
            AvailabilityVsCost = 0,
            CapacityReservations = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureStrategyCapacityReservationArgs
                {
                    ShouldUtilize = false,
                    UtilizationStrategy = "string",
                    CapacityReservationGroups = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs
                        {
                            CrgName = "string",
                            CrgResourceGroupName = "string",
                            CrgShouldPrioritize = false,
                        },
                    },
                },
            },
            DrainingTimeout = 0,
            OdWindows = new[]
            {
                "string",
            },
            OptimizationWindows = new[]
            {
                "string",
            },
            PreferredLifeCycle = "string",
            RevertToSpot = new SpotInst.Inputs.StatefulNodeAzureStrategyRevertToSpotArgs
            {
                PerformAt = "string",
            },
        },
        ShouldPersistOsDisk = false,
        ShouldPersistNetwork = false,
        ShouldPersistDataDisks = false,
        ResourceGroupName = "string",
        Region = "string",
        Image = new SpotInst.Inputs.StatefulNodeAzureImageArgs
        {
            CustomImages = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureImageCustomImageArgs
                {
                    CustomImageResourceGroupName = "string",
                    Name = "string",
                },
            },
            Galleries = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureImageGalleryArgs
                {
                    GalleryName = "string",
                    GalleryResourceGroupName = "string",
                    ImageName = "string",
                    VersionName = "string",
                    SpotAccountId = "string",
                },
            },
            MarketplaceImages = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureImageMarketplaceImageArgs
                {
                    Offer = "string",
                    Publisher = "string",
                    Sku = "string",
                    Version = "string",
                },
            },
        },
        SchedulingTasks = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
            {
                CronExpression = "string",
                IsEnabled = false,
                Type = "string",
            },
        },
        AttachDataDisks = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureAttachDataDiskArgs
            {
                DataDiskName = "string",
                DataDiskResourceGroupName = "string",
                SizeGb = 0,
                StorageAccountType = "string",
                Lun = 0,
                Zone = "string",
            },
        },
        ImportVms = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureImportVmArgs
            {
                OriginalVmName = "string",
                ResourceGroupName = "string",
                DrainingTimeout = 0,
                ResourcesRetentionTime = 0,
            },
        },
        LicenseType = "string",
        LoadBalancers = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureLoadBalancerArgs
            {
                BackendPoolNames = new[]
                {
                    "string",
                },
                Name = "string",
                ResourceGroupName = "string",
                Type = "string",
                Sku = "string",
            },
        },
        Login = new SpotInst.Inputs.StatefulNodeAzureLoginArgs
        {
            UserName = "string",
            Password = "string",
            SshPublicKey = "string",
        },
        ManagedServiceIdentities = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureManagedServiceIdentityArgs
            {
                Name = "string",
                ResourceGroupName = "string",
            },
        },
        Name = "string",
        Network = new SpotInst.Inputs.StatefulNodeAzureNetworkArgs
        {
            NetworkInterfaces = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceArgs
                {
                    IsPrimary = false,
                    SubnetName = "string",
                    AdditionalIpConfigurations = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs
                        {
                            Name = "string",
                            PrivateIpAddressVersion = "string",
                        },
                    },
                    ApplicationSecurityGroups = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs
                        {
                            Name = "string",
                            NetworkResourceGroupName = "string",
                        },
                    },
                    AssignPublicIp = false,
                    EnableIpForwarding = false,
                    NetworkSecurityGroups = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs
                        {
                            Name = "string",
                            NetworkResourceGroupName = "string",
                        },
                    },
                    PrivateIpAddresses = new[]
                    {
                        "string",
                    },
                    PublicIpSku = "string",
                    PublicIps = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs
                        {
                            Name = "string",
                            NetworkResourceGroupName = "string",
                        },
                    },
                },
            },
            NetworkResourceGroupName = "string",
            VirtualNetworkName = "string",
        },
        Extensions = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureExtensionArgs
            {
                ApiVersion = "string",
                MinorVersionAutoUpgrade = false,
                Name = "string",
                Publisher = "string",
                Type = "string",
                ProtectedSettings = 
                {
                    { "string", "any" },
                },
                PublicSettings = 
                {
                    { "string", "any" },
                },
            },
        },
        OsDisk = new SpotInst.Inputs.StatefulNodeAzureOsDiskArgs
        {
            Type = "string",
            Caching = "string",
            SizeGb = 0,
        },
        OsDiskPersistenceMode = "string",
        PreferredZone = "string",
        ProximityPlacementGroups = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureProximityPlacementGroupArgs
            {
                Name = "string",
                ResourceGroupName = "string",
            },
        },
        DetachDataDisks = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureDetachDataDiskArgs
            {
                DataDiskName = "string",
                DataDiskResourceGroupName = "string",
                ShouldDeallocate = false,
                TtlInHours = 0,
            },
        },
        Description = "string",
        Health = new SpotInst.Inputs.StatefulNodeAzureHealthArgs
        {
            AutoHealing = false,
            HealthCheckTypes = new[]
            {
                "string",
            },
            GracePeriod = 0,
            UnhealthyDuration = 0,
        },
        Secrets = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureSecretArgs
            {
                SourceVaults = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureSecretSourceVaultArgs
                    {
                        Name = "string",
                        ResourceGroupName = "string",
                    },
                },
                VaultCertificates = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureSecretVaultCertificateArgs
                    {
                        CertificateStore = "string",
                        CertificateUrl = "string",
                    },
                },
            },
        },
        Security = new SpotInst.Inputs.StatefulNodeAzureSecurityArgs
        {
            SecureBootEnabled = false,
            SecurityType = "string",
            VtpmEnabled = false,
        },
        Deletes = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureDeleteArgs
            {
                DiskShouldDeallocate = false,
                NetworkShouldDeallocate = false,
                PublicIpShouldDeallocate = false,
                ShouldTerminateVm = false,
                SnapshotShouldDeallocate = false,
                DiskTtlInHours = 0,
                NetworkTtlInHours = 0,
                PublicIpTtlInHours = 0,
                ShouldDeregisterFromLb = false,
                SnapshotTtlInHours = 0,
            },
        },
        DataDisksPersistenceMode = "string",
        DataDisks = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureDataDiskArgs
            {
                Lun = 0,
                SizeGb = 0,
                Type = "string",
            },
        },
        ShouldPersistVm = false,
        ShutdownScript = "string",
        Signals = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureSignalArgs
            {
                Timeout = 0,
                Type = "string",
            },
        },
        CustomData = "string",
        Tags = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureTagArgs
            {
                TagKey = "string",
                TagValue = "string",
            },
        },
        UpdateStates = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureUpdateStateArgs
            {
                State = "string",
            },
        },
        UserData = "string",
        VmName = "string",
        VmNamePrefix = "string",
        BootDiagnostics = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureBootDiagnosticArgs
            {
                IsEnabled = false,
                StorageUrl = "string",
                Type = "string",
            },
        },
        Zones = new[]
        {
            "string",
        },
    });
    
    example, err := spotinst.NewStatefulNodeAzure(ctx, "statefulNodeAzureResource", &spotinst.StatefulNodeAzureArgs{
    	Os: pulumi.String("string"),
    	VmSizes: &spotinst.StatefulNodeAzureVmSizesArgs{
    		OdSizes: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		SpotSizes: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		PreferredSpotSizes: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    	},
    	Strategy: &spotinst.StatefulNodeAzureStrategyArgs{
    		FallbackToOnDemand: pulumi.Bool(false),
    		AvailabilityVsCost: pulumi.Int(0),
    		CapacityReservations: spotinst.StatefulNodeAzureStrategyCapacityReservationArray{
    			&spotinst.StatefulNodeAzureStrategyCapacityReservationArgs{
    				ShouldUtilize:       pulumi.Bool(false),
    				UtilizationStrategy: pulumi.String("string"),
    				CapacityReservationGroups: spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArray{
    					&spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs{
    						CrgName:              pulumi.String("string"),
    						CrgResourceGroupName: pulumi.String("string"),
    						CrgShouldPrioritize:  pulumi.Bool(false),
    					},
    				},
    			},
    		},
    		DrainingTimeout: pulumi.Int(0),
    		OdWindows: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		OptimizationWindows: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		PreferredLifeCycle: pulumi.String("string"),
    		RevertToSpot: &spotinst.StatefulNodeAzureStrategyRevertToSpotArgs{
    			PerformAt: pulumi.String("string"),
    		},
    	},
    	ShouldPersistOsDisk:    pulumi.Bool(false),
    	ShouldPersistNetwork:   pulumi.Bool(false),
    	ShouldPersistDataDisks: pulumi.Bool(false),
    	ResourceGroupName:      pulumi.String("string"),
    	Region:                 pulumi.String("string"),
    	Image: &spotinst.StatefulNodeAzureImageArgs{
    		CustomImages: spotinst.StatefulNodeAzureImageCustomImageArray{
    			&spotinst.StatefulNodeAzureImageCustomImageArgs{
    				CustomImageResourceGroupName: pulumi.String("string"),
    				Name:                         pulumi.String("string"),
    			},
    		},
    		Galleries: spotinst.StatefulNodeAzureImageGalleryArray{
    			&spotinst.StatefulNodeAzureImageGalleryArgs{
    				GalleryName:              pulumi.String("string"),
    				GalleryResourceGroupName: pulumi.String("string"),
    				ImageName:                pulumi.String("string"),
    				VersionName:              pulumi.String("string"),
    				SpotAccountId:            pulumi.String("string"),
    			},
    		},
    		MarketplaceImages: spotinst.StatefulNodeAzureImageMarketplaceImageArray{
    			&spotinst.StatefulNodeAzureImageMarketplaceImageArgs{
    				Offer:     pulumi.String("string"),
    				Publisher: pulumi.String("string"),
    				Sku:       pulumi.String("string"),
    				Version:   pulumi.String("string"),
    			},
    		},
    	},
    	SchedulingTasks: spotinst.StatefulNodeAzureSchedulingTaskArray{
    		&spotinst.StatefulNodeAzureSchedulingTaskArgs{
    			CronExpression: pulumi.String("string"),
    			IsEnabled:      pulumi.Bool(false),
    			Type:           pulumi.String("string"),
    		},
    	},
    	AttachDataDisks: spotinst.StatefulNodeAzureAttachDataDiskArray{
    		&spotinst.StatefulNodeAzureAttachDataDiskArgs{
    			DataDiskName:              pulumi.String("string"),
    			DataDiskResourceGroupName: pulumi.String("string"),
    			SizeGb:                    pulumi.Int(0),
    			StorageAccountType:        pulumi.String("string"),
    			Lun:                       pulumi.Int(0),
    			Zone:                      pulumi.String("string"),
    		},
    	},
    	ImportVms: spotinst.StatefulNodeAzureImportVmArray{
    		&spotinst.StatefulNodeAzureImportVmArgs{
    			OriginalVmName:         pulumi.String("string"),
    			ResourceGroupName:      pulumi.String("string"),
    			DrainingTimeout:        pulumi.Int(0),
    			ResourcesRetentionTime: pulumi.Int(0),
    		},
    	},
    	LicenseType: pulumi.String("string"),
    	LoadBalancers: spotinst.StatefulNodeAzureLoadBalancerArray{
    		&spotinst.StatefulNodeAzureLoadBalancerArgs{
    			BackendPoolNames: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Name:              pulumi.String("string"),
    			ResourceGroupName: pulumi.String("string"),
    			Type:              pulumi.String("string"),
    			Sku:               pulumi.String("string"),
    		},
    	},
    	Login: &spotinst.StatefulNodeAzureLoginArgs{
    		UserName:     pulumi.String("string"),
    		Password:     pulumi.String("string"),
    		SshPublicKey: pulumi.String("string"),
    	},
    	ManagedServiceIdentities: spotinst.StatefulNodeAzureManagedServiceIdentityArray{
    		&spotinst.StatefulNodeAzureManagedServiceIdentityArgs{
    			Name:              pulumi.String("string"),
    			ResourceGroupName: pulumi.String("string"),
    		},
    	},
    	Name: pulumi.String("string"),
    	Network: &spotinst.StatefulNodeAzureNetworkArgs{
    		NetworkInterfaces: spotinst.StatefulNodeAzureNetworkNetworkInterfaceArray{
    			&spotinst.StatefulNodeAzureNetworkNetworkInterfaceArgs{
    				IsPrimary:  pulumi.Bool(false),
    				SubnetName: pulumi.String("string"),
    				AdditionalIpConfigurations: spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArray{
    					&spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs{
    						Name:                    pulumi.String("string"),
    						PrivateIpAddressVersion: pulumi.String("string"),
    					},
    				},
    				ApplicationSecurityGroups: spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArray{
    					&spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs{
    						Name:                     pulumi.String("string"),
    						NetworkResourceGroupName: pulumi.String("string"),
    					},
    				},
    				AssignPublicIp:     pulumi.Bool(false),
    				EnableIpForwarding: pulumi.Bool(false),
    				NetworkSecurityGroups: spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArray{
    					&spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs{
    						Name:                     pulumi.String("string"),
    						NetworkResourceGroupName: pulumi.String("string"),
    					},
    				},
    				PrivateIpAddresses: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				PublicIpSku: pulumi.String("string"),
    				PublicIps: spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArray{
    					&spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs{
    						Name:                     pulumi.String("string"),
    						NetworkResourceGroupName: pulumi.String("string"),
    					},
    				},
    			},
    		},
    		NetworkResourceGroupName: pulumi.String("string"),
    		VirtualNetworkName:       pulumi.String("string"),
    	},
    	Extensions: spotinst.StatefulNodeAzureExtensionArray{
    		&spotinst.StatefulNodeAzureExtensionArgs{
    			ApiVersion:              pulumi.String("string"),
    			MinorVersionAutoUpgrade: pulumi.Bool(false),
    			Name:                    pulumi.String("string"),
    			Publisher:               pulumi.String("string"),
    			Type:                    pulumi.String("string"),
    			ProtectedSettings: pulumi.Map{
    				"string": pulumi.Any("any"),
    			},
    			PublicSettings: pulumi.Map{
    				"string": pulumi.Any("any"),
    			},
    		},
    	},
    	OsDisk: &spotinst.StatefulNodeAzureOsDiskArgs{
    		Type:    pulumi.String("string"),
    		Caching: pulumi.String("string"),
    		SizeGb:  pulumi.Int(0),
    	},
    	OsDiskPersistenceMode: pulumi.String("string"),
    	PreferredZone:         pulumi.String("string"),
    	ProximityPlacementGroups: spotinst.StatefulNodeAzureProximityPlacementGroupArray{
    		&spotinst.StatefulNodeAzureProximityPlacementGroupArgs{
    			Name:              pulumi.String("string"),
    			ResourceGroupName: pulumi.String("string"),
    		},
    	},
    	DetachDataDisks: spotinst.StatefulNodeAzureDetachDataDiskArray{
    		&spotinst.StatefulNodeAzureDetachDataDiskArgs{
    			DataDiskName:              pulumi.String("string"),
    			DataDiskResourceGroupName: pulumi.String("string"),
    			ShouldDeallocate:          pulumi.Bool(false),
    			TtlInHours:                pulumi.Int(0),
    		},
    	},
    	Description: pulumi.String("string"),
    	Health: &spotinst.StatefulNodeAzureHealthArgs{
    		AutoHealing: pulumi.Bool(false),
    		HealthCheckTypes: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		GracePeriod:       pulumi.Int(0),
    		UnhealthyDuration: pulumi.Int(0),
    	},
    	Secrets: spotinst.StatefulNodeAzureSecretArray{
    		&spotinst.StatefulNodeAzureSecretArgs{
    			SourceVaults: spotinst.StatefulNodeAzureSecretSourceVaultArray{
    				&spotinst.StatefulNodeAzureSecretSourceVaultArgs{
    					Name:              pulumi.String("string"),
    					ResourceGroupName: pulumi.String("string"),
    				},
    			},
    			VaultCertificates: spotinst.StatefulNodeAzureSecretVaultCertificateArray{
    				&spotinst.StatefulNodeAzureSecretVaultCertificateArgs{
    					CertificateStore: pulumi.String("string"),
    					CertificateUrl:   pulumi.String("string"),
    				},
    			},
    		},
    	},
    	Security: &spotinst.StatefulNodeAzureSecurityArgs{
    		SecureBootEnabled: pulumi.Bool(false),
    		SecurityType:      pulumi.String("string"),
    		VtpmEnabled:       pulumi.Bool(false),
    	},
    	Deletes: spotinst.StatefulNodeAzureDeleteArray{
    		&spotinst.StatefulNodeAzureDeleteArgs{
    			DiskShouldDeallocate:     pulumi.Bool(false),
    			NetworkShouldDeallocate:  pulumi.Bool(false),
    			PublicIpShouldDeallocate: pulumi.Bool(false),
    			ShouldTerminateVm:        pulumi.Bool(false),
    			SnapshotShouldDeallocate: pulumi.Bool(false),
    			DiskTtlInHours:           pulumi.Int(0),
    			NetworkTtlInHours:        pulumi.Int(0),
    			PublicIpTtlInHours:       pulumi.Int(0),
    			ShouldDeregisterFromLb:   pulumi.Bool(false),
    			SnapshotTtlInHours:       pulumi.Int(0),
    		},
    	},
    	DataDisksPersistenceMode: pulumi.String("string"),
    	DataDisks: spotinst.StatefulNodeAzureDataDiskArray{
    		&spotinst.StatefulNodeAzureDataDiskArgs{
    			Lun:    pulumi.Int(0),
    			SizeGb: pulumi.Int(0),
    			Type:   pulumi.String("string"),
    		},
    	},
    	ShouldPersistVm: pulumi.Bool(false),
    	ShutdownScript:  pulumi.String("string"),
    	Signals: spotinst.StatefulNodeAzureSignalArray{
    		&spotinst.StatefulNodeAzureSignalArgs{
    			Timeout: pulumi.Int(0),
    			Type:    pulumi.String("string"),
    		},
    	},
    	CustomData: pulumi.String("string"),
    	Tags: spotinst.StatefulNodeAzureTagArray{
    		&spotinst.StatefulNodeAzureTagArgs{
    			TagKey:   pulumi.String("string"),
    			TagValue: pulumi.String("string"),
    		},
    	},
    	UpdateStates: spotinst.StatefulNodeAzureUpdateStateArray{
    		&spotinst.StatefulNodeAzureUpdateStateArgs{
    			State: pulumi.String("string"),
    		},
    	},
    	UserData:     pulumi.String("string"),
    	VmName:       pulumi.String("string"),
    	VmNamePrefix: pulumi.String("string"),
    	BootDiagnostics: spotinst.StatefulNodeAzureBootDiagnosticArray{
    		&spotinst.StatefulNodeAzureBootDiagnosticArgs{
    			IsEnabled:  pulumi.Bool(false),
    			StorageUrl: pulumi.String("string"),
    			Type:       pulumi.String("string"),
    		},
    	},
    	Zones: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    })
    
    var statefulNodeAzureResource = new StatefulNodeAzure("statefulNodeAzureResource", StatefulNodeAzureArgs.builder()
        .os("string")
        .vmSizes(StatefulNodeAzureVmSizesArgs.builder()
            .odSizes("string")
            .spotSizes("string")
            .preferredSpotSizes("string")
            .build())
        .strategy(StatefulNodeAzureStrategyArgs.builder()
            .fallbackToOnDemand(false)
            .availabilityVsCost(0)
            .capacityReservations(StatefulNodeAzureStrategyCapacityReservationArgs.builder()
                .shouldUtilize(false)
                .utilizationStrategy("string")
                .capacityReservationGroups(StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs.builder()
                    .crgName("string")
                    .crgResourceGroupName("string")
                    .crgShouldPrioritize(false)
                    .build())
                .build())
            .drainingTimeout(0)
            .odWindows("string")
            .optimizationWindows("string")
            .preferredLifeCycle("string")
            .revertToSpot(StatefulNodeAzureStrategyRevertToSpotArgs.builder()
                .performAt("string")
                .build())
            .build())
        .shouldPersistOsDisk(false)
        .shouldPersistNetwork(false)
        .shouldPersistDataDisks(false)
        .resourceGroupName("string")
        .region("string")
        .image(StatefulNodeAzureImageArgs.builder()
            .customImages(StatefulNodeAzureImageCustomImageArgs.builder()
                .customImageResourceGroupName("string")
                .name("string")
                .build())
            .galleries(StatefulNodeAzureImageGalleryArgs.builder()
                .galleryName("string")
                .galleryResourceGroupName("string")
                .imageName("string")
                .versionName("string")
                .spotAccountId("string")
                .build())
            .marketplaceImages(StatefulNodeAzureImageMarketplaceImageArgs.builder()
                .offer("string")
                .publisher("string")
                .sku("string")
                .version("string")
                .build())
            .build())
        .schedulingTasks(StatefulNodeAzureSchedulingTaskArgs.builder()
            .cronExpression("string")
            .isEnabled(false)
            .type("string")
            .build())
        .attachDataDisks(StatefulNodeAzureAttachDataDiskArgs.builder()
            .dataDiskName("string")
            .dataDiskResourceGroupName("string")
            .sizeGb(0)
            .storageAccountType("string")
            .lun(0)
            .zone("string")
            .build())
        .importVms(StatefulNodeAzureImportVmArgs.builder()
            .originalVmName("string")
            .resourceGroupName("string")
            .drainingTimeout(0)
            .resourcesRetentionTime(0)
            .build())
        .licenseType("string")
        .loadBalancers(StatefulNodeAzureLoadBalancerArgs.builder()
            .backendPoolNames("string")
            .name("string")
            .resourceGroupName("string")
            .type("string")
            .sku("string")
            .build())
        .login(StatefulNodeAzureLoginArgs.builder()
            .userName("string")
            .password("string")
            .sshPublicKey("string")
            .build())
        .managedServiceIdentities(StatefulNodeAzureManagedServiceIdentityArgs.builder()
            .name("string")
            .resourceGroupName("string")
            .build())
        .name("string")
        .network(StatefulNodeAzureNetworkArgs.builder()
            .networkInterfaces(StatefulNodeAzureNetworkNetworkInterfaceArgs.builder()
                .isPrimary(false)
                .subnetName("string")
                .additionalIpConfigurations(StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs.builder()
                    .name("string")
                    .privateIpAddressVersion("string")
                    .build())
                .applicationSecurityGroups(StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs.builder()
                    .name("string")
                    .networkResourceGroupName("string")
                    .build())
                .assignPublicIp(false)
                .enableIpForwarding(false)
                .networkSecurityGroups(StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs.builder()
                    .name("string")
                    .networkResourceGroupName("string")
                    .build())
                .privateIpAddresses("string")
                .publicIpSku("string")
                .publicIps(StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs.builder()
                    .name("string")
                    .networkResourceGroupName("string")
                    .build())
                .build())
            .networkResourceGroupName("string")
            .virtualNetworkName("string")
            .build())
        .extensions(StatefulNodeAzureExtensionArgs.builder()
            .apiVersion("string")
            .minorVersionAutoUpgrade(false)
            .name("string")
            .publisher("string")
            .type("string")
            .protectedSettings(Map.of("string", "any"))
            .publicSettings(Map.of("string", "any"))
            .build())
        .osDisk(StatefulNodeAzureOsDiskArgs.builder()
            .type("string")
            .caching("string")
            .sizeGb(0)
            .build())
        .osDiskPersistenceMode("string")
        .preferredZone("string")
        .proximityPlacementGroups(StatefulNodeAzureProximityPlacementGroupArgs.builder()
            .name("string")
            .resourceGroupName("string")
            .build())
        .detachDataDisks(StatefulNodeAzureDetachDataDiskArgs.builder()
            .dataDiskName("string")
            .dataDiskResourceGroupName("string")
            .shouldDeallocate(false)
            .ttlInHours(0)
            .build())
        .description("string")
        .health(StatefulNodeAzureHealthArgs.builder()
            .autoHealing(false)
            .healthCheckTypes("string")
            .gracePeriod(0)
            .unhealthyDuration(0)
            .build())
        .secrets(StatefulNodeAzureSecretArgs.builder()
            .sourceVaults(StatefulNodeAzureSecretSourceVaultArgs.builder()
                .name("string")
                .resourceGroupName("string")
                .build())
            .vaultCertificates(StatefulNodeAzureSecretVaultCertificateArgs.builder()
                .certificateStore("string")
                .certificateUrl("string")
                .build())
            .build())
        .security(StatefulNodeAzureSecurityArgs.builder()
            .secureBootEnabled(false)
            .securityType("string")
            .vtpmEnabled(false)
            .build())
        .deletes(StatefulNodeAzureDeleteArgs.builder()
            .diskShouldDeallocate(false)
            .networkShouldDeallocate(false)
            .publicIpShouldDeallocate(false)
            .shouldTerminateVm(false)
            .snapshotShouldDeallocate(false)
            .diskTtlInHours(0)
            .networkTtlInHours(0)
            .publicIpTtlInHours(0)
            .shouldDeregisterFromLb(false)
            .snapshotTtlInHours(0)
            .build())
        .dataDisksPersistenceMode("string")
        .dataDisks(StatefulNodeAzureDataDiskArgs.builder()
            .lun(0)
            .sizeGb(0)
            .type("string")
            .build())
        .shouldPersistVm(false)
        .shutdownScript("string")
        .signals(StatefulNodeAzureSignalArgs.builder()
            .timeout(0)
            .type("string")
            .build())
        .customData("string")
        .tags(StatefulNodeAzureTagArgs.builder()
            .tagKey("string")
            .tagValue("string")
            .build())
        .updateStates(StatefulNodeAzureUpdateStateArgs.builder()
            .state("string")
            .build())
        .userData("string")
        .vmName("string")
        .vmNamePrefix("string")
        .bootDiagnostics(StatefulNodeAzureBootDiagnosticArgs.builder()
            .isEnabled(false)
            .storageUrl("string")
            .type("string")
            .build())
        .zones("string")
        .build());
    
    stateful_node_azure_resource = spotinst.StatefulNodeAzure("statefulNodeAzureResource",
        os="string",
        vm_sizes=spotinst.StatefulNodeAzureVmSizesArgs(
            od_sizes=["string"],
            spot_sizes=["string"],
            preferred_spot_sizes=["string"],
        ),
        strategy=spotinst.StatefulNodeAzureStrategyArgs(
            fallback_to_on_demand=False,
            availability_vs_cost=0,
            capacity_reservations=[spotinst.StatefulNodeAzureStrategyCapacityReservationArgs(
                should_utilize=False,
                utilization_strategy="string",
                capacity_reservation_groups=[spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs(
                    crg_name="string",
                    crg_resource_group_name="string",
                    crg_should_prioritize=False,
                )],
            )],
            draining_timeout=0,
            od_windows=["string"],
            optimization_windows=["string"],
            preferred_life_cycle="string",
            revert_to_spot=spotinst.StatefulNodeAzureStrategyRevertToSpotArgs(
                perform_at="string",
            ),
        ),
        should_persist_os_disk=False,
        should_persist_network=False,
        should_persist_data_disks=False,
        resource_group_name="string",
        region="string",
        image=spotinst.StatefulNodeAzureImageArgs(
            custom_images=[spotinst.StatefulNodeAzureImageCustomImageArgs(
                custom_image_resource_group_name="string",
                name="string",
            )],
            galleries=[spotinst.StatefulNodeAzureImageGalleryArgs(
                gallery_name="string",
                gallery_resource_group_name="string",
                image_name="string",
                version_name="string",
                spot_account_id="string",
            )],
            marketplace_images=[spotinst.StatefulNodeAzureImageMarketplaceImageArgs(
                offer="string",
                publisher="string",
                sku="string",
                version="string",
            )],
        ),
        scheduling_tasks=[spotinst.StatefulNodeAzureSchedulingTaskArgs(
            cron_expression="string",
            is_enabled=False,
            type="string",
        )],
        attach_data_disks=[spotinst.StatefulNodeAzureAttachDataDiskArgs(
            data_disk_name="string",
            data_disk_resource_group_name="string",
            size_gb=0,
            storage_account_type="string",
            lun=0,
            zone="string",
        )],
        import_vms=[spotinst.StatefulNodeAzureImportVmArgs(
            original_vm_name="string",
            resource_group_name="string",
            draining_timeout=0,
            resources_retention_time=0,
        )],
        license_type="string",
        load_balancers=[spotinst.StatefulNodeAzureLoadBalancerArgs(
            backend_pool_names=["string"],
            name="string",
            resource_group_name="string",
            type="string",
            sku="string",
        )],
        login=spotinst.StatefulNodeAzureLoginArgs(
            user_name="string",
            password="string",
            ssh_public_key="string",
        ),
        managed_service_identities=[spotinst.StatefulNodeAzureManagedServiceIdentityArgs(
            name="string",
            resource_group_name="string",
        )],
        name="string",
        network=spotinst.StatefulNodeAzureNetworkArgs(
            network_interfaces=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceArgs(
                is_primary=False,
                subnet_name="string",
                additional_ip_configurations=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs(
                    name="string",
                    private_ip_address_version="string",
                )],
                application_security_groups=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs(
                    name="string",
                    network_resource_group_name="string",
                )],
                assign_public_ip=False,
                enable_ip_forwarding=False,
                network_security_groups=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs(
                    name="string",
                    network_resource_group_name="string",
                )],
                private_ip_addresses=["string"],
                public_ip_sku="string",
                public_ips=[spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs(
                    name="string",
                    network_resource_group_name="string",
                )],
            )],
            network_resource_group_name="string",
            virtual_network_name="string",
        ),
        extensions=[spotinst.StatefulNodeAzureExtensionArgs(
            api_version="string",
            minor_version_auto_upgrade=False,
            name="string",
            publisher="string",
            type="string",
            protected_settings={
                "string": "any",
            },
            public_settings={
                "string": "any",
            },
        )],
        os_disk=spotinst.StatefulNodeAzureOsDiskArgs(
            type="string",
            caching="string",
            size_gb=0,
        ),
        os_disk_persistence_mode="string",
        preferred_zone="string",
        proximity_placement_groups=[spotinst.StatefulNodeAzureProximityPlacementGroupArgs(
            name="string",
            resource_group_name="string",
        )],
        detach_data_disks=[spotinst.StatefulNodeAzureDetachDataDiskArgs(
            data_disk_name="string",
            data_disk_resource_group_name="string",
            should_deallocate=False,
            ttl_in_hours=0,
        )],
        description="string",
        health=spotinst.StatefulNodeAzureHealthArgs(
            auto_healing=False,
            health_check_types=["string"],
            grace_period=0,
            unhealthy_duration=0,
        ),
        secrets=[spotinst.StatefulNodeAzureSecretArgs(
            source_vaults=[spotinst.StatefulNodeAzureSecretSourceVaultArgs(
                name="string",
                resource_group_name="string",
            )],
            vault_certificates=[spotinst.StatefulNodeAzureSecretVaultCertificateArgs(
                certificate_store="string",
                certificate_url="string",
            )],
        )],
        security=spotinst.StatefulNodeAzureSecurityArgs(
            secure_boot_enabled=False,
            security_type="string",
            vtpm_enabled=False,
        ),
        deletes=[spotinst.StatefulNodeAzureDeleteArgs(
            disk_should_deallocate=False,
            network_should_deallocate=False,
            public_ip_should_deallocate=False,
            should_terminate_vm=False,
            snapshot_should_deallocate=False,
            disk_ttl_in_hours=0,
            network_ttl_in_hours=0,
            public_ip_ttl_in_hours=0,
            should_deregister_from_lb=False,
            snapshot_ttl_in_hours=0,
        )],
        data_disks_persistence_mode="string",
        data_disks=[spotinst.StatefulNodeAzureDataDiskArgs(
            lun=0,
            size_gb=0,
            type="string",
        )],
        should_persist_vm=False,
        shutdown_script="string",
        signals=[spotinst.StatefulNodeAzureSignalArgs(
            timeout=0,
            type="string",
        )],
        custom_data="string",
        tags=[spotinst.StatefulNodeAzureTagArgs(
            tag_key="string",
            tag_value="string",
        )],
        update_states=[spotinst.StatefulNodeAzureUpdateStateArgs(
            state="string",
        )],
        user_data="string",
        vm_name="string",
        vm_name_prefix="string",
        boot_diagnostics=[spotinst.StatefulNodeAzureBootDiagnosticArgs(
            is_enabled=False,
            storage_url="string",
            type="string",
        )],
        zones=["string"])
    
    const statefulNodeAzureResource = new spotinst.StatefulNodeAzure("statefulNodeAzureResource", {
        os: "string",
        vmSizes: {
            odSizes: ["string"],
            spotSizes: ["string"],
            preferredSpotSizes: ["string"],
        },
        strategy: {
            fallbackToOnDemand: false,
            availabilityVsCost: 0,
            capacityReservations: [{
                shouldUtilize: false,
                utilizationStrategy: "string",
                capacityReservationGroups: [{
                    crgName: "string",
                    crgResourceGroupName: "string",
                    crgShouldPrioritize: false,
                }],
            }],
            drainingTimeout: 0,
            odWindows: ["string"],
            optimizationWindows: ["string"],
            preferredLifeCycle: "string",
            revertToSpot: {
                performAt: "string",
            },
        },
        shouldPersistOsDisk: false,
        shouldPersistNetwork: false,
        shouldPersistDataDisks: false,
        resourceGroupName: "string",
        region: "string",
        image: {
            customImages: [{
                customImageResourceGroupName: "string",
                name: "string",
            }],
            galleries: [{
                galleryName: "string",
                galleryResourceGroupName: "string",
                imageName: "string",
                versionName: "string",
                spotAccountId: "string",
            }],
            marketplaceImages: [{
                offer: "string",
                publisher: "string",
                sku: "string",
                version: "string",
            }],
        },
        schedulingTasks: [{
            cronExpression: "string",
            isEnabled: false,
            type: "string",
        }],
        attachDataDisks: [{
            dataDiskName: "string",
            dataDiskResourceGroupName: "string",
            sizeGb: 0,
            storageAccountType: "string",
            lun: 0,
            zone: "string",
        }],
        importVms: [{
            originalVmName: "string",
            resourceGroupName: "string",
            drainingTimeout: 0,
            resourcesRetentionTime: 0,
        }],
        licenseType: "string",
        loadBalancers: [{
            backendPoolNames: ["string"],
            name: "string",
            resourceGroupName: "string",
            type: "string",
            sku: "string",
        }],
        login: {
            userName: "string",
            password: "string",
            sshPublicKey: "string",
        },
        managedServiceIdentities: [{
            name: "string",
            resourceGroupName: "string",
        }],
        name: "string",
        network: {
            networkInterfaces: [{
                isPrimary: false,
                subnetName: "string",
                additionalIpConfigurations: [{
                    name: "string",
                    privateIpAddressVersion: "string",
                }],
                applicationSecurityGroups: [{
                    name: "string",
                    networkResourceGroupName: "string",
                }],
                assignPublicIp: false,
                enableIpForwarding: false,
                networkSecurityGroups: [{
                    name: "string",
                    networkResourceGroupName: "string",
                }],
                privateIpAddresses: ["string"],
                publicIpSku: "string",
                publicIps: [{
                    name: "string",
                    networkResourceGroupName: "string",
                }],
            }],
            networkResourceGroupName: "string",
            virtualNetworkName: "string",
        },
        extensions: [{
            apiVersion: "string",
            minorVersionAutoUpgrade: false,
            name: "string",
            publisher: "string",
            type: "string",
            protectedSettings: {
                string: "any",
            },
            publicSettings: {
                string: "any",
            },
        }],
        osDisk: {
            type: "string",
            caching: "string",
            sizeGb: 0,
        },
        osDiskPersistenceMode: "string",
        preferredZone: "string",
        proximityPlacementGroups: [{
            name: "string",
            resourceGroupName: "string",
        }],
        detachDataDisks: [{
            dataDiskName: "string",
            dataDiskResourceGroupName: "string",
            shouldDeallocate: false,
            ttlInHours: 0,
        }],
        description: "string",
        health: {
            autoHealing: false,
            healthCheckTypes: ["string"],
            gracePeriod: 0,
            unhealthyDuration: 0,
        },
        secrets: [{
            sourceVaults: [{
                name: "string",
                resourceGroupName: "string",
            }],
            vaultCertificates: [{
                certificateStore: "string",
                certificateUrl: "string",
            }],
        }],
        security: {
            secureBootEnabled: false,
            securityType: "string",
            vtpmEnabled: false,
        },
        deletes: [{
            diskShouldDeallocate: false,
            networkShouldDeallocate: false,
            publicIpShouldDeallocate: false,
            shouldTerminateVm: false,
            snapshotShouldDeallocate: false,
            diskTtlInHours: 0,
            networkTtlInHours: 0,
            publicIpTtlInHours: 0,
            shouldDeregisterFromLb: false,
            snapshotTtlInHours: 0,
        }],
        dataDisksPersistenceMode: "string",
        dataDisks: [{
            lun: 0,
            sizeGb: 0,
            type: "string",
        }],
        shouldPersistVm: false,
        shutdownScript: "string",
        signals: [{
            timeout: 0,
            type: "string",
        }],
        customData: "string",
        tags: [{
            tagKey: "string",
            tagValue: "string",
        }],
        updateStates: [{
            state: "string",
        }],
        userData: "string",
        vmName: "string",
        vmNamePrefix: "string",
        bootDiagnostics: [{
            isEnabled: false,
            storageUrl: "string",
            type: "string",
        }],
        zones: ["string"],
    });
    
    type: spotinst:StatefulNodeAzure
    properties:
        attachDataDisks:
            - dataDiskName: string
              dataDiskResourceGroupName: string
              lun: 0
              sizeGb: 0
              storageAccountType: string
              zone: string
        bootDiagnostics:
            - isEnabled: false
              storageUrl: string
              type: string
        customData: string
        dataDisks:
            - lun: 0
              sizeGb: 0
              type: string
        dataDisksPersistenceMode: string
        deletes:
            - diskShouldDeallocate: false
              diskTtlInHours: 0
              networkShouldDeallocate: false
              networkTtlInHours: 0
              publicIpShouldDeallocate: false
              publicIpTtlInHours: 0
              shouldDeregisterFromLb: false
              shouldTerminateVm: false
              snapshotShouldDeallocate: false
              snapshotTtlInHours: 0
        description: string
        detachDataDisks:
            - dataDiskName: string
              dataDiskResourceGroupName: string
              shouldDeallocate: false
              ttlInHours: 0
        extensions:
            - apiVersion: string
              minorVersionAutoUpgrade: false
              name: string
              protectedSettings:
                string: any
              publicSettings:
                string: any
              publisher: string
              type: string
        health:
            autoHealing: false
            gracePeriod: 0
            healthCheckTypes:
                - string
            unhealthyDuration: 0
        image:
            customImages:
                - customImageResourceGroupName: string
                  name: string
            galleries:
                - galleryName: string
                  galleryResourceGroupName: string
                  imageName: string
                  spotAccountId: string
                  versionName: string
            marketplaceImages:
                - offer: string
                  publisher: string
                  sku: string
                  version: string
        importVms:
            - drainingTimeout: 0
              originalVmName: string
              resourceGroupName: string
              resourcesRetentionTime: 0
        licenseType: string
        loadBalancers:
            - backendPoolNames:
                - string
              name: string
              resourceGroupName: string
              sku: string
              type: string
        login:
            password: string
            sshPublicKey: string
            userName: string
        managedServiceIdentities:
            - name: string
              resourceGroupName: string
        name: string
        network:
            networkInterfaces:
                - additionalIpConfigurations:
                    - name: string
                      privateIpAddressVersion: string
                  applicationSecurityGroups:
                    - name: string
                      networkResourceGroupName: string
                  assignPublicIp: false
                  enableIpForwarding: false
                  isPrimary: false
                  networkSecurityGroups:
                    - name: string
                      networkResourceGroupName: string
                  privateIpAddresses:
                    - string
                  publicIpSku: string
                  publicIps:
                    - name: string
                      networkResourceGroupName: string
                  subnetName: string
            networkResourceGroupName: string
            virtualNetworkName: string
        os: string
        osDisk:
            caching: string
            sizeGb: 0
            type: string
        osDiskPersistenceMode: string
        preferredZone: string
        proximityPlacementGroups:
            - name: string
              resourceGroupName: string
        region: string
        resourceGroupName: string
        schedulingTasks:
            - cronExpression: string
              isEnabled: false
              type: string
        secrets:
            - sourceVaults:
                - name: string
                  resourceGroupName: string
              vaultCertificates:
                - certificateStore: string
                  certificateUrl: string
        security:
            secureBootEnabled: false
            securityType: string
            vtpmEnabled: false
        shouldPersistDataDisks: false
        shouldPersistNetwork: false
        shouldPersistOsDisk: false
        shouldPersistVm: false
        shutdownScript: string
        signals:
            - timeout: 0
              type: string
        strategy:
            availabilityVsCost: 0
            capacityReservations:
                - capacityReservationGroups:
                    - crgName: string
                      crgResourceGroupName: string
                      crgShouldPrioritize: false
                  shouldUtilize: false
                  utilizationStrategy: string
            drainingTimeout: 0
            fallbackToOnDemand: false
            odWindows:
                - string
            optimizationWindows:
                - string
            preferredLifeCycle: string
            revertToSpot:
                performAt: string
        tags:
            - tagKey: string
              tagValue: string
        updateStates:
            - state: string
        userData: string
        vmName: string
        vmNamePrefix: string
        vmSizes:
            odSizes:
                - string
            preferredSpotSizes:
                - string
            spotSizes:
                - string
        zones:
            - string
    

    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:

    Os string
    Region string
    ResourceGroupName string
    ShouldPersistDataDisks bool
    ShouldPersistNetwork bool
    ShouldPersistOsDisk bool
    Strategy Pulumi.SpotInst.Inputs.StatefulNodeAzureStrategy
    VmSizes Pulumi.SpotInst.Inputs.StatefulNodeAzureVmSizes
    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>
    LicenseType string
    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
    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
    VmNamePrefix string
    Zones List<string>
    Os string
    Region string
    ResourceGroupName string
    ShouldPersistDataDisks bool
    ShouldPersistNetwork bool
    ShouldPersistOsDisk bool
    Strategy StatefulNodeAzureStrategyArgs
    VmSizes StatefulNodeAzureVmSizesArgs
    AttachDataDisks []StatefulNodeAzureAttachDataDiskArgs
    BootDiagnostics []StatefulNodeAzureBootDiagnosticArgs
    CustomData string
    DataDisks []StatefulNodeAzureDataDiskArgs
    DataDisksPersistenceMode string
    Deletes []StatefulNodeAzureDeleteArgs
    Description string
    DetachDataDisks []StatefulNodeAzureDetachDataDiskArgs
    Extensions []StatefulNodeAzureExtensionArgs
    Health StatefulNodeAzureHealthArgs
    Image StatefulNodeAzureImageArgs
    ImportVms []StatefulNodeAzureImportVmArgs
    LicenseType string
    LoadBalancers []StatefulNodeAzureLoadBalancerArgs
    Login StatefulNodeAzureLoginArgs
    ManagedServiceIdentities []StatefulNodeAzureManagedServiceIdentityArgs
    Name string
    Network StatefulNodeAzureNetworkArgs
    OsDisk StatefulNodeAzureOsDiskArgs
    OsDiskPersistenceMode 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
    VmNamePrefix string
    Zones []string
    os String
    region String
    resourceGroupName String
    shouldPersistDataDisks Boolean
    shouldPersistNetwork Boolean
    shouldPersistOsDisk Boolean
    strategy StatefulNodeAzureStrategy
    vmSizes StatefulNodeAzureVmSizes
    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>
    licenseType String
    loadBalancers List<StatefulNodeAzureLoadBalancer>
    login StatefulNodeAzureLogin
    managedServiceIdentities List<StatefulNodeAzureManagedServiceIdentity>
    name String
    network StatefulNodeAzureNetwork
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode 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
    vmNamePrefix String
    zones List<String>
    os string
    region string
    resourceGroupName string
    shouldPersistDataDisks boolean
    shouldPersistNetwork boolean
    shouldPersistOsDisk boolean
    strategy StatefulNodeAzureStrategy
    vmSizes StatefulNodeAzureVmSizes
    attachDataDisks StatefulNodeAzureAttachDataDisk[]
    bootDiagnostics StatefulNodeAzureBootDiagnostic[]
    customData string
    dataDisks StatefulNodeAzureDataDisk[]
    dataDisksPersistenceMode string
    deletes StatefulNodeAzureDelete[]
    description string
    detachDataDisks StatefulNodeAzureDetachDataDisk[]
    extensions StatefulNodeAzureExtension[]
    health StatefulNodeAzureHealth
    image StatefulNodeAzureImage
    importVms StatefulNodeAzureImportVm[]
    licenseType string
    loadBalancers StatefulNodeAzureLoadBalancer[]
    login StatefulNodeAzureLogin
    managedServiceIdentities StatefulNodeAzureManagedServiceIdentity[]
    name string
    network StatefulNodeAzureNetwork
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode 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
    vmNamePrefix string
    zones string[]
    os str
    region str
    resource_group_name str
    should_persist_data_disks bool
    should_persist_network bool
    should_persist_os_disk bool
    strategy StatefulNodeAzureStrategyArgs
    vm_sizes StatefulNodeAzureVmSizesArgs
    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]
    license_type str
    load_balancers Sequence[StatefulNodeAzureLoadBalancerArgs]
    login StatefulNodeAzureLoginArgs
    managed_service_identities Sequence[StatefulNodeAzureManagedServiceIdentityArgs]
    name str
    network StatefulNodeAzureNetworkArgs
    os_disk StatefulNodeAzureOsDiskArgs
    os_disk_persistence_mode 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
    vm_name_prefix str
    zones Sequence[str]
    os String
    region String
    resourceGroupName String
    shouldPersistDataDisks Boolean
    shouldPersistNetwork Boolean
    shouldPersistOsDisk Boolean
    strategy Property Map
    vmSizes 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>
    licenseType String
    loadBalancers List<Property Map>
    login Property Map
    managedServiceIdentities List<Property Map>
    name String
    network Property Map
    osDisk Property Map
    osDiskPersistenceMode 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
    vmNamePrefix 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,
            license_type: Optional[str] = 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,
            os: Optional[str] = None,
            os_disk: Optional[StatefulNodeAzureOsDiskArgs] = None,
            os_disk_persistence_mode: Optional[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,
            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,
            vm_name_prefix: Optional[str] = None,
            vm_sizes: Optional[StatefulNodeAzureVmSizesArgs] = 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>
    LicenseType string
    LoadBalancers List<Pulumi.SpotInst.Inputs.StatefulNodeAzureLoadBalancer>
    Login Pulumi.SpotInst.Inputs.StatefulNodeAzureLogin
    ManagedServiceIdentities List<Pulumi.SpotInst.Inputs.StatefulNodeAzureManagedServiceIdentity>
    Name string
    Network Pulumi.SpotInst.Inputs.StatefulNodeAzureNetwork
    Os string
    OsDisk Pulumi.SpotInst.Inputs.StatefulNodeAzureOsDisk
    OsDiskPersistenceMode 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>
    Strategy Pulumi.SpotInst.Inputs.StatefulNodeAzureStrategy
    Tags List<Pulumi.SpotInst.Inputs.StatefulNodeAzureTag>
    UpdateStates List<Pulumi.SpotInst.Inputs.StatefulNodeAzureUpdateState>
    UserData string
    VmName string
    VmNamePrefix string
    VmSizes Pulumi.SpotInst.Inputs.StatefulNodeAzureVmSizes
    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
    LicenseType string
    LoadBalancers []StatefulNodeAzureLoadBalancerArgs
    Login StatefulNodeAzureLoginArgs
    ManagedServiceIdentities []StatefulNodeAzureManagedServiceIdentityArgs
    Name string
    Network StatefulNodeAzureNetworkArgs
    Os string
    OsDisk StatefulNodeAzureOsDiskArgs
    OsDiskPersistenceMode 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
    Strategy StatefulNodeAzureStrategyArgs
    Tags []StatefulNodeAzureTagArgs
    UpdateStates []StatefulNodeAzureUpdateStateArgs
    UserData string
    VmName string
    VmNamePrefix string
    VmSizes StatefulNodeAzureVmSizesArgs
    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>
    licenseType String
    loadBalancers List<StatefulNodeAzureLoadBalancer>
    login StatefulNodeAzureLogin
    managedServiceIdentities List<StatefulNodeAzureManagedServiceIdentity>
    name String
    network StatefulNodeAzureNetwork
    os String
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode 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>
    strategy StatefulNodeAzureStrategy
    tags List<StatefulNodeAzureTag>
    updateStates List<StatefulNodeAzureUpdateState>
    userData String
    vmName String
    vmNamePrefix String
    vmSizes StatefulNodeAzureVmSizes
    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[]
    licenseType string
    loadBalancers StatefulNodeAzureLoadBalancer[]
    login StatefulNodeAzureLogin
    managedServiceIdentities StatefulNodeAzureManagedServiceIdentity[]
    name string
    network StatefulNodeAzureNetwork
    os string
    osDisk StatefulNodeAzureOsDisk
    osDiskPersistenceMode 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[]
    strategy StatefulNodeAzureStrategy
    tags StatefulNodeAzureTag[]
    updateStates StatefulNodeAzureUpdateState[]
    userData string
    vmName string
    vmNamePrefix string
    vmSizes StatefulNodeAzureVmSizes
    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]
    license_type str
    load_balancers Sequence[StatefulNodeAzureLoadBalancerArgs]
    login StatefulNodeAzureLoginArgs
    managed_service_identities Sequence[StatefulNodeAzureManagedServiceIdentityArgs]
    name str
    network StatefulNodeAzureNetworkArgs
    os str
    os_disk StatefulNodeAzureOsDiskArgs
    os_disk_persistence_mode 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]
    strategy StatefulNodeAzureStrategyArgs
    tags Sequence[StatefulNodeAzureTagArgs]
    update_states Sequence[StatefulNodeAzureUpdateStateArgs]
    user_data str
    vm_name str
    vm_name_prefix str
    vm_sizes StatefulNodeAzureVmSizesArgs
    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>
    licenseType String
    loadBalancers List<Property Map>
    login Property Map
    managedServiceIdentities List<Property Map>
    name String
    network Property Map
    os String
    osDisk Property Map
    osDiskPersistenceMode 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>
    strategy Property Map
    tags List<Property Map>
    updateStates List<Property Map>
    userData String
    vmName String
    vmNamePrefix String
    vmSizes Property Map
    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
    Caching string
    SizeGb int
    Type string
    Caching string
    SizeGb int
    type String
    caching String
    sizeGb Integer
    type string
    caching string
    sizeGb number
    type str
    caching str
    size_gb int
    type String
    caching 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