Eip class

Provides an Elastic IP resource.

> Note: EIP may require IGW to exist prior to association. Use dependsOn to set an explicit dependency on the IGW.

> Note: Do not use networkInterface to associate the EIP to aws.lb.LoadBalancer or aws.ec2.NatGateway resources. Instead use the allocationId available in those resources to allow AWS to manage the association, otherwise you will see AuthFailure errors.

Example Usage

Single EIP associated with an instance

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

const lb = new aws.ec2.Eip("lb", {
    instance: web.id,
    domain: "vpc",
});
import pulumi
import pulumi_aws as aws

lb = aws.ec2.Eip("lb",
    instance=web["id"],
    domain="vpc")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var lb = new Aws.Ec2.Eip("lb", new()
    {
        Instance = web.Id,
        Domain = "vpc",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewEip(ctx, "lb", &ec2.EipArgs{
			Instance: pulumi.Any(web.Id),
			Domain:   pulumi.String("vpc"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_eip" "lb" {
  instance = web.id
  domain   = "vpc"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Eip;
import com.pulumi.aws.ec2.EipArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 lb = new Eip("lb", EipArgs.builder()
            .instance(web.id())
            .domain("vpc")
            .build());

    }
}
resources:
  lb:
    type: aws:ec2:Eip
    properties:
      instance: ${web.id}
      domain: vpc

Multiple EIPs associated with a single network interface

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

const multi_ip = new aws.ec2.NetworkInterface("multi-ip", {
    subnetId: main.id,
    privateIps: [
        "10.0.0.10",
        "10.0.0.11",
    ],
});
const one = new aws.ec2.Eip("one", {
    domain: "vpc",
    networkInterface: multi_ip.id,
    associateWithPrivateIp: "10.0.0.10",
});
const two = new aws.ec2.Eip("two", {
    domain: "vpc",
    networkInterface: multi_ip.id,
    associateWithPrivateIp: "10.0.0.11",
});
import pulumi
import pulumi_aws as aws

multi_ip = aws.ec2.NetworkInterface("multi-ip",
    subnet_id=main["id"],
    private_ips=[
        "10.0.0.10",
        "10.0.0.11",
    ])
one = aws.ec2.Eip("one",
    domain="vpc",
    network_interface=multi_ip.id,
    associate_with_private_ip="10.0.0.10")
two = aws.ec2.Eip("two",
    domain="vpc",
    network_interface=multi_ip.id,
    associate_with_private_ip="10.0.0.11")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var multi_ip = new Aws.Ec2.NetworkInterface("multi-ip", new()
    {
        SubnetId = main.Id,
        PrivateIps = new[]
        {
            "10.0.0.10",
            "10.0.0.11",
        },
    });

    var one = new Aws.Ec2.Eip("one", new()
    {
        Domain = "vpc",
        NetworkInterface = multi_ip.Id,
        AssociateWithPrivateIp = "10.0.0.10",
    });

    var two = new Aws.Ec2.Eip("two", new()
    {
        Domain = "vpc",
        NetworkInterface = multi_ip.Id,
        AssociateWithPrivateIp = "10.0.0.11",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		multi_ip, err := ec2.NewNetworkInterface(ctx, "multi-ip", &ec2.NetworkInterfaceArgs{
			SubnetId: pulumi.Any(main.Id),
			PrivateIps: pulumi.StringArray{
				pulumi.String("10.0.0.10"),
				pulumi.String("10.0.0.11"),
			},
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewEip(ctx, "one", &ec2.EipArgs{
			Domain:                 pulumi.String("vpc"),
			NetworkInterface:       multi_ip.ID().ToIDOutput().ToStringOutput(),
			AssociateWithPrivateIp: pulumi.String("10.0.0.10"),
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewEip(ctx, "two", &ec2.EipArgs{
			Domain:                 pulumi.String("vpc"),
			NetworkInterface:       multi_ip.ID().ToIDOutput().ToStringOutput(),
			AssociateWithPrivateIp: pulumi.String("10.0.0.11"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_networkinterface" "multi-ip" {
  subnet_id   = main.id
  private_ips = ["10.0.0.10", "10.0.0.11"]
}
resource "aws_ec2_eip" "one" {
  domain                    = "vpc"
  network_interface         = aws_ec2_networkinterface.multi-ip.id
  associate_with_private_ip = "10.0.0.10"
}
resource "aws_ec2_eip" "two" {
  domain                    = "vpc"
  network_interface         = aws_ec2_networkinterface.multi-ip.id
  associate_with_private_ip = "10.0.0.11"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.NetworkInterface;
import com.pulumi.aws.ec2.NetworkInterfaceArgs;
import com.pulumi.aws.ec2.Eip;
import com.pulumi.aws.ec2.EipArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 multi_ip = new NetworkInterface("multi-ip", NetworkInterfaceArgs.builder()
            .subnetId(main.id())
            .privateIps(
                "10.0.0.10",
                "10.0.0.11")
            .build());

        var one = new Eip("one", EipArgs.builder()
            .domain("vpc")
            .networkInterface(multi_ip.id())
            .associateWithPrivateIp("10.0.0.10")
            .build());

        var two = new Eip("two", EipArgs.builder()
            .domain("vpc")
            .networkInterface(multi_ip.id())
            .associateWithPrivateIp("10.0.0.11")
            .build());

    }
}
resources:
  multi-ip:
    type: aws:ec2:NetworkInterface
    properties:
      subnetId: ${main.id}
      privateIps:
        - 10.0.0.10
        - 10.0.0.11
  one:
    type: aws:ec2:Eip
    properties:
      domain: vpc
      networkInterface: ${["multi-ip"].id}
      associateWithPrivateIp: 10.0.0.10
  two:
    type: aws:ec2:Eip
    properties:
      domain: vpc
      networkInterface: ${["multi-ip"].id}
      associateWithPrivateIp: 10.0.0.11

Attaching an EIP to an Instance with a pre-assigned private ip (VPC Only)

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

const _default = new aws.ec2.Vpc("default", {
    cidrBlock: "10.0.0.0/16",
    enableDnsHostnames: true,
});
const gw = new aws.ec2.InternetGateway("gw", {vpcId: _default.id});
const myTestSubnet = new aws.ec2.Subnet("my_test_subnet", {
    vpcId: _default.id,
    cidrBlock: "10.0.0.0/24",
    mapPublicIpOnLaunch: true,
}, {
    dependsOn: [gw],
});
const foo = new aws.ec2.Instance("foo", {
    ami: "ami-5189a661",
    instanceType: aws.ec2.InstanceType.T2_Micro,
    privateIp: "10.0.0.12",
    subnetId: myTestSubnet.id,
});
const bar = new aws.ec2.Eip("bar", {
    domain: "vpc",
    instance: foo.id,
    associateWithPrivateIp: "10.0.0.12",
}, {
    dependsOn: [gw],
});
import pulumi
import pulumi_aws as aws

default = aws.ec2.Vpc("default",
    cidr_block="10.0.0.0/16",
    enable_dns_hostnames=True)
gw = aws.ec2.InternetGateway("gw", vpc_id=default.id)
my_test_subnet = aws.ec2.Subnet("my_test_subnet",
    vpc_id=default.id,
    cidr_block="10.0.0.0/24",
    map_public_ip_on_launch=True,
    opts = pulumi.ResourceOptions(depends_on=[gw]))
foo = aws.ec2.Instance("foo",
    ami="ami-5189a661",
    instance_type=aws.ec2.InstanceType.T2_MICRO,
    private_ip="10.0.0.12",
    subnet_id=my_test_subnet.id)
bar = aws.ec2.Eip("bar",
    domain="vpc",
    instance=foo.id,
    associate_with_private_ip="10.0.0.12",
    opts = pulumi.ResourceOptions(depends_on=[gw]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var @default = new Aws.Ec2.Vpc("default", new()
    {
        CidrBlock = "10.0.0.0/16",
        EnableDnsHostnames = true,
    });

    var gw = new Aws.Ec2.InternetGateway("gw", new()
    {
        VpcId = @default.Id,
    });

    var myTestSubnet = new Aws.Ec2.Subnet("my_test_subnet", new()
    {
        VpcId = @default.Id,
        CidrBlock = "10.0.0.0/24",
        MapPublicIpOnLaunch = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            gw,
        },
    });

    var foo = new Aws.Ec2.Instance("foo", new()
    {
        Ami = "ami-5189a661",
        InstanceType = Aws.Ec2.InstanceType.T2_Micro,
        PrivateIp = "10.0.0.12",
        SubnetId = myTestSubnet.Id,
    });

    var bar = new Aws.Ec2.Eip("bar", new()
    {
        Domain = "vpc",
        Instance = foo.Id,
        AssociateWithPrivateIp = "10.0.0.12",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            gw,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := ec2.NewVpc(ctx, "default", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.0.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		gw, err := ec2.NewInternetGateway(ctx, "gw", &ec2.InternetGatewayArgs{
			VpcId: _default.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		myTestSubnet, err := ec2.NewSubnet(ctx, "my_test_subnet", &ec2.SubnetArgs{
			VpcId:               _default.ID().ToIDOutput().ToStringOutput(),
			CidrBlock:           pulumi.String("10.0.0.0/24"),
			MapPublicIpOnLaunch: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			gw,
		}))
		if err != nil {
			return err
		}
		foo, err := ec2.NewInstance(ctx, "foo", &ec2.InstanceArgs{
			Ami:          pulumi.String("ami-5189a661"),
			InstanceType: pulumi.String(ec2.InstanceType_T2_Micro),
			PrivateIp:    pulumi.String("10.0.0.12"),
			SubnetId:     myTestSubnet.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewEip(ctx, "bar", &ec2.EipArgs{
			Domain:                 pulumi.String("vpc"),
			Instance:               foo.ID().ToIDOutput().ToStringOutput(),
			AssociateWithPrivateIp: pulumi.String("10.0.0.12"),
		}, pulumi.DependsOn([]pulumi.Resource{
			gw,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_vpc" "default" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
}
resource "aws_ec2_internetgateway" "gw" {
  vpc_id = aws_ec2_vpc.default.id
}
resource "aws_ec2_subnet" "my_test_subnet" {
  depends_on              = [aws_ec2_internetgateway.gw]
  vpc_id                  = aws_ec2_vpc.default.id
  cidr_block              = "10.0.0.0/24"
  map_public_ip_on_launch = true
}
resource "aws_ec2_instance" "foo" {
  ami           = "ami-5189a661"
  instance_type = "t2.micro"
  private_ip    = "10.0.0.12"
  subnet_id     = aws_ec2_subnet.my_test_subnet.id
}
resource "aws_ec2_eip" "bar" {
  depends_on                = [aws_ec2_internetgateway.gw]
  domain                    = "vpc"
  instance                  = aws_ec2_instance.foo.id
  associate_with_private_ip = "10.0.0.12"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.ec2.InternetGateway;
import com.pulumi.aws.ec2.InternetGatewayArgs;
import com.pulumi.aws.ec2.Subnet;
import com.pulumi.aws.ec2.SubnetArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
import com.pulumi.aws.ec2.Eip;
import com.pulumi.aws.ec2.EipArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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 default_ = new Vpc("default", VpcArgs.builder()
            .cidrBlock("10.0.0.0/16")
            .enableDnsHostnames(true)
            .build());

        var gw = new InternetGateway("gw", InternetGatewayArgs.builder()
            .vpcId(default_.id())
            .build());

        var myTestSubnet = new Subnet("myTestSubnet", SubnetArgs.builder()
            .vpcId(default_.id())
            .cidrBlock("10.0.0.0/24")
            .mapPublicIpOnLaunch(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(gw)
                .build());

        var foo = new Instance("foo", InstanceArgs.builder()
            .ami("ami-5189a661")
            .instanceType("t2.micro")
            .privateIp("10.0.0.12")
            .subnetId(myTestSubnet.id())
            .build());

        var bar = new Eip("bar", EipArgs.builder()
            .domain("vpc")
            .instance(foo.id())
            .associateWithPrivateIp("10.0.0.12")
            .build(), CustomResourceOptions.builder()
                .dependsOn(gw)
                .build());

    }
}
resources:
  default:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 10.0.0.0/16
      enableDnsHostnames: true
  gw:
    type: aws:ec2:InternetGateway
    properties:
      vpcId: ${default.id}
  myTestSubnet:
    type: aws:ec2:Subnet
    name: my_test_subnet
    properties:
      vpcId: ${default.id}
      cidrBlock: 10.0.0.0/24
      mapPublicIpOnLaunch: true
    options:
      dependsOn:
        - ${gw}
  foo:
    type: aws:ec2:Instance
    properties:
      ami: ami-5189a661
      instanceType: t2.micro
      privateIp: 10.0.0.12
      subnetId: ${myTestSubnet.id}
  bar:
    type: aws:ec2:Eip
    properties:
      domain: vpc
      instance: ${foo.id}
      associateWithPrivateIp: 10.0.0.12
    options:
      dependsOn:
        - ${gw}

Allocating EIP from the BYOIP pool

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

const byoip_ip = new aws.ec2.Eip("byoip-ip", {
    domain: "vpc",
    publicIpv4Pool: "ipv4pool-ec2-012345",
});
import pulumi
import pulumi_aws as aws

byoip_ip = aws.ec2.Eip("byoip-ip",
    domain="vpc",
    public_ipv4_pool="ipv4pool-ec2-012345")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var byoip_ip = new Aws.Ec2.Eip("byoip-ip", new()
    {
        Domain = "vpc",
        PublicIpv4Pool = "ipv4pool-ec2-012345",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewEip(ctx, "byoip-ip", &ec2.EipArgs{
			Domain:         pulumi.String("vpc"),
			PublicIpv4Pool: pulumi.String("ipv4pool-ec2-012345"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_eip" "byoip-ip" {
  domain           = "vpc"
  public_ipv4_pool = "ipv4pool-ec2-012345"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Eip;
import com.pulumi.aws.ec2.EipArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 byoip_ip = new Eip("byoip-ip", EipArgs.builder()
            .domain("vpc")
            .publicIpv4Pool("ipv4pool-ec2-012345")
            .build());

    }
}
resources:
  byoip-ip:
    type: aws:ec2:Eip
    properties:
      domain: vpc
      publicIpv4Pool: ipv4pool-ec2-012345

Allocating EIP from the IPAM Pool

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

const ipam_ip = new aws.ec2.Eip("ipam-ip", {
    domain: "vpc",
    ipamPoolId: "ipam-pool-07ccc86aa41bef7ce",
});
import pulumi
import pulumi_aws as aws

ipam_ip = aws.ec2.Eip("ipam-ip",
    domain="vpc",
    ipam_pool_id="ipam-pool-07ccc86aa41bef7ce")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var ipam_ip = new Aws.Ec2.Eip("ipam-ip", new()
    {
        Domain = "vpc",
        IpamPoolId = "ipam-pool-07ccc86aa41bef7ce",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewEip(ctx, "ipam-ip", &ec2.EipArgs{
			Domain:     pulumi.String("vpc"),
			IpamPoolId: pulumi.String("ipam-pool-07ccc86aa41bef7ce"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_eip" "ipam-ip" {
  domain       = "vpc"
  ipam_pool_id = "ipam-pool-07ccc86aa41bef7ce"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Eip;
import com.pulumi.aws.ec2.EipArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 ipam_ip = new Eip("ipam-ip", EipArgs.builder()
            .domain("vpc")
            .ipamPoolId("ipam-pool-07ccc86aa41bef7ce")
            .build());

    }
}
resources:
  ipam-ip:
    type: aws:ec2:Eip
    properties:
      domain: vpc
      ipamPoolId: ipam-pool-07ccc86aa41bef7ce

Import

Identity Schema

Required

  • id (String) Allocation ID that identifies the Elastic IP.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import EIPs in a VPC using their Allocation ID. For example:

$ pulumi import aws:ec2/eip:Eip example eipalloc-00a10e96

Constructors

Eip(String name, {EipArgs? args, CustomResourceOptions? options})
Creates a new Eip. name The Pulumi resource name. args Arguments used to configure this Eip. The set of arguments for Eip. options Resource options controlling this resource's behavior.
Eip.reference(String urn)
Creates a typed reference to an existing Eip resource.

Properties

address ↔ Output<String?>
IP address from an EC2 BYOIP pool. This option is only available for VPC EIPs.
latefinal
allocationId ↔ Output<String>
ID that AWS assigns to represent the allocation of the Elastic IP address for use with instances in a VPC.
latefinal
arn ↔ Output<String>
latefinal
associateWithPrivateIp ↔ Output<String?>
User-specified primary or secondary private IP address to associate with the Elastic IP address. If no private IP address is specified, the Elastic IP address is associated with the primary private IP address.
latefinal
associationId ↔ Output<String>
ID representing the association of the address with an instance in a VPC.
latefinal
carrierIp ↔ Output<String>
Carrier IP address.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
customerOwnedIp ↔ Output<String>
Customer owned IP.
latefinal
customerOwnedIpv4Pool ↔ Output<String?>
ID of a customer-owned address pool. For more on customer owned IP addressed check out Customer-owned IP addresses guide.
latefinal
domain ↔ Output<String>
Indicates if this EIP is for use in VPC (vpc).
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
instance ↔ Output<String>
EC2 instance ID.
latefinal
ipamPoolId ↔ Output<String>
The ID of an IPAM pool which has an Amazon-provided or BYOIP public IPv4 CIDR provisioned to it.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
networkBorderGroup ↔ Output<String>
Location from which the IP address is advertised. Use this parameter to limit the address to this location.
latefinal
networkInterface ↔ Output<String>
Network interface ID to associate with.
latefinal
privateDns ↔ Output<String>
The Private DNS associated with the Elastic IP address (if in VPC).
latefinal
privateIp ↔ Output<String>
Contains the private IP address (if in VPC).
latefinal
ptrRecord ↔ Output<String>
The DNS pointer (PTR) record for the IP address.
latefinal
publicDns ↔ Output<String>
Public DNS associated with the Elastic IP address.
latefinal
publicIp ↔ Output<String>
Contains the public IP address.
latefinal
publicIpv4Pool ↔ Output<String>
EC2 IPv4 address pool identifier or amazon. This option is only available for VPC EIPs.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. Tags can only be applied to EIPs in a VPC. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {EipState? state, CustomResourceOptions? options}) → Eip
Gets an existing Eip resource's state with the given name and id.