Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.gcp.compute.kotlin
import com.pulumi.core.Output
import com.pulumi.gcp.compute.kotlin.outputs.InterconnectAttachmentPrivateInterconnectInfo
import com.pulumi.gcp.compute.kotlin.outputs.InterconnectAttachmentPrivateInterconnectInfo.Companion.toKotlin
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
/**
* Builder for [InterconnectAttachment].
*/
@PulumiTagMarker
public class InterconnectAttachmentResourceBuilder internal constructor() {
public var name: String? = null
public var args: InterconnectAttachmentArgs = InterconnectAttachmentArgs()
public var opts: CustomResourceOptions = CustomResourceOptions()
/**
* @param name The _unique_ name of the resulting resource.
*/
public fun name(`value`: String) {
this.name = value
}
/**
* @param block The arguments to use to populate this resource's properties.
*/
public suspend fun args(block: suspend InterconnectAttachmentArgsBuilder.() -> Unit) {
val builder = InterconnectAttachmentArgsBuilder()
block(builder)
this.args = builder.build()
}
/**
* @param block A bag of options that control this resource's behavior.
*/
public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
}
internal fun build(): InterconnectAttachment {
val builtJavaResource = com.pulumi.gcp.compute.InterconnectAttachment(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return InterconnectAttachment(builtJavaResource)
}
}
/**
* Represents an InterconnectAttachment (VLAN attachment) resource. For more
* information, see Creating VLAN Attachments.
* ## Example Usage
* ### Interconnect Attachment Basic
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const foobarNetwork = new gcp.compute.Network("foobar", {
* name: "network-1",
* autoCreateSubnetworks: false,
* });
* const foobar = new gcp.compute.Router("foobar", {
* name: "router-1",
* network: foobarNetwork.name,
* bgp: {
* asn: 16550,
* },
* });
* const onPrem = new gcp.compute.InterconnectAttachment("on_prem", {
* name: "on-prem-attachment",
* edgeAvailabilityDomain: "AVAILABILITY_DOMAIN_1",
* type: "PARTNER",
* router: foobar.id,
* mtu: "1500",
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* foobar_network = gcp.compute.Network("foobar",
* name="network-1",
* auto_create_subnetworks=False)
* foobar = gcp.compute.Router("foobar",
* name="router-1",
* network=foobar_network.name,
* bgp={
* "asn": 16550,
* })
* on_prem = gcp.compute.InterconnectAttachment("on_prem",
* name="on-prem-attachment",
* edge_availability_domain="AVAILABILITY_DOMAIN_1",
* type="PARTNER",
* router=foobar.id,
* mtu="1500")
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var foobarNetwork = new Gcp.Compute.Network("foobar", new()
* {
* Name = "network-1",
* AutoCreateSubnetworks = false,
* });
* var foobar = new Gcp.Compute.Router("foobar", new()
* {
* Name = "router-1",
* Network = foobarNetwork.Name,
* Bgp = new Gcp.Compute.Inputs.RouterBgpArgs
* {
* Asn = 16550,
* },
* });
* var onPrem = new Gcp.Compute.InterconnectAttachment("on_prem", new()
* {
* Name = "on-prem-attachment",
* EdgeAvailabilityDomain = "AVAILABILITY_DOMAIN_1",
* Type = "PARTNER",
* Router = foobar.Id,
* Mtu = "1500",
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* foobarNetwork, err := compute.NewNetwork(ctx, "foobar", &compute.NetworkArgs{
* Name: pulumi.String("network-1"),
* AutoCreateSubnetworks: pulumi.Bool(false),
* })
* if err != nil {
* return err
* }
* foobar, err := compute.NewRouter(ctx, "foobar", &compute.RouterArgs{
* Name: pulumi.String("router-1"),
* Network: foobarNetwork.Name,
* Bgp: &compute.RouterBgpArgs{
* Asn: pulumi.Int(16550),
* },
* })
* if err != nil {
* return err
* }
* _, err = compute.NewInterconnectAttachment(ctx, "on_prem", &compute.InterconnectAttachmentArgs{
* Name: pulumi.String("on-prem-attachment"),
* EdgeAvailabilityDomain: pulumi.String("AVAILABILITY_DOMAIN_1"),
* Type: pulumi.String("PARTNER"),
* Router: foobar.ID(),
* Mtu: pulumi.String("1500"),
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.gcp.compute.Network;
* import com.pulumi.gcp.compute.NetworkArgs;
* import com.pulumi.gcp.compute.Router;
* import com.pulumi.gcp.compute.RouterArgs;
* import com.pulumi.gcp.compute.inputs.RouterBgpArgs;
* import com.pulumi.gcp.compute.InterconnectAttachment;
* import com.pulumi.gcp.compute.InterconnectAttachmentArgs;
* 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 foobarNetwork = new Network("foobarNetwork", NetworkArgs.builder()
* .name("network-1")
* .autoCreateSubnetworks(false)
* .build());
* var foobar = new Router("foobar", RouterArgs.builder()
* .name("router-1")
* .network(foobarNetwork.name())
* .bgp(RouterBgpArgs.builder()
* .asn(16550)
* .build())
* .build());
* var onPrem = new InterconnectAttachment("onPrem", InterconnectAttachmentArgs.builder()
* .name("on-prem-attachment")
* .edgeAvailabilityDomain("AVAILABILITY_DOMAIN_1")
* .type("PARTNER")
* .router(foobar.id())
* .mtu(1500)
* .build());
* }
* }
* ```
* ```yaml
* resources:
* onPrem:
* type: gcp:compute:InterconnectAttachment
* name: on_prem
* properties:
* name: on-prem-attachment
* edgeAvailabilityDomain: AVAILABILITY_DOMAIN_1
* type: PARTNER
* router: ${foobar.id}
* mtu: 1500
* foobar:
* type: gcp:compute:Router
* properties:
* name: router-1
* network: ${foobarNetwork.name}
* bgp:
* asn: 16550
* foobarNetwork:
* type: gcp:compute:Network
* name: foobar
* properties:
* name: network-1
* autoCreateSubnetworks: false
* ```
*
* ### Compute Interconnect Attachment Ipsec Encryption
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as gcp from "@pulumi/gcp";
* const network = new gcp.compute.Network("network", {
* name: "test-network",
* autoCreateSubnetworks: false,
* });
* const address = new gcp.compute.Address("address", {
* name: "test-address",
* addressType: "INTERNAL",
* purpose: "IPSEC_INTERCONNECT",
* address: "192.168.1.0",
* prefixLength: 29,
* network: network.selfLink,
* });
* const router = new gcp.compute.Router("router", {
* name: "test-router",
* network: network.name,
* encryptedInterconnectRouter: true,
* bgp: {
* asn: 16550,
* },
* });
* const ipsec_encrypted_interconnect_attachment = new gcp.compute.InterconnectAttachment("ipsec-encrypted-interconnect-attachment", {
* name: "test-interconnect-attachment",
* edgeAvailabilityDomain: "AVAILABILITY_DOMAIN_1",
* type: "PARTNER",
* router: router.id,
* encryption: "IPSEC",
* ipsecInternalAddresses: [address.selfLink],
* });
* ```
* ```python
* import pulumi
* import pulumi_gcp as gcp
* network = gcp.compute.Network("network",
* name="test-network",
* auto_create_subnetworks=False)
* address = gcp.compute.Address("address",
* name="test-address",
* address_type="INTERNAL",
* purpose="IPSEC_INTERCONNECT",
* address="192.168.1.0",
* prefix_length=29,
* network=network.self_link)
* router = gcp.compute.Router("router",
* name="test-router",
* network=network.name,
* encrypted_interconnect_router=True,
* bgp={
* "asn": 16550,
* })
* ipsec_encrypted_interconnect_attachment = gcp.compute.InterconnectAttachment("ipsec-encrypted-interconnect-attachment",
* name="test-interconnect-attachment",
* edge_availability_domain="AVAILABILITY_DOMAIN_1",
* type="PARTNER",
* router=router.id,
* encryption="IPSEC",
* ipsec_internal_addresses=[address.self_link])
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Gcp = Pulumi.Gcp;
* return await Deployment.RunAsync(() =>
* {
* var network = new Gcp.Compute.Network("network", new()
* {
* Name = "test-network",
* AutoCreateSubnetworks = false,
* });
* var address = new Gcp.Compute.Address("address", new()
* {
* Name = "test-address",
* AddressType = "INTERNAL",
* Purpose = "IPSEC_INTERCONNECT",
* IPAddress = "192.168.1.0",
* PrefixLength = 29,
* Network = network.SelfLink,
* });
* var router = new Gcp.Compute.Router("router", new()
* {
* Name = "test-router",
* Network = network.Name,
* EncryptedInterconnectRouter = true,
* Bgp = new Gcp.Compute.Inputs.RouterBgpArgs
* {
* Asn = 16550,
* },
* });
* var ipsec_encrypted_interconnect_attachment = new Gcp.Compute.InterconnectAttachment("ipsec-encrypted-interconnect-attachment", new()
* {
* Name = "test-interconnect-attachment",
* EdgeAvailabilityDomain = "AVAILABILITY_DOMAIN_1",
* Type = "PARTNER",
* Router = router.Id,
* Encryption = "IPSEC",
* IpsecInternalAddresses = new[]
* {
* address.SelfLink,
* },
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* network, err := compute.NewNetwork(ctx, "network", &compute.NetworkArgs{
* Name: pulumi.String("test-network"),
* AutoCreateSubnetworks: pulumi.Bool(false),
* })
* if err != nil {
* return err
* }
* address, err := compute.NewAddress(ctx, "address", &compute.AddressArgs{
* Name: pulumi.String("test-address"),
* AddressType: pulumi.String("INTERNAL"),
* Purpose: pulumi.String("IPSEC_INTERCONNECT"),
* Address: pulumi.String("192.168.1.0"),
* PrefixLength: pulumi.Int(29),
* Network: network.SelfLink,
* })
* if err != nil {
* return err
* }
* router, err := compute.NewRouter(ctx, "router", &compute.RouterArgs{
* Name: pulumi.String("test-router"),
* Network: network.Name,
* EncryptedInterconnectRouter: pulumi.Bool(true),
* Bgp: &compute.RouterBgpArgs{
* Asn: pulumi.Int(16550),
* },
* })
* if err != nil {
* return err
* }
* _, err = compute.NewInterconnectAttachment(ctx, "ipsec-encrypted-interconnect-attachment", &compute.InterconnectAttachmentArgs{
* Name: pulumi.String("test-interconnect-attachment"),
* EdgeAvailabilityDomain: pulumi.String("AVAILABILITY_DOMAIN_1"),
* Type: pulumi.String("PARTNER"),
* Router: router.ID(),
* Encryption: pulumi.String("IPSEC"),
* IpsecInternalAddresses: pulumi.StringArray{
* address.SelfLink,
* },
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.gcp.compute.Network;
* import com.pulumi.gcp.compute.NetworkArgs;
* import com.pulumi.gcp.compute.Address;
* import com.pulumi.gcp.compute.AddressArgs;
* import com.pulumi.gcp.compute.Router;
* import com.pulumi.gcp.compute.RouterArgs;
* import com.pulumi.gcp.compute.inputs.RouterBgpArgs;
* import com.pulumi.gcp.compute.InterconnectAttachment;
* import com.pulumi.gcp.compute.InterconnectAttachmentArgs;
* 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 network = new Network("network", NetworkArgs.builder()
* .name("test-network")
* .autoCreateSubnetworks(false)
* .build());
* var address = new Address("address", AddressArgs.builder()
* .name("test-address")
* .addressType("INTERNAL")
* .purpose("IPSEC_INTERCONNECT")
* .address("192.168.1.0")
* .prefixLength(29)
* .network(network.selfLink())
* .build());
* var router = new Router("router", RouterArgs.builder()
* .name("test-router")
* .network(network.name())
* .encryptedInterconnectRouter(true)
* .bgp(RouterBgpArgs.builder()
* .asn(16550)
* .build())
* .build());
* var ipsec_encrypted_interconnect_attachment = new InterconnectAttachment("ipsec-encrypted-interconnect-attachment", InterconnectAttachmentArgs.builder()
* .name("test-interconnect-attachment")
* .edgeAvailabilityDomain("AVAILABILITY_DOMAIN_1")
* .type("PARTNER")
* .router(router.id())
* .encryption("IPSEC")
* .ipsecInternalAddresses(address.selfLink())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* ipsec-encrypted-interconnect-attachment:
* type: gcp:compute:InterconnectAttachment
* properties:
* name: test-interconnect-attachment
* edgeAvailabilityDomain: AVAILABILITY_DOMAIN_1
* type: PARTNER
* router: ${router.id}
* encryption: IPSEC
* ipsecInternalAddresses:
* - ${address.selfLink}
* address:
* type: gcp:compute:Address
* properties:
* name: test-address
* addressType: INTERNAL
* purpose: IPSEC_INTERCONNECT
* address: 192.168.1.0
* prefixLength: 29
* network: ${network.selfLink}
* router:
* type: gcp:compute:Router
* properties:
* name: test-router
* network: ${network.name}
* encryptedInterconnectRouter: true
* bgp:
* asn: 16550
* network:
* type: gcp:compute:Network
* properties:
* name: test-network
* autoCreateSubnetworks: false
* ```
*
* ## Import
* InterconnectAttachment can be imported using any of these accepted formats:
* * `projects/{{project}}/regions/{{region}}/interconnectAttachments/{{name}}`
* * `{{project}}/{{region}}/{{name}}`
* * `{{region}}/{{name}}`
* * `{{name}}`
* When using the `pulumi import` command, InterconnectAttachment can be imported using one of the formats above. For example:
* ```sh
* $ pulumi import gcp:compute/interconnectAttachment:InterconnectAttachment default projects/{{project}}/regions/{{region}}/interconnectAttachments/{{name}}
* ```
* ```sh
* $ pulumi import gcp:compute/interconnectAttachment:InterconnectAttachment default {{project}}/{{region}}/{{name}}
* ```
* ```sh
* $ pulumi import gcp:compute/interconnectAttachment:InterconnectAttachment default {{region}}/{{name}}
* ```
* ```sh
* $ pulumi import gcp:compute/interconnectAttachment:InterconnectAttachment default {{name}}
* ```
*/
public class InterconnectAttachment internal constructor(
override val javaResource: com.pulumi.gcp.compute.InterconnectAttachment,
) : KotlinCustomResource(javaResource, InterconnectAttachmentMapper) {
/**
* Whether the VLAN attachment is enabled or disabled. When using
* PARTNER type this will Pre-Activate the interconnect attachment
*/
public val adminEnabled: Output?
get() = javaResource.adminEnabled().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Provisioned bandwidth capacity for the interconnect attachment.
* For attachments of type DEDICATED, the user can set the bandwidth.
* For attachments of type PARTNER, the Google Partner that is operating the interconnect must set the bandwidth.
* Output only for PARTNER type, mutable for PARTNER_PROVIDER and DEDICATED,
* Defaults to BPS_10G
* Possible values are: `BPS_50M`, `BPS_100M`, `BPS_200M`, `BPS_300M`, `BPS_400M`, `BPS_500M`, `BPS_1G`, `BPS_2G`, `BPS_5G`, `BPS_10G`, `BPS_20G`, `BPS_50G`.
*/
public val bandwidth: Output
get() = javaResource.bandwidth().applyValue({ args0 -> args0 })
/**
* Up to 16 candidate prefixes that can be used to restrict the allocation
* of cloudRouterIpAddress and customerRouterIpAddress for this attachment.
* All prefixes must be within link-local address space (169.254.0.0/16)
* and must be /29 or shorter (/28, /27, etc). Google will attempt to select
* an unused /29 from the supplied candidate prefix(es). The request will
* fail if all possible /29s are in use on Google's edge. If not supplied,
* Google will randomly select an unused /29 from all of link-local space.
*/
public val candidateSubnets: Output>?
get() = javaResource.candidateSubnets().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 -> args0 })
}).orElse(null)
})
/**
* IPv4 address + prefix length to be configured on Cloud Router
* Interface for this interconnect attachment.
*/
public val cloudRouterIpAddress: Output
get() = javaResource.cloudRouterIpAddress().applyValue({ args0 -> args0 })
/**
* IPv6 address + prefix length to be configured on Cloud Router
* Interface for this interconnect attachment.
*/
public val cloudRouterIpv6Address: Output
get() = javaResource.cloudRouterIpv6Address().applyValue({ args0 -> args0 })
/**
* Creation timestamp in RFC3339 text format.
*/
public val creationTimestamp: Output
get() = javaResource.creationTimestamp().applyValue({ args0 -> args0 })
/**
* IPv4 address + prefix length to be configured on the customer
* router subinterface for this interconnect attachment.
*/
public val customerRouterIpAddress: Output
get() = javaResource.customerRouterIpAddress().applyValue({ args0 -> args0 })
/**
* IPv6 address + prefix length to be configured on the customer
* router subinterface for this interconnect attachment.
*/
public val customerRouterIpv6Address: Output
get() = javaResource.customerRouterIpv6Address().applyValue({ args0 -> args0 })
/**
* An optional description of this resource.
*/
public val description: Output?
get() = javaResource.description().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Desired availability domain for the attachment. Only available for type
* PARTNER, at creation time. For improved reliability, customers should
* configure a pair of attachments with one per availability domain. The
* selected availability domain will be provided to the Partner via the
* pairing key so that the provisioned circuit will lie in the specified
* domain. If not specified, the value will default to AVAILABILITY_DOMAIN_ANY.
*/
public val edgeAvailabilityDomain: Output
get() = javaResource.edgeAvailabilityDomain().applyValue({ args0 -> args0 })
/**
* Indicates the user-supplied encryption option of this interconnect
* attachment. Can only be specified at attachment creation for PARTNER or
* DEDICATED attachments.
* * NONE - This is the default value, which means that the VLAN attachment
* carries unencrypted traffic. VMs are able to send traffic to, or receive
* traffic from, such a VLAN attachment.
* * IPSEC - The VLAN attachment carries only encrypted traffic that is
* encrypted by an IPsec device, such as an HA VPN gateway or third-party
* IPsec VPN. VMs cannot directly send traffic to, or receive traffic from,
* such a VLAN attachment. To use HA VPN over Cloud Interconnect, the VLAN
* attachment must be created with this option.
* Default value is `NONE`.
* Possible values are: `NONE`, `IPSEC`.
*/
public val encryption: Output?
get() = javaResource.encryption().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Google reference ID, to be used when raising support tickets with
* Google or otherwise to debug backend connectivity issues.
*/
public val googleReferenceId: Output
get() = javaResource.googleReferenceId().applyValue({ args0 -> args0 })
/**
* URL of the underlying Interconnect object that this attachment's
* traffic will traverse through. Required if type is DEDICATED, must not
* be set if type is PARTNER.
*/
public val interconnect: Output?
get() = javaResource.interconnect().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* URL of addresses that have been reserved for the interconnect attachment,
* Used only for interconnect attachment that has the encryption option as
* IPSEC.
* The addresses must be RFC 1918 IP address ranges. When creating HA VPN
* gateway over the interconnect attachment, if the attachment is configured
* to use an RFC 1918 IP address, then the VPN gateway's IP address will be
* allocated from the IP address range specified here.
* For example, if the HA VPN gateway's interface 0 is paired to this
* interconnect attachment, then an RFC 1918 IP address for the VPN gateway
* interface 0 will be allocated from the IP address specified for this
* interconnect attachment.
* If this field is not specified for interconnect attachment that has
* encryption option as IPSEC, later on when creating HA VPN gateway on this
* interconnect attachment, the HA VPN gateway's IP address will be
* allocated from regional external IP address pool.
*/
public val ipsecInternalAddresses: Output>?
get() = javaResource.ipsecInternalAddresses().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 -> args0 })
}).orElse(null)
})
/**
* Maximum Transmission Unit (MTU), in bytes, of packets passing through
* this interconnect attachment. Currently, only 1440 and 1500 are allowed. If not specified, the value will default to 1440.
*/
public val mtu: Output
get() = javaResource.mtu().applyValue({ args0 -> args0 })
/**
* Name of the resource. Provided by the client when the resource is created. The
* name must be 1-63 characters long, and comply with RFC1035. Specifically, the
* name must be 1-63 characters long and match the regular expression
* `a-z?` which means the first character must be a
* lowercase letter, and all following characters must be a dash, lowercase
* letter, or digit, except the last character, which cannot be a dash.
* - - -
*/
public val name: Output
get() = javaResource.name().applyValue({ args0 -> args0 })
/**
* [Output only for type PARTNER. Not present for DEDICATED]. The opaque
* identifier of an PARTNER attachment used to initiate provisioning with
* a selected partner. Of the form "XXXXX/region/domain"
*/
public val pairingKey: Output
get() = javaResource.pairingKey().applyValue({ args0 -> args0 })
/**
* [Output only for type PARTNER. Not present for DEDICATED]. Optional
* BGP ASN for the router that should be supplied by a layer 3 Partner if
* they configured BGP on behalf of the customer.
*/
public val partnerAsn: Output
get() = javaResource.partnerAsn().applyValue({ args0 -> args0 })
/**
* Information specific to an InterconnectAttachment. This property
* is populated if the interconnect that this is attached to is of type DEDICATED.
* Structure is documented below.
*/
public val privateInterconnectInfos: Output>
get() = javaResource.privateInterconnectInfos().applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> toKotlin(args0) })
})
})
/**
* The ID of the project in which the resource belongs.
* If it is not provided, the provider project is used.
*/
public val project: Output
get() = javaResource.project().applyValue({ args0 -> args0 })
/**
* Region where the regional interconnect attachment resides.
*/
public val region: Output
get() = javaResource.region().applyValue({ args0 -> args0 })
/**
* URL of the cloud router to be used for dynamic routing. This router must be in
* the same region as this InterconnectAttachment. The InterconnectAttachment will
* automatically connect the Interconnect to the network & region within which the
* Cloud Router is configured.
*/
public val router: Output
get() = javaResource.router().applyValue({ args0 -> args0 })
/**
* The URI of the created resource.
*/
public val selfLink: Output
get() = javaResource.selfLink().applyValue({ args0 -> args0 })
/**
* The stack type for this interconnect attachment to identify whether the IPv6
* feature is enabled or not. If not specified, IPV4_ONLY will be used.
* This field can be both set at interconnect attachments creation and update
* interconnect attachment operations.
* Possible values are: `IPV4_IPV6`, `IPV4_ONLY`.
*/
public val stackType: Output
get() = javaResource.stackType().applyValue({ args0 -> args0 })
/**
* [Output Only] The current state of this attachment's functionality.
*/
public val state: Output
get() = javaResource.state().applyValue({ args0 -> args0 })
/**
* Length of the IPv4 subnet mask. Allowed values: 29 (default), 30. The default value is 29,
* except for Cross-Cloud Interconnect connections that use an InterconnectRemoteLocation with a
* constraints.subnetLengthRange.min equal to 30. For example, connections that use an Azure
* remote location fall into this category. In these cases, the default value is 30, and
* requesting 29 returns an error. Where both 29 and 30 are allowed, 29 is preferred, because it
* gives Google Cloud Support more debugging visibility.
*/
public val subnetLength: Output?
get() = javaResource.subnetLength().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The type of InterconnectAttachment you wish to create. Defaults to
* DEDICATED.
* Possible values are: `DEDICATED`, `PARTNER`, `PARTNER_PROVIDER`.
*/
public val type: Output
get() = javaResource.type().applyValue({ args0 -> args0 })
/**
* The IEEE 802.1Q VLAN tag for this attachment, in the range 2-4094. When
* using PARTNER type this will be managed upstream.
*/
public val vlanTag8021q: Output
get() = javaResource.vlanTag8021q().applyValue({ args0 -> args0 })
}
public object InterconnectAttachmentMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.gcp.compute.InterconnectAttachment::class == javaResource::class
override fun map(javaResource: Resource): InterconnectAttachment =
InterconnectAttachment(javaResource as com.pulumi.gcp.compute.InterconnectAttachment)
}
/**
* @see [InterconnectAttachment].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [InterconnectAttachment].
*/
public suspend fun interconnectAttachment(
name: String,
block: suspend InterconnectAttachmentResourceBuilder.() -> Unit,
): InterconnectAttachment {
val builder = InterconnectAttachmentResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [InterconnectAttachment].
* @param name The _unique_ name of the resulting resource.
*/
public fun interconnectAttachment(name: String): InterconnectAttachment {
val builder = InterconnectAttachmentResourceBuilder()
builder.name(name)
return builder.build()
}
