Docs Packages
  1. Packages
  2. Azure Classic
  3. API Docs
  4. network
  5. getPublicIP

We recommend using Azure Native.

Azure Classic v5.81.0 published on Monday, Jun 24, 2024 by Pulumi
pulumi/pulumi-azure

azure.network.getPublicIP

Explore with Pulumi AI

azure logo

We recommend using Azure Native.

Azure Classic v5.81.0 published on Monday, Jun 24, 2024 by Pulumi
pulumi/pulumi-azure

    Use this data source to access information about an existing Public IP Address.

    Example Usage

    Reference An Existing)

    import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const example = azure.network.getPublicIP({
    name: "name_of_public_ip",
    resourceGroupName: "name_of_resource_group",
});
export const domainNameLabel = example.then(example => example.domainNameLabel);
export const publicIpAddress = example.then(example => example.ipAddress);

    import pulumi
import pulumi_azure as azure

example = azure.network.get_public_ip(name="name_of_public_ip",
    resource_group_name="name_of_resource_group")
pulumi.export("domainNameLabel", example.domain_name_label)
pulumi.export("publicIpAddress", example.ip_address)

    package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := network.GetPublicIP(ctx, &network.GetPublicIPArgs{
			Name:              "name_of_public_ip",
			ResourceGroupName: "name_of_resource_group",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("domainNameLabel", example.DomainNameLabel)
		ctx.Export("publicIpAddress", example.IpAddress)
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var example = Azure.Network.GetPublicIP.Invoke(new()
    {
        Name = "name_of_public_ip",
        ResourceGroupName = "name_of_resource_group",
    });

    return new Dictionary<string, object?>
    {
        ["domainNameLabel"] = example.Apply(getPublicIPResult => getPublicIPResult.DomainNameLabel),
        ["publicIpAddress"] = example.Apply(getPublicIPResult => getPublicIPResult.IpAddress),
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.network.NetworkFunctions;
import com.pulumi.azure.network.inputs.GetPublicIPArgs;
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) {
        final var example = NetworkFunctions.getPublicIP(GetPublicIPArgs.builder()
            .name("name_of_public_ip")
            .resourceGroupName("name_of_resource_group")
            .build());

        ctx.export("domainNameLabel", example.applyValue(getPublicIPResult -> getPublicIPResult.domainNameLabel()));
        ctx.export("publicIpAddress", example.applyValue(getPublicIPResult -> getPublicIPResult.ipAddress()));
    }
}

    variables:
  example:
    fn::invoke:
      Function: azure:network:getPublicIP
      Arguments:
        name: name_of_public_ip
        resourceGroupName: name_of_resource_group
outputs:
  domainNameLabel: ${example.domainNameLabel}
  publicIpAddress: ${example.ipAddress}

    Retrieve The Dynamic Public IP Of A New VM)

    import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "test-resources",
    location: "West Europe",
});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("example", {
    name: "test-network",
    addressSpaces: ["10.0.0.0/16"],
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
});
const exampleSubnet = new azure.network.Subnet("example", {
    name: "acctsub",
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.0.2.0/24"],
});
const examplePublicIp = new azure.network.PublicIp("example", {
    name: "test-pip",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    allocationMethod: "Dynamic",
    idleTimeoutInMinutes: 30,
    tags: {
        environment: "test",
    },
});
const exampleNetworkInterface = new azure.network.NetworkInterface("example", {
    name: "test-nic",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    ipConfigurations: [{
        name: "testconfiguration1",
        subnetId: exampleSubnet.id,
        privateIpAddressAllocation: "Static",
        privateIpAddress: "10.0.2.5",
        publicIpAddressId: examplePublicIp.id,
    }],
});
const exampleVirtualMachine = new azure.compute.VirtualMachine("example", {
    name: "test-vm",
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    networkInterfaceIds: [exampleNetworkInterface.id],
});
const example = azure.network.getPublicIPOutput({
    name: examplePublicIp.name,
    resourceGroupName: exampleVirtualMachine.resourceGroupName,
});
export const publicIpAddress = example.apply(example => example.ipAddress);

    import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("example",
    name="test-resources",
    location="West Europe")
example_virtual_network = azure.network.VirtualNetwork("example",
    name="test-network",
    address_spaces=["10.0.0.0/16"],
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name)
example_subnet = azure.network.Subnet("example",
    name="acctsub",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.0.2.0/24"])
example_public_ip = azure.network.PublicIp("example",
    name="test-pip",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    allocation_method="Dynamic",
    idle_timeout_in_minutes=30,
    tags={
        "environment": "test",
    })
example_network_interface = azure.network.NetworkInterface("example",
    name="test-nic",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    ip_configurations=[azure.network.NetworkInterfaceIpConfigurationArgs(
        name="testconfiguration1",
        subnet_id=example_subnet.id,
        private_ip_address_allocation="Static",
        private_ip_address="10.0.2.5",
        public_ip_address_id=example_public_ip.id,
    )])
example_virtual_machine = azure.compute.VirtualMachine("example",
    name="test-vm",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    network_interface_ids=[example_network_interface.id])
example = azure.network.get_public_ip_output(name=example_public_ip.name,
    resource_group_name=example_virtual_machine.resource_group_name)
pulumi.export("publicIpAddress", example.ip_address)

    package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/compute"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("test-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "example", &network.VirtualNetworkArgs{
			Name: pulumi.String("test-network"),
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.0.0.0/16"),
			},
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "example", &network.SubnetArgs{
			Name:               pulumi.String("acctsub"),
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.0.2.0/24"),
			},
		})
		if err != nil {
			return err
		}
		examplePublicIp, err := network.NewPublicIp(ctx, "example", &network.PublicIpArgs{
			Name:                 pulumi.String("test-pip"),
			Location:             exampleResourceGroup.Location,
			ResourceGroupName:    exampleResourceGroup.Name,
			AllocationMethod:     pulumi.String("Dynamic"),
			IdleTimeoutInMinutes: pulumi.Int(30),
			Tags: pulumi.StringMap{
				"environment": pulumi.String("test"),
			},
		})
		if err != nil {
			return err
		}
		exampleNetworkInterface, err := network.NewNetworkInterface(ctx, "example", &network.NetworkInterfaceArgs{
			Name:              pulumi.String("test-nic"),
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			IpConfigurations: network.NetworkInterfaceIpConfigurationArray{
				&network.NetworkInterfaceIpConfigurationArgs{
					Name:                       pulumi.String("testconfiguration1"),
					SubnetId:                   exampleSubnet.ID(),
					PrivateIpAddressAllocation: pulumi.String("Static"),
					PrivateIpAddress:           pulumi.String("10.0.2.5"),
					PublicIpAddressId:          examplePublicIp.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleVirtualMachine, err := compute.NewVirtualMachine(ctx, "example", &compute.VirtualMachineArgs{
			Name:              pulumi.String("test-vm"),
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			NetworkInterfaceIds: pulumi.StringArray{
				exampleNetworkInterface.ID(),
			},
		})
		if err != nil {
			return err
		}
		example := network.GetPublicIPOutput(ctx, network.GetPublicIPOutputArgs{
			Name:              examplePublicIp.Name,
			ResourceGroupName: exampleVirtualMachine.ResourceGroupName,
		}, nil)
		ctx.Export("publicIpAddress", example.ApplyT(func(example network.GetPublicIPResult) (*string, error) {
			return &example.IpAddress, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "test-resources",
        Location = "West Europe",
    });

    var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("example", new()
    {
        Name = "test-network",
        AddressSpaces = new[]
        {
            "10.0.0.0/16",
        },
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
    });

    var exampleSubnet = new Azure.Network.Subnet("example", new()
    {
        Name = "acctsub",
        ResourceGroupName = exampleResourceGroup.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.0.2.0/24",
        },
    });

    var examplePublicIp = new Azure.Network.PublicIp("example", new()
    {
        Name = "test-pip",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        AllocationMethod = "Dynamic",
        IdleTimeoutInMinutes = 30,
        Tags = 
        {
            { "environment", "test" },
        },
    });

    var exampleNetworkInterface = new Azure.Network.NetworkInterface("example", new()
    {
        Name = "test-nic",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        IpConfigurations = new[]
        {
            new Azure.Network.Inputs.NetworkInterfaceIpConfigurationArgs
            {
                Name = "testconfiguration1",
                SubnetId = exampleSubnet.Id,
                PrivateIpAddressAllocation = "Static",
                PrivateIpAddress = "10.0.2.5",
                PublicIpAddressId = examplePublicIp.Id,
            },
        },
    });

    var exampleVirtualMachine = new Azure.Compute.VirtualMachine("example", new()
    {
        Name = "test-vm",
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        NetworkInterfaceIds = new[]
        {
            exampleNetworkInterface.Id,
        },
    });

    var example = Azure.Network.GetPublicIP.Invoke(new()
    {
        Name = examplePublicIp.Name,
        ResourceGroupName = exampleVirtualMachine.ResourceGroupName,
    });

    return new Dictionary<string, object?>
    {
        ["publicIpAddress"] = example.Apply(getPublicIPResult => getPublicIPResult.IpAddress),
    };
});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.network.VirtualNetwork;
import com.pulumi.azure.network.VirtualNetworkArgs;
import com.pulumi.azure.network.Subnet;
import com.pulumi.azure.network.SubnetArgs;
import com.pulumi.azure.network.PublicIp;
import com.pulumi.azure.network.PublicIpArgs;
import com.pulumi.azure.network.NetworkInterface;
import com.pulumi.azure.network.NetworkInterfaceArgs;
import com.pulumi.azure.network.inputs.NetworkInterfaceIpConfigurationArgs;
import com.pulumi.azure.compute.VirtualMachine;
import com.pulumi.azure.compute.VirtualMachineArgs;
import com.pulumi.azure.network.NetworkFunctions;
import com.pulumi.azure.network.inputs.GetPublicIPArgs;
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 exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()
            .name("test-resources")
            .location("West Europe")
            .build());

        var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()
            .name("test-network")
            .addressSpaces("10.0.0.0/16")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .build());

        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()
            .name("acctsub")
            .resourceGroupName(exampleResourceGroup.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.0.2.0/24")
            .build());

        var examplePublicIp = new PublicIp("examplePublicIp", PublicIpArgs.builder()
            .name("test-pip")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .allocationMethod("Dynamic")
            .idleTimeoutInMinutes(30)
            .tags(Map.of("environment", "test"))
            .build());

        var exampleNetworkInterface = new NetworkInterface("exampleNetworkInterface", NetworkInterfaceArgs.builder()
            .name("test-nic")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .ipConfigurations(NetworkInterfaceIpConfigurationArgs.builder()
                .name("testconfiguration1")
                .subnetId(exampleSubnet.id())
                .privateIpAddressAllocation("Static")
                .privateIpAddress("10.0.2.5")
                .publicIpAddressId(examplePublicIp.id())
                .build())
            .build());

        var exampleVirtualMachine = new VirtualMachine("exampleVirtualMachine", VirtualMachineArgs.builder()
            .name("test-vm")
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .networkInterfaceIds(exampleNetworkInterface.id())
            .build());

        final var example = NetworkFunctions.getPublicIP(GetPublicIPArgs.builder()
            .name(examplePublicIp.name())
            .resourceGroupName(exampleVirtualMachine.resourceGroupName())
            .build());

        ctx.export("publicIpAddress", example.applyValue(getPublicIPResult -> getPublicIPResult).applyValue(example -> example.applyValue(getPublicIPResult -> getPublicIPResult.ipAddress())));
    }
}

    resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    name: example
    properties:
      name: test-resources
      location: West Europe
  exampleVirtualNetwork:
    type: azure:network:VirtualNetwork
    name: example
    properties:
      name: test-network
      addressSpaces:
        - 10.0.0.0/16
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
  exampleSubnet:
    type: azure:network:Subnet
    name: example
    properties:
      name: acctsub
      resourceGroupName: ${exampleResourceGroup.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.0.2.0/24
  examplePublicIp:
    type: azure:network:PublicIp
    name: example
    properties:
      name: test-pip
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      allocationMethod: Dynamic
      idleTimeoutInMinutes: 30
      tags:
        environment: test
  exampleNetworkInterface:
    type: azure:network:NetworkInterface
    name: example
    properties:
      name: test-nic
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      ipConfigurations:
        - name: testconfiguration1
          subnetId: ${exampleSubnet.id}
          privateIpAddressAllocation: Static
          privateIpAddress: 10.0.2.5
          publicIpAddressId: ${examplePublicIp.id}
  exampleVirtualMachine:
    type: azure:compute:VirtualMachine
    name: example
    properties:
      name: test-vm
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      networkInterfaceIds: # ...
        - ${exampleNetworkInterface.id}
variables:
  example:
    fn::invoke:
      Function: azure:network:getPublicIP
      Arguments:
        name: ${examplePublicIp.name}
        resourceGroupName: ${exampleVirtualMachine.resourceGroupName}
outputs:
  publicIpAddress: ${example.ipAddress}

    Using getPublicIP

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getPublicIP(args: GetPublicIPArgs, opts?: InvokeOptions): Promise<GetPublicIPResult>
function getPublicIPOutput(args: GetPublicIPOutputArgs, opts?: InvokeOptions): Output<GetPublicIPResult>
    def get_public_ip(name: Optional[str] = None,
                  resource_group_name: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetPublicIPResult
def get_public_ip_output(name: Optional[pulumi.Input[str]] = None,
                  resource_group_name: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetPublicIPResult]
    func GetPublicIP(ctx *Context, args *GetPublicIPArgs, opts ...InvokeOption) (*GetPublicIPResult, error)
func GetPublicIPOutput(ctx *Context, args *GetPublicIPOutputArgs, opts ...InvokeOption) GetPublicIPResultOutput

    > Note: This function is named GetPublicIP in the Go SDK.

    public static class GetPublicIP 
{
    public static Task<GetPublicIPResult> InvokeAsync(GetPublicIPArgs args, InvokeOptions? opts = null)
    public static Output<GetPublicIPResult> Invoke(GetPublicIPInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetPublicIPResult> getPublicIP(GetPublicIPArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

    fn::invoke:
  function: azure:network/getPublicIP:getPublicIP
  arguments:
    # arguments dictionary

    The following arguments are supported:

    Name string
    Specifies the name of the public IP address.
    ResourceGroupName string
    Specifies the name of the resource group.
    Name string
    Specifies the name of the public IP address.
    ResourceGroupName string
    Specifies the name of the resource group.
    name String
    Specifies the name of the public IP address.
    resourceGroupName String
    Specifies the name of the resource group.
    name string
    Specifies the name of the public IP address.
    resourceGroupName string
    Specifies the name of the resource group.
    name str
    Specifies the name of the public IP address.
    resource_group_name str
    Specifies the name of the resource group.
    name String
    Specifies the name of the public IP address.
    resourceGroupName String
    Specifies the name of the resource group.

    getPublicIP Result

    The following output properties are available:

    AllocationMethod string
    The allocation method for this IP address. Possible values are Static or Dynamic.
    DdosProtectionMode string
    The DDoS protection mode of the public IP.
    DdosProtectionPlanId string
    The ID of DDoS protection plan associated with the public IP.
    DomainNameLabel string
    The label for the Domain Name.
    Fqdn string
    Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
    Id string
    The provider-assigned unique ID for this managed resource.
    IdleTimeoutInMinutes int
    Specifies the timeout for the TCP idle connection.
    IpAddress string
    The IP address value that was allocated.
    IpTags Dictionary<string, string>
    A mapping of tags to assigned to the resource.
    IpVersion string
    The IP version being used, for example IPv4 or IPv6.
    Location string
    The region that this public ip exists.
    Name string
    ResourceGroupName string
    ReverseFqdn string
    The fully qualified domain name that resolves to this public IP address.
    Sku string
    The SKU of the Public IP.
    Tags Dictionary<string, string>
    A mapping of tags to assigned to the resource.
    Zones List<string>
    A list of Availability Zones in which this Public IP is located.
    AllocationMethod string
    The allocation method for this IP address. Possible values are Static or Dynamic.
    DdosProtectionMode string
    The DDoS protection mode of the public IP.
    DdosProtectionPlanId string
    The ID of DDoS protection plan associated with the public IP.
    DomainNameLabel string
    The label for the Domain Name.
    Fqdn string
    Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
    Id string
    The provider-assigned unique ID for this managed resource.
    IdleTimeoutInMinutes int
    Specifies the timeout for the TCP idle connection.
    IpAddress string
    The IP address value that was allocated.
    IpTags map[string]string
    A mapping of tags to assigned to the resource.
    IpVersion string
    The IP version being used, for example IPv4 or IPv6.
    Location string
    The region that this public ip exists.
    Name string
    ResourceGroupName string
    ReverseFqdn string
    The fully qualified domain name that resolves to this public IP address.
    Sku string
    The SKU of the Public IP.
    Tags map[string]string
    A mapping of tags to assigned to the resource.
    Zones []string
    A list of Availability Zones in which this Public IP is located.
    allocationMethod String
    The allocation method for this IP address. Possible values are Static or Dynamic.
    ddosProtectionMode String
    The DDoS protection mode of the public IP.
    ddosProtectionPlanId String
    The ID of DDoS protection plan associated with the public IP.
    domainNameLabel String
    The label for the Domain Name.
    fqdn String
    Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
    id String
    The provider-assigned unique ID for this managed resource.
    idleTimeoutInMinutes Integer
    Specifies the timeout for the TCP idle connection.
    ipAddress String
    The IP address value that was allocated.
    ipTags Map<String,String>
    A mapping of tags to assigned to the resource.
    ipVersion String
    The IP version being used, for example IPv4 or IPv6.
    location String
    The region that this public ip exists.
    name String
    resourceGroupName String
    reverseFqdn String
    The fully qualified domain name that resolves to this public IP address.
    sku String
    The SKU of the Public IP.
    tags Map<String,String>
    A mapping of tags to assigned to the resource.
    zones List<String>
    A list of Availability Zones in which this Public IP is located.
    allocationMethod string
    The allocation method for this IP address. Possible values are Static or Dynamic.
    ddosProtectionMode string
    The DDoS protection mode of the public IP.
    ddosProtectionPlanId string
    The ID of DDoS protection plan associated with the public IP.
    domainNameLabel string
    The label for the Domain Name.
    fqdn string
    Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
    id string
    The provider-assigned unique ID for this managed resource.
    idleTimeoutInMinutes number
    Specifies the timeout for the TCP idle connection.
    ipAddress string
    The IP address value that was allocated.
    ipTags {[key: string]: string}
    A mapping of tags to assigned to the resource.
    ipVersion string
    The IP version being used, for example IPv4 or IPv6.
    location string
    The region that this public ip exists.
    name string
    resourceGroupName string
    reverseFqdn string
    The fully qualified domain name that resolves to this public IP address.
    sku string
    The SKU of the Public IP.
    tags {[key: string]: string}
    A mapping of tags to assigned to the resource.
    zones string[]
    A list of Availability Zones in which this Public IP is located.
    allocation_method str
    The allocation method for this IP address. Possible values are Static or Dynamic.
    ddos_protection_mode str
    The DDoS protection mode of the public IP.
    ddos_protection_plan_id str
    The ID of DDoS protection plan associated with the public IP.
    domain_name_label str
    The label for the Domain Name.
    fqdn str
    Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
    id str
    The provider-assigned unique ID for this managed resource.
    idle_timeout_in_minutes int
    Specifies the timeout for the TCP idle connection.
    ip_address str
    The IP address value that was allocated.
    ip_tags Mapping[str, str]
    A mapping of tags to assigned to the resource.
    ip_version str
    The IP version being used, for example IPv4 or IPv6.
    location str
    The region that this public ip exists.
    name str
    resource_group_name str
    reverse_fqdn str
    The fully qualified domain name that resolves to this public IP address.
    sku str
    The SKU of the Public IP.
    tags Mapping[str, str]
    A mapping of tags to assigned to the resource.
    zones Sequence[str]
    A list of Availability Zones in which this Public IP is located.
    allocationMethod String
    The allocation method for this IP address. Possible values are Static or Dynamic.
    ddosProtectionMode String
    The DDoS protection mode of the public IP.
    ddosProtectionPlanId String
    The ID of DDoS protection plan associated with the public IP.
    domainNameLabel String
    The label for the Domain Name.
    fqdn String
    Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
    id String
    The provider-assigned unique ID for this managed resource.
    idleTimeoutInMinutes Number
    Specifies the timeout for the TCP idle connection.
    ipAddress String
    The IP address value that was allocated.
    ipTags Map<String>
    A mapping of tags to assigned to the resource.
    ipVersion String
    The IP version being used, for example IPv4 or IPv6.
    location String
    The region that this public ip exists.
    name String
    resourceGroupName String
    reverseFqdn String
    The fully qualified domain name that resolves to this public IP address.
    sku String
    The SKU of the Public IP.
    tags Map<String>
    A mapping of tags to assigned to the resource.
    zones List<String>
    A list of Availability Zones in which this Public IP is located.

    Package Details

    Repository
    Azure Classic pulumi/pulumi-azure
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the azurerm Terraform Provider.
    azure logo

    We recommend using Azure Native.

    Azure Classic v5.81.0 published on Monday, Jun 24, 2024 by Pulumi
    pulumi/pulumi-azure