gcp.compute.RouterNatAddress

A resource used to set the list of IP addresses to be used in a NAT service and manage the draining of destroyed IPs.

Note: This resource is to be used alongside a gcp.compute.RouterNat resource, the router nat resource must have no defined nat_ips or drain_nat_ips parameters, instead using the initial_nat_ips parameter to set at least one IP for the creation of the resource.

To get more information about RouterNatAddress, see:

• API documentation
• How-to Guides
  • Google Cloud Router

Example Usage

Create RouterNatAddress Resource

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

Constructor syntax

new RouterNatAddress(name: string, args: RouterNatAddressArgs, opts?: CustomResourceOptions);

@overload
def RouterNatAddress(resource_name: str,
                     args: RouterNatAddressArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def RouterNatAddress(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     nat_ips: Optional[Sequence[str]] = None,
                     router: Optional[str] = None,
                     router_nat: Optional[str] = None,
                     drain_nat_ips: Optional[Sequence[str]] = None,
                     project: Optional[str] = None,
                     region: Optional[str] = None)

func NewRouterNatAddress(ctx *Context, name string, args RouterNatAddressArgs, opts ...ResourceOption) (*RouterNatAddress, error)

public RouterNatAddress(string name, RouterNatAddressArgs args, CustomResourceOptions? opts = null)

public RouterNatAddress(String name, RouterNatAddressArgs args)
public RouterNatAddress(String name, RouterNatAddressArgs args, CustomResourceOptions options)

type: gcp:compute:RouterNatAddress
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

Constructor example

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

var routerNatAddressResource = new Gcp.Compute.RouterNatAddress("routerNatAddressResource", new()
{
    NatIps = new[]
    {
        "string",
    },
    Router = "string",
    RouterNat = "string",
    DrainNatIps = new[]
    {
        "string",
    },
    Project = "string",
    Region = "string",
});

example, err := compute.NewRouterNatAddress(ctx, "routerNatAddressResource", &compute.RouterNatAddressArgs{
	NatIps: pulumi.StringArray{
		pulumi.String("string"),
	},
	Router:    pulumi.String("string"),
	RouterNat: pulumi.String("string"),
	DrainNatIps: pulumi.StringArray{
		pulumi.String("string"),
	},
	Project: pulumi.String("string"),
	Region:  pulumi.String("string"),
})

var routerNatAddressResource = new RouterNatAddress("routerNatAddressResource", RouterNatAddressArgs.builder()
    .natIps("string")
    .router("string")
    .routerNat("string")
    .drainNatIps("string")
    .project("string")
    .region("string")
    .build());

router_nat_address_resource = gcp.compute.RouterNatAddress("routerNatAddressResource",
    nat_ips=["string"],
    router="string",
    router_nat="string",
    drain_nat_ips=["string"],
    project="string",
    region="string")

const routerNatAddressResource = new gcp.compute.RouterNatAddress("routerNatAddressResource", {
    natIps: ["string"],
    router: "string",
    routerNat: "string",
    drainNatIps: ["string"],
    project: "string",
    region: "string",
});

type: gcp:compute:RouterNatAddress
properties:
    drainNatIps:
        - string
    natIps:
        - string
    project: string
    region: string
    router: string
    routerNat: string

RouterNatAddress 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 RouterNatAddress resource accepts the following input properties:

Outputs

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

Look up Existing RouterNatAddress Resource

Get an existing RouterNatAddress 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?: RouterNatAddressState, opts?: CustomResourceOptions): RouterNatAddress

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        drain_nat_ips: Optional[Sequence[str]] = None,
        nat_ips: Optional[Sequence[str]] = None,
        project: Optional[str] = None,
        region: Optional[str] = None,
        router: Optional[str] = None,
        router_nat: Optional[str] = None) -> RouterNatAddress

func GetRouterNatAddress(ctx *Context, name string, id IDInput, state *RouterNatAddressState, opts ...ResourceOption) (*RouterNatAddress, error)

public static RouterNatAddress Get(string name, Input<string> id, RouterNatAddressState? state, CustomResourceOptions? opts = null)

public static RouterNatAddress get(String name, Output<String> id, RouterNatAddressState state, CustomResourceOptions options)

resources:  _:    type: gcp:compute:RouterNatAddress    get:      id: ${id}

Import

RouterNatAddress can be imported using any of these accepted formats:

• projects/{{project}}/regions/{{region}}/routers/{{router}}/{{router_nat}}

• {{project}}/{{region}}/{{router}}/{{router_nat}}

• {{region}}/{{router}}/{{router_nat}}

• {{router}}/{{router_nat}}

When using the pulumi import command, RouterNatAddress can be imported using one of the formats above. For example:

$ pulumi import gcp:compute/routerNatAddress:RouterNatAddress default projects/{{project}}/regions/{{region}}/routers/{{router}}/{{router_nat}}

$ pulumi import gcp:compute/routerNatAddress:RouterNatAddress default {{project}}/{{region}}/{{router}}/{{router_nat}}

$ pulumi import gcp:compute/routerNatAddress:RouterNatAddress default {{region}}/{{router}}/{{router_nat}}

$ pulumi import gcp:compute/routerNatAddress:RouterNatAddress default {{router}}/{{router_nat}}

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository

Google Cloud (GCP) Classic pulumi/pulumi-gcp

License

Apache-2.0

Notes

This Pulumi package is based on the google-beta Terraform Provider.