body
stringlengths 26
98.2k
| body_hash
int64 -9,222,864,604,528,158,000
9,221,803,474B
| docstring
stringlengths 1
16.8k
| path
stringlengths 5
230
| name
stringlengths 1
96
| repository_name
stringlengths 7
89
| lang
stringclasses 1
value | body_without_docstring
stringlengths 20
98.2k
|
|---|---|---|---|---|---|---|---|
@property
@pulumi.getter(name='advertisedGroups')
def advertised_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpPeerAdvertisedGroupsItem']]]]:
'\n User-specified list of prefix groups to advertise in custom mode, which can take one of the following options: - ALL_SUBNETS: Advertises all available subnets, including peer VPC subnets. - ALL_VPC_SUBNETS: Advertises the router\'s own VPC subnets. Note that this field can only be populated if advertise_mode is CUSTOM and overrides the list defined for the router (in the "bgp" message). These groups are advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.\n '
return pulumi.get(self, 'advertised_groups')
| 2,363,357,547,399,857,700
|
User-specified list of prefix groups to advertise in custom mode, which can take one of the following options: - ALL_SUBNETS: Advertises all available subnets, including peer VPC subnets. - ALL_VPC_SUBNETS: Advertises the router's own VPC subnets. Note that this field can only be populated if advertise_mode is CUSTOM and overrides the list defined for the router (in the "bgp" message). These groups are advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
advertised_groups
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='advertisedGroups')
def advertised_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpPeerAdvertisedGroupsItem']]]]:
'\n User-specified list of prefix groups to advertise in custom mode, which can take one of the following options: - ALL_SUBNETS: Advertises all available subnets, including peer VPC subnets. - ALL_VPC_SUBNETS: Advertises the router\'s own VPC subnets. Note that this field can only be populated if advertise_mode is CUSTOM and overrides the list defined for the router (in the "bgp" message). These groups are advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.\n '
return pulumi.get(self, 'advertised_groups')
|
@property
@pulumi.getter(name='advertisedIpRanges')
def advertised_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]]]:
'\n User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and overrides the list defined for the router (in the "bgp" message). These IP ranges are advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.\n '
return pulumi.get(self, 'advertised_ip_ranges')
| 2,100,521,784,183,591,400
|
User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and overrides the list defined for the router (in the "bgp" message). These IP ranges are advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
advertised_ip_ranges
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='advertisedIpRanges')
def advertised_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]]]:
'\n \n '
return pulumi.get(self, 'advertised_ip_ranges')
|
@property
@pulumi.getter(name='advertisedRoutePriority')
def advertised_route_priority(self) -> Optional[pulumi.Input[int]]:
'\n The priority of routes advertised to this BGP peer. Where there is more than one matching route of maximum length, the routes with the lowest priority value win.\n '
return pulumi.get(self, 'advertised_route_priority')
| -3,647,610,572,457,442,300
|
The priority of routes advertised to this BGP peer. Where there is more than one matching route of maximum length, the routes with the lowest priority value win.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
advertised_route_priority
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='advertisedRoutePriority')
def advertised_route_priority(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'advertised_route_priority')
|
@property
@pulumi.getter
def bfd(self) -> Optional[pulumi.Input['RouterBgpPeerBfdArgs']]:
'\n BFD configuration for the BGP peering.\n '
return pulumi.get(self, 'bfd')
| 2,193,612,015,508,931,300
|
BFD configuration for the BGP peering.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
bfd
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def bfd(self) -> Optional[pulumi.Input['RouterBgpPeerBfdArgs']]:
'\n \n '
return pulumi.get(self, 'bfd')
|
@property
@pulumi.getter
def enable(self) -> Optional[pulumi.Input['RouterBgpPeerEnable']]:
'\n The status of the BGP peer connection. If set to FALSE, any active session with the peer is terminated and all associated routing information is removed. If set to TRUE, the peer connection can be established with routing information. The default is TRUE.\n '
return pulumi.get(self, 'enable')
| 3,638,441,869,262,351,000
|
The status of the BGP peer connection. If set to FALSE, any active session with the peer is terminated and all associated routing information is removed. If set to TRUE, the peer connection can be established with routing information. The default is TRUE.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enable
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def enable(self) -> Optional[pulumi.Input['RouterBgpPeerEnable']]:
'\n \n '
return pulumi.get(self, 'enable')
|
@property
@pulumi.getter(name='enableIpv6')
def enable_ipv6(self) -> Optional[pulumi.Input[bool]]:
'\n Enable IPv6 traffic over BGP Peer. If not specified, it is disabled by default.\n '
return pulumi.get(self, 'enable_ipv6')
| -6,175,929,967,183,419,000
|
Enable IPv6 traffic over BGP Peer. If not specified, it is disabled by default.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enable_ipv6
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='enableIpv6')
def enable_ipv6(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'enable_ipv6')
|
@property
@pulumi.getter(name='interfaceName')
def interface_name(self) -> Optional[pulumi.Input[str]]:
'\n Name of the interface the BGP peer is associated with.\n '
return pulumi.get(self, 'interface_name')
| -1,903,031,188,723,196,400
|
Name of the interface the BGP peer is associated with.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
interface_name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='interfaceName')
def interface_name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'interface_name')
|
@property
@pulumi.getter(name='ipAddress')
def ip_address(self) -> Optional[pulumi.Input[str]]:
'\n IP address of the interface inside Google Cloud Platform. Only IPv4 is supported.\n '
return pulumi.get(self, 'ip_address')
| -3,578,195,004,325,526,000
|
IP address of the interface inside Google Cloud Platform. Only IPv4 is supported.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
ip_address
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='ipAddress')
def ip_address(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'ip_address')
|
@property
@pulumi.getter(name='ipv6NexthopAddress')
def ipv6_nexthop_address(self) -> Optional[pulumi.Input[str]]:
'\n IPv6 address of the interface inside Google Cloud Platform.\n '
return pulumi.get(self, 'ipv6_nexthop_address')
| -2,058,201,300,910,098,000
|
IPv6 address of the interface inside Google Cloud Platform.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
ipv6_nexthop_address
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='ipv6NexthopAddress')
def ipv6_nexthop_address(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'ipv6_nexthop_address')
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n Name of this BGP peer. 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]([-a-z0-9]*[a-z0-9])?` 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.\n '
return pulumi.get(self, 'name')
| -6,021,097,294,036,206,000
|
Name of this BGP peer. 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]([-a-z0-9]*[a-z0-9])?` 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.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'name')
|
@property
@pulumi.getter(name='peerAsn')
def peer_asn(self) -> Optional[pulumi.Input[int]]:
'\n Peer BGP Autonomous System Number (ASN). Each BGP interface may use a different value.\n '
return pulumi.get(self, 'peer_asn')
| -3,005,583,462,519,792,600
|
Peer BGP Autonomous System Number (ASN). Each BGP interface may use a different value.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
peer_asn
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='peerAsn')
def peer_asn(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'peer_asn')
|
@property
@pulumi.getter(name='peerIpAddress')
def peer_ip_address(self) -> Optional[pulumi.Input[str]]:
'\n IP address of the BGP interface outside Google Cloud Platform. Only IPv4 is supported.\n '
return pulumi.get(self, 'peer_ip_address')
| 5,637,232,032,146,817,000
|
IP address of the BGP interface outside Google Cloud Platform. Only IPv4 is supported.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
peer_ip_address
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='peerIpAddress')
def peer_ip_address(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'peer_ip_address')
|
@property
@pulumi.getter(name='peerIpv6NexthopAddress')
def peer_ipv6_nexthop_address(self) -> Optional[pulumi.Input[str]]:
'\n IPv6 address of the BGP interface outside Google Cloud Platform.\n '
return pulumi.get(self, 'peer_ipv6_nexthop_address')
| -8,829,923,199,086,197,000
|
IPv6 address of the BGP interface outside Google Cloud Platform.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
peer_ipv6_nexthop_address
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='peerIpv6NexthopAddress')
def peer_ipv6_nexthop_address(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'peer_ipv6_nexthop_address')
|
@property
@pulumi.getter(name='routerApplianceInstance')
def router_appliance_instance(self) -> Optional[pulumi.Input[str]]:
'\n URI of the VM instance that is used as third-party router appliances such as Next Gen Firewalls, Virtual Routers, or Router Appliances. The VM instance must be located in zones contained in the same region as this Cloud Router. The VM instance is the peer side of the BGP session.\n '
return pulumi.get(self, 'router_appliance_instance')
| -3,297,314,188,586,559,000
|
URI of the VM instance that is used as third-party router appliances such as Next Gen Firewalls, Virtual Routers, or Router Appliances. The VM instance must be located in zones contained in the same region as this Cloud Router. The VM instance is the peer side of the BGP session.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
router_appliance_instance
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='routerApplianceInstance')
def router_appliance_instance(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'router_appliance_instance')
|
def __init__(__self__, *, advertise_mode: Optional[pulumi.Input['RouterBgpAdvertiseMode']]=None, advertised_groups: Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]]]=None, advertised_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]]]=None, asn: Optional[pulumi.Input[int]]=None, keepalive_interval: Optional[pulumi.Input[int]]=None):
"\n :param pulumi.Input['RouterBgpAdvertiseMode'] advertise_mode: User-specified flag to indicate which mode to use for advertisement. The options are DEFAULT or CUSTOM.\n :param pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]] advertised_groups: User-specified list of prefix groups to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These groups will be advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.\n :param pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These IP ranges will be advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.\n :param pulumi.Input[int] asn: Local BGP Autonomous System Number (ASN). Must be an RFC6996 private ASN, either 16-bit or 32-bit. The value will be fixed for this router resource. All VPN tunnels that link to this router will have the same local ASN.\n :param pulumi.Input[int] keepalive_interval: The interval in seconds between BGP keepalive messages that are sent to the peer. Hold time is three times the interval at which keepalive messages are sent, and the hold time is the maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer. BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.\n "
if (advertise_mode is not None):
pulumi.set(__self__, 'advertise_mode', advertise_mode)
if (advertised_groups is not None):
pulumi.set(__self__, 'advertised_groups', advertised_groups)
if (advertised_ip_ranges is not None):
pulumi.set(__self__, 'advertised_ip_ranges', advertised_ip_ranges)
if (asn is not None):
pulumi.set(__self__, 'asn', asn)
if (keepalive_interval is not None):
pulumi.set(__self__, 'keepalive_interval', keepalive_interval)
| -5,052,623,954,703,217,000
|
:param pulumi.Input['RouterBgpAdvertiseMode'] advertise_mode: User-specified flag to indicate which mode to use for advertisement. The options are DEFAULT or CUSTOM.
:param pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]] advertised_groups: User-specified list of prefix groups to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These groups will be advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.
:param pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These IP ranges will be advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.
:param pulumi.Input[int] asn: Local BGP Autonomous System Number (ASN). Must be an RFC6996 private ASN, either 16-bit or 32-bit. The value will be fixed for this router resource. All VPN tunnels that link to this router will have the same local ASN.
:param pulumi.Input[int] keepalive_interval: The interval in seconds between BGP keepalive messages that are sent to the peer. Hold time is three times the interval at which keepalive messages are sent, and the hold time is the maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer. BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, advertise_mode: Optional[pulumi.Input['RouterBgpAdvertiseMode']]=None, advertised_groups: Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]]]=None, advertised_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]]]=None, asn: Optional[pulumi.Input[int]]=None, keepalive_interval: Optional[pulumi.Input[int]]=None):
"\n :param pulumi.Input['RouterBgpAdvertiseMode'] advertise_mode: User-specified flag to indicate which mode to use for advertisement. The options are DEFAULT or CUSTOM.\n :param pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]] advertised_groups: User-specified list of prefix groups to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These groups will be advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.\n :param pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These IP ranges will be advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.\n :param pulumi.Input[int] asn: Local BGP Autonomous System Number (ASN). Must be an RFC6996 private ASN, either 16-bit or 32-bit. The value will be fixed for this router resource. All VPN tunnels that link to this router will have the same local ASN.\n :param pulumi.Input[int] keepalive_interval: The interval in seconds between BGP keepalive messages that are sent to the peer. Hold time is three times the interval at which keepalive messages are sent, and the hold time is the maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer. BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.\n "
if (advertise_mode is not None):
pulumi.set(__self__, 'advertise_mode', advertise_mode)
if (advertised_groups is not None):
pulumi.set(__self__, 'advertised_groups', advertised_groups)
if (advertised_ip_ranges is not None):
pulumi.set(__self__, 'advertised_ip_ranges', advertised_ip_ranges)
if (asn is not None):
pulumi.set(__self__, 'asn', asn)
if (keepalive_interval is not None):
pulumi.set(__self__, 'keepalive_interval', keepalive_interval)
|
@property
@pulumi.getter(name='advertiseMode')
def advertise_mode(self) -> Optional[pulumi.Input['RouterBgpAdvertiseMode']]:
'\n User-specified flag to indicate which mode to use for advertisement. The options are DEFAULT or CUSTOM.\n '
return pulumi.get(self, 'advertise_mode')
| 6,547,796,711,742,336,000
|
User-specified flag to indicate which mode to use for advertisement. The options are DEFAULT or CUSTOM.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
advertise_mode
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='advertiseMode')
def advertise_mode(self) -> Optional[pulumi.Input['RouterBgpAdvertiseMode']]:
'\n \n '
return pulumi.get(self, 'advertise_mode')
|
@property
@pulumi.getter(name='advertisedGroups')
def advertised_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]]]:
'\n User-specified list of prefix groups to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These groups will be advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.\n '
return pulumi.get(self, 'advertised_groups')
| 7,157,919,484,063,481,000
|
User-specified list of prefix groups to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These groups will be advertised in addition to any specified prefixes. Leave this field blank to advertise no custom groups.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
advertised_groups
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='advertisedGroups')
def advertised_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterBgpAdvertisedGroupsItem']]]]:
'\n \n '
return pulumi.get(self, 'advertised_groups')
|
@property
@pulumi.getter(name='advertisedIpRanges')
def advertised_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]]]:
'\n User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These IP ranges will be advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.\n '
return pulumi.get(self, 'advertised_ip_ranges')
| -1,156,382,621,223,308,300
|
User-specified list of individual IP ranges to advertise in custom mode. This field can only be populated if advertise_mode is CUSTOM and is advertised to all peers of the router. These IP ranges will be advertised in addition to any specified groups. Leave this field blank to advertise no custom IP ranges.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
advertised_ip_ranges
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='advertisedIpRanges')
def advertised_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterAdvertisedIpRangeArgs']]]]:
'\n \n '
return pulumi.get(self, 'advertised_ip_ranges')
|
@property
@pulumi.getter
def asn(self) -> Optional[pulumi.Input[int]]:
'\n Local BGP Autonomous System Number (ASN). Must be an RFC6996 private ASN, either 16-bit or 32-bit. The value will be fixed for this router resource. All VPN tunnels that link to this router will have the same local ASN.\n '
return pulumi.get(self, 'asn')
| -9,091,422,312,853,005,000
|
Local BGP Autonomous System Number (ASN). Must be an RFC6996 private ASN, either 16-bit or 32-bit. The value will be fixed for this router resource. All VPN tunnels that link to this router will have the same local ASN.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
asn
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def asn(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'asn')
|
@property
@pulumi.getter(name='keepaliveInterval')
def keepalive_interval(self) -> Optional[pulumi.Input[int]]:
"\n The interval in seconds between BGP keepalive messages that are sent to the peer. Hold time is three times the interval at which keepalive messages are sent, and the hold time is the maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer. BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.\n "
return pulumi.get(self, 'keepalive_interval')
| 3,698,750,580,406,849,500
|
The interval in seconds between BGP keepalive messages that are sent to the peer. Hold time is three times the interval at which keepalive messages are sent, and the hold time is the maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer. BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
keepalive_interval
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='keepaliveInterval')
def keepalive_interval(self) -> Optional[pulumi.Input[int]]:
"\n \n "
return pulumi.get(self, 'keepalive_interval')
|
def __init__(__self__, *, ip_range: Optional[pulumi.Input[str]]=None, linked_interconnect_attachment: Optional[pulumi.Input[str]]=None, linked_vpn_tunnel: Optional[pulumi.Input[str]]=None, name: Optional[pulumi.Input[str]]=None, private_ip_address: Optional[pulumi.Input[str]]=None, redundant_interface: Optional[pulumi.Input[str]]=None, subnetwork: Optional[pulumi.Input[str]]=None):
'\n :param pulumi.Input[str] ip_range: IP address and range of the interface. The IP range must be in the RFC3927 link-local IP address space. The value must be a CIDR-formatted string, for example: 169.254.0.1/30. NOTE: Do not truncate the address as it represents the IP address of the interface.\n :param pulumi.Input[str] linked_interconnect_attachment: URI of the linked Interconnect attachment. It must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.\n :param pulumi.Input[str] linked_vpn_tunnel: URI of the linked VPN tunnel, which must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.\n :param pulumi.Input[str] name: Name of this interface entry. 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]([-a-z0-9]*[a-z0-9])?` 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.\n :param pulumi.Input[str] private_ip_address: The regional private internal IP address that is used to establish BGP sessions to a VM instance acting as a third-party Router Appliance, such as a Next Gen Firewall, a Virtual Router, or an SD-WAN VM.\n :param pulumi.Input[str] redundant_interface: Name of the interface that will be redundant with the current interface you are creating. The redundantInterface must belong to the same Cloud Router as the interface here. To establish the BGP session to a Router Appliance VM, you must create two BGP peers. The two BGP peers must be attached to two separate interfaces that are redundant with each other. The redundant_interface must be 1-63 characters long, and comply with RFC1035. Specifically, the redundant_interface must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` 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.\n :param pulumi.Input[str] subnetwork: The URI of the subnetwork resource that this interface belongs to, which must be in the same region as the Cloud Router. When you establish a BGP session to a VM instance using this interface, the VM instance must belong to the same subnetwork as the subnetwork specified here.\n '
if (ip_range is not None):
pulumi.set(__self__, 'ip_range', ip_range)
if (linked_interconnect_attachment is not None):
pulumi.set(__self__, 'linked_interconnect_attachment', linked_interconnect_attachment)
if (linked_vpn_tunnel is not None):
pulumi.set(__self__, 'linked_vpn_tunnel', linked_vpn_tunnel)
if (name is not None):
pulumi.set(__self__, 'name', name)
if (private_ip_address is not None):
pulumi.set(__self__, 'private_ip_address', private_ip_address)
if (redundant_interface is not None):
pulumi.set(__self__, 'redundant_interface', redundant_interface)
if (subnetwork is not None):
pulumi.set(__self__, 'subnetwork', subnetwork)
| 4,245,033,567,282,725,400
|
:param pulumi.Input[str] ip_range: IP address and range of the interface. The IP range must be in the RFC3927 link-local IP address space. The value must be a CIDR-formatted string, for example: 169.254.0.1/30. NOTE: Do not truncate the address as it represents the IP address of the interface.
:param pulumi.Input[str] linked_interconnect_attachment: URI of the linked Interconnect attachment. It must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.
:param pulumi.Input[str] linked_vpn_tunnel: URI of the linked VPN tunnel, which must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.
:param pulumi.Input[str] name: Name of this interface entry. 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]([-a-z0-9]*[a-z0-9])?` 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.
:param pulumi.Input[str] private_ip_address: The regional private internal IP address that is used to establish BGP sessions to a VM instance acting as a third-party Router Appliance, such as a Next Gen Firewall, a Virtual Router, or an SD-WAN VM.
:param pulumi.Input[str] redundant_interface: Name of the interface that will be redundant with the current interface you are creating. The redundantInterface must belong to the same Cloud Router as the interface here. To establish the BGP session to a Router Appliance VM, you must create two BGP peers. The two BGP peers must be attached to two separate interfaces that are redundant with each other. The redundant_interface must be 1-63 characters long, and comply with RFC1035. Specifically, the redundant_interface must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` 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.
:param pulumi.Input[str] subnetwork: The URI of the subnetwork resource that this interface belongs to, which must be in the same region as the Cloud Router. When you establish a BGP session to a VM instance using this interface, the VM instance must belong to the same subnetwork as the subnetwork specified here.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, ip_range: Optional[pulumi.Input[str]]=None, linked_interconnect_attachment: Optional[pulumi.Input[str]]=None, linked_vpn_tunnel: Optional[pulumi.Input[str]]=None, name: Optional[pulumi.Input[str]]=None, private_ip_address: Optional[pulumi.Input[str]]=None, redundant_interface: Optional[pulumi.Input[str]]=None, subnetwork: Optional[pulumi.Input[str]]=None):
'\n :param pulumi.Input[str] ip_range: IP address and range of the interface. The IP range must be in the RFC3927 link-local IP address space. The value must be a CIDR-formatted string, for example: 169.254.0.1/30. NOTE: Do not truncate the address as it represents the IP address of the interface.\n :param pulumi.Input[str] linked_interconnect_attachment: URI of the linked Interconnect attachment. It must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.\n :param pulumi.Input[str] linked_vpn_tunnel: URI of the linked VPN tunnel, which must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.\n :param pulumi.Input[str] name: Name of this interface entry. 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]([-a-z0-9]*[a-z0-9])?` 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.\n :param pulumi.Input[str] private_ip_address: The regional private internal IP address that is used to establish BGP sessions to a VM instance acting as a third-party Router Appliance, such as a Next Gen Firewall, a Virtual Router, or an SD-WAN VM.\n :param pulumi.Input[str] redundant_interface: Name of the interface that will be redundant with the current interface you are creating. The redundantInterface must belong to the same Cloud Router as the interface here. To establish the BGP session to a Router Appliance VM, you must create two BGP peers. The two BGP peers must be attached to two separate interfaces that are redundant with each other. The redundant_interface must be 1-63 characters long, and comply with RFC1035. Specifically, the redundant_interface must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` 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.\n :param pulumi.Input[str] subnetwork: The URI of the subnetwork resource that this interface belongs to, which must be in the same region as the Cloud Router. When you establish a BGP session to a VM instance using this interface, the VM instance must belong to the same subnetwork as the subnetwork specified here.\n '
if (ip_range is not None):
pulumi.set(__self__, 'ip_range', ip_range)
if (linked_interconnect_attachment is not None):
pulumi.set(__self__, 'linked_interconnect_attachment', linked_interconnect_attachment)
if (linked_vpn_tunnel is not None):
pulumi.set(__self__, 'linked_vpn_tunnel', linked_vpn_tunnel)
if (name is not None):
pulumi.set(__self__, 'name', name)
if (private_ip_address is not None):
pulumi.set(__self__, 'private_ip_address', private_ip_address)
if (redundant_interface is not None):
pulumi.set(__self__, 'redundant_interface', redundant_interface)
if (subnetwork is not None):
pulumi.set(__self__, 'subnetwork', subnetwork)
|
@property
@pulumi.getter(name='ipRange')
def ip_range(self) -> Optional[pulumi.Input[str]]:
'\n IP address and range of the interface. The IP range must be in the RFC3927 link-local IP address space. The value must be a CIDR-formatted string, for example: 169.254.0.1/30. NOTE: Do not truncate the address as it represents the IP address of the interface.\n '
return pulumi.get(self, 'ip_range')
| -6,787,178,637,306,643,000
|
IP address and range of the interface. The IP range must be in the RFC3927 link-local IP address space. The value must be a CIDR-formatted string, for example: 169.254.0.1/30. NOTE: Do not truncate the address as it represents the IP address of the interface.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
ip_range
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='ipRange')
def ip_range(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'ip_range')
|
@property
@pulumi.getter(name='linkedInterconnectAttachment')
def linked_interconnect_attachment(self) -> Optional[pulumi.Input[str]]:
'\n URI of the linked Interconnect attachment. It must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.\n '
return pulumi.get(self, 'linked_interconnect_attachment')
| -4,980,360,089,529,437,000
|
URI of the linked Interconnect attachment. It must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
linked_interconnect_attachment
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='linkedInterconnectAttachment')
def linked_interconnect_attachment(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'linked_interconnect_attachment')
|
@property
@pulumi.getter(name='linkedVpnTunnel')
def linked_vpn_tunnel(self) -> Optional[pulumi.Input[str]]:
'\n URI of the linked VPN tunnel, which must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.\n '
return pulumi.get(self, 'linked_vpn_tunnel')
| 4,601,268,514,029,673,000
|
URI of the linked VPN tunnel, which must be in the same region as the router. Each interface can have one linked resource, which can be a VPN tunnel, an Interconnect attachment, or a virtual machine instance.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
linked_vpn_tunnel
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='linkedVpnTunnel')
def linked_vpn_tunnel(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'linked_vpn_tunnel')
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n Name of this interface entry. 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]([-a-z0-9]*[a-z0-9])?` 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.\n '
return pulumi.get(self, 'name')
| -496,815,607,806,467,460
|
Name of this interface entry. 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]([-a-z0-9]*[a-z0-9])?` 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.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'name')
|
@property
@pulumi.getter(name='privateIpAddress')
def private_ip_address(self) -> Optional[pulumi.Input[str]]:
'\n The regional private internal IP address that is used to establish BGP sessions to a VM instance acting as a third-party Router Appliance, such as a Next Gen Firewall, a Virtual Router, or an SD-WAN VM.\n '
return pulumi.get(self, 'private_ip_address')
| 814,243,173,883,397,400
|
The regional private internal IP address that is used to establish BGP sessions to a VM instance acting as a third-party Router Appliance, such as a Next Gen Firewall, a Virtual Router, or an SD-WAN VM.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
private_ip_address
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='privateIpAddress')
def private_ip_address(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'private_ip_address')
|
@property
@pulumi.getter(name='redundantInterface')
def redundant_interface(self) -> Optional[pulumi.Input[str]]:
'\n Name of the interface that will be redundant with the current interface you are creating. The redundantInterface must belong to the same Cloud Router as the interface here. To establish the BGP session to a Router Appliance VM, you must create two BGP peers. The two BGP peers must be attached to two separate interfaces that are redundant with each other. The redundant_interface must be 1-63 characters long, and comply with RFC1035. Specifically, the redundant_interface must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` 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.\n '
return pulumi.get(self, 'redundant_interface')
| 2,541,051,506,374,571,500
|
Name of the interface that will be redundant with the current interface you are creating. The redundantInterface must belong to the same Cloud Router as the interface here. To establish the BGP session to a Router Appliance VM, you must create two BGP peers. The two BGP peers must be attached to two separate interfaces that are redundant with each other. The redundant_interface must be 1-63 characters long, and comply with RFC1035. Specifically, the redundant_interface must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` 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.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
redundant_interface
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='redundantInterface')
def redundant_interface(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'redundant_interface')
|
@property
@pulumi.getter
def subnetwork(self) -> Optional[pulumi.Input[str]]:
'\n The URI of the subnetwork resource that this interface belongs to, which must be in the same region as the Cloud Router. When you establish a BGP session to a VM instance using this interface, the VM instance must belong to the same subnetwork as the subnetwork specified here.\n '
return pulumi.get(self, 'subnetwork')
| 4,459,182,001,608,221,000
|
The URI of the subnetwork resource that this interface belongs to, which must be in the same region as the Cloud Router. When you establish a BGP session to a VM instance using this interface, the VM instance must belong to the same subnetwork as the subnetwork specified here.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
subnetwork
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def subnetwork(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'subnetwork')
|
def __init__(__self__, *, enable: Optional[pulumi.Input[bool]]=None, filter: Optional[pulumi.Input['RouterNatLogConfigFilter']]=None):
"\n Configuration of logging on a NAT.\n :param pulumi.Input[bool] enable: Indicates whether or not to export logs. This is false by default.\n :param pulumi.Input['RouterNatLogConfigFilter'] filter: Specify the desired filtering of logs on this NAT. If unspecified, logs are exported for all connections handled by this NAT. This option can take one of the following values: - ERRORS_ONLY: Export logs only for connection failures. - TRANSLATIONS_ONLY: Export logs only for successful connections. - ALL: Export logs for all connections, successful and unsuccessful. \n "
if (enable is not None):
pulumi.set(__self__, 'enable', enable)
if (filter is not None):
pulumi.set(__self__, 'filter', filter)
| 3,140,566,783,472,850,400
|
Configuration of logging on a NAT.
:param pulumi.Input[bool] enable: Indicates whether or not to export logs. This is false by default.
:param pulumi.Input['RouterNatLogConfigFilter'] filter: Specify the desired filtering of logs on this NAT. If unspecified, logs are exported for all connections handled by this NAT. This option can take one of the following values: - ERRORS_ONLY: Export logs only for connection failures. - TRANSLATIONS_ONLY: Export logs only for successful connections. - ALL: Export logs for all connections, successful and unsuccessful.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, enable: Optional[pulumi.Input[bool]]=None, filter: Optional[pulumi.Input['RouterNatLogConfigFilter']]=None):
"\n Configuration of logging on a NAT.\n :param pulumi.Input[bool] enable: Indicates whether or not to export logs. This is false by default.\n :param pulumi.Input['RouterNatLogConfigFilter'] filter: Specify the desired filtering of logs on this NAT. If unspecified, logs are exported for all connections handled by this NAT. This option can take one of the following values: - ERRORS_ONLY: Export logs only for connection failures. - TRANSLATIONS_ONLY: Export logs only for successful connections. - ALL: Export logs for all connections, successful and unsuccessful. \n "
if (enable is not None):
pulumi.set(__self__, 'enable', enable)
if (filter is not None):
pulumi.set(__self__, 'filter', filter)
|
@property
@pulumi.getter
def enable(self) -> Optional[pulumi.Input[bool]]:
'\n Indicates whether or not to export logs. This is false by default.\n '
return pulumi.get(self, 'enable')
| -2,715,045,311,775,218,000
|
Indicates whether or not to export logs. This is false by default.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enable
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def enable(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'enable')
|
@property
@pulumi.getter
def filter(self) -> Optional[pulumi.Input['RouterNatLogConfigFilter']]:
'\n Specify the desired filtering of logs on this NAT. If unspecified, logs are exported for all connections handled by this NAT. This option can take one of the following values: - ERRORS_ONLY: Export logs only for connection failures. - TRANSLATIONS_ONLY: Export logs only for successful connections. - ALL: Export logs for all connections, successful and unsuccessful. \n '
return pulumi.get(self, 'filter')
| -2,699,815,122,220,690,400
|
Specify the desired filtering of logs on this NAT. If unspecified, logs are exported for all connections handled by this NAT. This option can take one of the following values: - ERRORS_ONLY: Export logs only for connection failures. - TRANSLATIONS_ONLY: Export logs only for successful connections. - ALL: Export logs for all connections, successful and unsuccessful.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
filter
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def filter(self) -> Optional[pulumi.Input['RouterNatLogConfigFilter']]:
'\n \n '
return pulumi.get(self, 'filter')
|
def __init__(__self__, *, source_nat_active_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_nat_active_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_nat_drain_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_nat_drain_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_active_ips: A list of URLs of the IP resources used for this NAT rule. These IP addresses must be valid static external IP addresses assigned to the project. This field is used for public NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_active_ranges: A list of URLs of the subnetworks used as source ranges for this NAT Rule. These subnetworks must have purpose set to PRIVATE_NAT. This field is used for private NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_drain_ips: A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT rule only. This field is used for public NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_drain_ranges: A list of URLs of subnetworks representing source ranges to be drained. This is only supported on patch/update, and these subnetworks must have previously been used as active ranges in this NAT Rule. This field is used for private NAT.\n '
if (source_nat_active_ips is not None):
pulumi.set(__self__, 'source_nat_active_ips', source_nat_active_ips)
if (source_nat_active_ranges is not None):
pulumi.set(__self__, 'source_nat_active_ranges', source_nat_active_ranges)
if (source_nat_drain_ips is not None):
pulumi.set(__self__, 'source_nat_drain_ips', source_nat_drain_ips)
if (source_nat_drain_ranges is not None):
pulumi.set(__self__, 'source_nat_drain_ranges', source_nat_drain_ranges)
| 4,866,488,087,862,280,000
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_active_ips: A list of URLs of the IP resources used for this NAT rule. These IP addresses must be valid static external IP addresses assigned to the project. This field is used for public NAT.
:param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_active_ranges: A list of URLs of the subnetworks used as source ranges for this NAT Rule. These subnetworks must have purpose set to PRIVATE_NAT. This field is used for private NAT.
:param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_drain_ips: A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT rule only. This field is used for public NAT.
:param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_drain_ranges: A list of URLs of subnetworks representing source ranges to be drained. This is only supported on patch/update, and these subnetworks must have previously been used as active ranges in this NAT Rule. This field is used for private NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, source_nat_active_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_nat_active_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_nat_drain_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_nat_drain_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_active_ips: A list of URLs of the IP resources used for this NAT rule. These IP addresses must be valid static external IP addresses assigned to the project. This field is used for public NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_active_ranges: A list of URLs of the subnetworks used as source ranges for this NAT Rule. These subnetworks must have purpose set to PRIVATE_NAT. This field is used for private NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_drain_ips: A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT rule only. This field is used for public NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] source_nat_drain_ranges: A list of URLs of subnetworks representing source ranges to be drained. This is only supported on patch/update, and these subnetworks must have previously been used as active ranges in this NAT Rule. This field is used for private NAT.\n '
if (source_nat_active_ips is not None):
pulumi.set(__self__, 'source_nat_active_ips', source_nat_active_ips)
if (source_nat_active_ranges is not None):
pulumi.set(__self__, 'source_nat_active_ranges', source_nat_active_ranges)
if (source_nat_drain_ips is not None):
pulumi.set(__self__, 'source_nat_drain_ips', source_nat_drain_ips)
if (source_nat_drain_ranges is not None):
pulumi.set(__self__, 'source_nat_drain_ranges', source_nat_drain_ranges)
|
@property
@pulumi.getter(name='sourceNatActiveIps')
def source_nat_active_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of URLs of the IP resources used for this NAT rule. These IP addresses must be valid static external IP addresses assigned to the project. This field is used for public NAT.\n '
return pulumi.get(self, 'source_nat_active_ips')
| -2,628,174,069,551,930,000
|
A list of URLs of the IP resources used for this NAT rule. These IP addresses must be valid static external IP addresses assigned to the project. This field is used for public NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_nat_active_ips
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceNatActiveIps')
def source_nat_active_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'source_nat_active_ips')
|
@property
@pulumi.getter(name='sourceNatActiveRanges')
def source_nat_active_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of URLs of the subnetworks used as source ranges for this NAT Rule. These subnetworks must have purpose set to PRIVATE_NAT. This field is used for private NAT.\n '
return pulumi.get(self, 'source_nat_active_ranges')
| -7,656,686,445,095,689,000
|
A list of URLs of the subnetworks used as source ranges for this NAT Rule. These subnetworks must have purpose set to PRIVATE_NAT. This field is used for private NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_nat_active_ranges
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceNatActiveRanges')
def source_nat_active_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'source_nat_active_ranges')
|
@property
@pulumi.getter(name='sourceNatDrainIps')
def source_nat_drain_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT rule only. This field is used for public NAT.\n '
return pulumi.get(self, 'source_nat_drain_ips')
| -3,437,297,740,741,811,700
|
A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT rule only. This field is used for public NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_nat_drain_ips
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceNatDrainIps')
def source_nat_drain_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'source_nat_drain_ips')
|
@property
@pulumi.getter(name='sourceNatDrainRanges')
def source_nat_drain_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of URLs of subnetworks representing source ranges to be drained. This is only supported on patch/update, and these subnetworks must have previously been used as active ranges in this NAT Rule. This field is used for private NAT.\n '
return pulumi.get(self, 'source_nat_drain_ranges')
| 6,671,438,718,492,624,000
|
A list of URLs of subnetworks representing source ranges to be drained. This is only supported on patch/update, and these subnetworks must have previously been used as active ranges in this NAT Rule. This field is used for private NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_nat_drain_ranges
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceNatDrainRanges')
def source_nat_drain_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'source_nat_drain_ranges')
|
def __init__(__self__, *, action: Optional[pulumi.Input['RouterNatRuleActionArgs']]=None, description: Optional[pulumi.Input[str]]=None, match: Optional[pulumi.Input[str]]=None, rule_number: Optional[pulumi.Input[int]]=None):
'\n :param pulumi.Input[\'RouterNatRuleActionArgs\'] action: The action to be enforced for traffic that matches this rule.\n :param pulumi.Input[str] description: An optional description of this rule.\n :param pulumi.Input[str] match: CEL expression that specifies the match condition that egress traffic from a VM is evaluated against. If it evaluates to true, the corresponding `action` is enforced. The following examples are valid match expressions for public NAT: "inIpRange(destination.ip, \'1.1.0.0/16\') || inIpRange(destination.ip, \'2.2.0.0/16\')" "destination.ip == \'1.1.0.1\' || destination.ip == \'8.8.8.8\'" The following example is a valid match expression for private NAT: "nexthop.hub == \'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1\'"\n :param pulumi.Input[int] rule_number: An integer uniquely identifying a rule in the list. The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.\n '
if (action is not None):
pulumi.set(__self__, 'action', action)
if (description is not None):
pulumi.set(__self__, 'description', description)
if (match is not None):
pulumi.set(__self__, 'match', match)
if (rule_number is not None):
pulumi.set(__self__, 'rule_number', rule_number)
| 7,519,574,260,378,542,000
|
:param pulumi.Input['RouterNatRuleActionArgs'] action: The action to be enforced for traffic that matches this rule.
:param pulumi.Input[str] description: An optional description of this rule.
:param pulumi.Input[str] match: CEL expression that specifies the match condition that egress traffic from a VM is evaluated against. If it evaluates to true, the corresponding `action` is enforced. The following examples are valid match expressions for public NAT: "inIpRange(destination.ip, '1.1.0.0/16') || inIpRange(destination.ip, '2.2.0.0/16')" "destination.ip == '1.1.0.1' || destination.ip == '8.8.8.8'" The following example is a valid match expression for private NAT: "nexthop.hub == 'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1'"
:param pulumi.Input[int] rule_number: An integer uniquely identifying a rule in the list. The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, action: Optional[pulumi.Input['RouterNatRuleActionArgs']]=None, description: Optional[pulumi.Input[str]]=None, match: Optional[pulumi.Input[str]]=None, rule_number: Optional[pulumi.Input[int]]=None):
'\n :param pulumi.Input[\'RouterNatRuleActionArgs\'] action: The action to be enforced for traffic that matches this rule.\n :param pulumi.Input[str] description: An optional description of this rule.\n :param pulumi.Input[str] match: CEL expression that specifies the match condition that egress traffic from a VM is evaluated against. If it evaluates to true, the corresponding `action` is enforced. The following examples are valid match expressions for public NAT: "inIpRange(destination.ip, \'1.1.0.0/16\') || inIpRange(destination.ip, \'2.2.0.0/16\')" "destination.ip == \'1.1.0.1\' || destination.ip == \'8.8.8.8\'" The following example is a valid match expression for private NAT: "nexthop.hub == \'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1\'"\n :param pulumi.Input[int] rule_number: An integer uniquely identifying a rule in the list. The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.\n '
if (action is not None):
pulumi.set(__self__, 'action', action)
if (description is not None):
pulumi.set(__self__, 'description', description)
if (match is not None):
pulumi.set(__self__, 'match', match)
if (rule_number is not None):
pulumi.set(__self__, 'rule_number', rule_number)
|
@property
@pulumi.getter
def action(self) -> Optional[pulumi.Input['RouterNatRuleActionArgs']]:
'\n The action to be enforced for traffic that matches this rule.\n '
return pulumi.get(self, 'action')
| -1,936,090,919,313,821,000
|
The action to be enforced for traffic that matches this rule.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
action
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def action(self) -> Optional[pulumi.Input['RouterNatRuleActionArgs']]:
'\n \n '
return pulumi.get(self, 'action')
|
@property
@pulumi.getter
def description(self) -> Optional[pulumi.Input[str]]:
'\n An optional description of this rule.\n '
return pulumi.get(self, 'description')
| 971,513,290,712,883,700
|
An optional description of this rule.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
description
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def description(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'description')
|
@property
@pulumi.getter
def match(self) -> Optional[pulumi.Input[str]]:
'\n CEL expression that specifies the match condition that egress traffic from a VM is evaluated against. If it evaluates to true, the corresponding `action` is enforced. The following examples are valid match expressions for public NAT: "inIpRange(destination.ip, \'1.1.0.0/16\') || inIpRange(destination.ip, \'2.2.0.0/16\')" "destination.ip == \'1.1.0.1\' || destination.ip == \'8.8.8.8\'" The following example is a valid match expression for private NAT: "nexthop.hub == \'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1\'"\n '
return pulumi.get(self, 'match')
| -5,752,420,958,762,066,000
|
CEL expression that specifies the match condition that egress traffic from a VM is evaluated against. If it evaluates to true, the corresponding `action` is enforced. The following examples are valid match expressions for public NAT: "inIpRange(destination.ip, '1.1.0.0/16') || inIpRange(destination.ip, '2.2.0.0/16')" "destination.ip == '1.1.0.1' || destination.ip == '8.8.8.8'" The following example is a valid match expression for private NAT: "nexthop.hub == 'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1'"
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
match
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def match(self) -> Optional[pulumi.Input[str]]:
'\n CEL expression that specifies the match condition that egress traffic from a VM is evaluated against. If it evaluates to true, the corresponding `action` is enforced. The following examples are valid match expressions for public NAT: "inIpRange(destination.ip, \'1.1.0.0/16\') || inIpRange(destination.ip, \'2.2.0.0/16\')" "destination.ip == \'1.1.0.1\' || destination.ip == \'8.8.8.8\'" The following example is a valid match expression for private NAT: "nexthop.hub == \'https://networkconnectivity.googleapis.com/v1alpha1/projects/my-project/global/hub/hub-1\'"\n '
return pulumi.get(self, 'match')
|
@property
@pulumi.getter(name='ruleNumber')
def rule_number(self) -> Optional[pulumi.Input[int]]:
'\n An integer uniquely identifying a rule in the list. The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.\n '
return pulumi.get(self, 'rule_number')
| -6,814,629,788,571,208,000
|
An integer uniquely identifying a rule in the list. The rule number must be a positive value between 0 and 65000, and must be unique among rules within a NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
rule_number
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='ruleNumber')
def rule_number(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'rule_number')
|
def __init__(__self__, *, name: Optional[pulumi.Input[str]]=None, secondary_ip_range_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_ip_ranges_to_nat: Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatSourceIpRangesToNatItem']]]]=None):
'\n Defines the IP ranges that want to use NAT for a subnetwork.\n :param pulumi.Input[str] name: URL for the subnetwork resource that will use NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] secondary_ip_range_names: A list of the secondary ranges of the Subnetwork that are allowed to use NAT. This can be populated only if "LIST_OF_SECONDARY_IP_RANGES" is one of the values in source_ip_ranges_to_nat.\n :param pulumi.Input[Sequence[pulumi.Input[\'RouterNatSubnetworkToNatSourceIpRangesToNatItem\']]] source_ip_ranges_to_nat: Specify the options for NAT ranges in the Subnetwork. All options of a single value are valid except NAT_IP_RANGE_OPTION_UNSPECIFIED. The only valid option with multiple values is: ["PRIMARY_IP_RANGE", "LIST_OF_SECONDARY_IP_RANGES"] Default: [ALL_IP_RANGES]\n '
if (name is not None):
pulumi.set(__self__, 'name', name)
if (secondary_ip_range_names is not None):
pulumi.set(__self__, 'secondary_ip_range_names', secondary_ip_range_names)
if (source_ip_ranges_to_nat is not None):
pulumi.set(__self__, 'source_ip_ranges_to_nat', source_ip_ranges_to_nat)
| -8,792,510,397,263,477,000
|
Defines the IP ranges that want to use NAT for a subnetwork.
:param pulumi.Input[str] name: URL for the subnetwork resource that will use NAT.
:param pulumi.Input[Sequence[pulumi.Input[str]]] secondary_ip_range_names: A list of the secondary ranges of the Subnetwork that are allowed to use NAT. This can be populated only if "LIST_OF_SECONDARY_IP_RANGES" is one of the values in source_ip_ranges_to_nat.
:param pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatSourceIpRangesToNatItem']]] source_ip_ranges_to_nat: Specify the options for NAT ranges in the Subnetwork. All options of a single value are valid except NAT_IP_RANGE_OPTION_UNSPECIFIED. The only valid option with multiple values is: ["PRIMARY_IP_RANGE", "LIST_OF_SECONDARY_IP_RANGES"] Default: [ALL_IP_RANGES]
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, name: Optional[pulumi.Input[str]]=None, secondary_ip_range_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, source_ip_ranges_to_nat: Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatSourceIpRangesToNatItem']]]]=None):
'\n Defines the IP ranges that want to use NAT for a subnetwork.\n :param pulumi.Input[str] name: URL for the subnetwork resource that will use NAT.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] secondary_ip_range_names: A list of the secondary ranges of the Subnetwork that are allowed to use NAT. This can be populated only if "LIST_OF_SECONDARY_IP_RANGES" is one of the values in source_ip_ranges_to_nat.\n :param pulumi.Input[Sequence[pulumi.Input[\'RouterNatSubnetworkToNatSourceIpRangesToNatItem\']]] source_ip_ranges_to_nat: Specify the options for NAT ranges in the Subnetwork. All options of a single value are valid except NAT_IP_RANGE_OPTION_UNSPECIFIED. The only valid option with multiple values is: ["PRIMARY_IP_RANGE", "LIST_OF_SECONDARY_IP_RANGES"] Default: [ALL_IP_RANGES]\n '
if (name is not None):
pulumi.set(__self__, 'name', name)
if (secondary_ip_range_names is not None):
pulumi.set(__self__, 'secondary_ip_range_names', secondary_ip_range_names)
if (source_ip_ranges_to_nat is not None):
pulumi.set(__self__, 'source_ip_ranges_to_nat', source_ip_ranges_to_nat)
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n URL for the subnetwork resource that will use NAT.\n '
return pulumi.get(self, 'name')
| -2,831,834,990,770,588,000
|
URL for the subnetwork resource that will use NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'name')
|
@property
@pulumi.getter(name='secondaryIpRangeNames')
def secondary_ip_range_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of the secondary ranges of the Subnetwork that are allowed to use NAT. This can be populated only if "LIST_OF_SECONDARY_IP_RANGES" is one of the values in source_ip_ranges_to_nat.\n '
return pulumi.get(self, 'secondary_ip_range_names')
| -7,040,625,438,611,705,000
|
A list of the secondary ranges of the Subnetwork that are allowed to use NAT. This can be populated only if "LIST_OF_SECONDARY_IP_RANGES" is one of the values in source_ip_ranges_to_nat.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
secondary_ip_range_names
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='secondaryIpRangeNames')
def secondary_ip_range_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'secondary_ip_range_names')
|
@property
@pulumi.getter(name='sourceIpRangesToNat')
def source_ip_ranges_to_nat(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatSourceIpRangesToNatItem']]]]:
'\n Specify the options for NAT ranges in the Subnetwork. All options of a single value are valid except NAT_IP_RANGE_OPTION_UNSPECIFIED. The only valid option with multiple values is: ["PRIMARY_IP_RANGE", "LIST_OF_SECONDARY_IP_RANGES"] Default: [ALL_IP_RANGES]\n '
return pulumi.get(self, 'source_ip_ranges_to_nat')
| -7,852,849,550,570,182,000
|
Specify the options for NAT ranges in the Subnetwork. All options of a single value are valid except NAT_IP_RANGE_OPTION_UNSPECIFIED. The only valid option with multiple values is: ["PRIMARY_IP_RANGE", "LIST_OF_SECONDARY_IP_RANGES"] Default: [ALL_IP_RANGES]
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_ip_ranges_to_nat
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceIpRangesToNat')
def source_ip_ranges_to_nat(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatSourceIpRangesToNatItem']]]]:
'\n \n '
return pulumi.get(self, 'source_ip_ranges_to_nat')
|
def __init__(__self__, *, drain_nat_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, enable_dynamic_port_allocation: Optional[pulumi.Input[bool]]=None, enable_endpoint_independent_mapping: Optional[pulumi.Input[bool]]=None, icmp_idle_timeout_sec: Optional[pulumi.Input[int]]=None, log_config: Optional[pulumi.Input['RouterNatLogConfigArgs']]=None, max_ports_per_vm: Optional[pulumi.Input[int]]=None, min_ports_per_vm: Optional[pulumi.Input[int]]=None, name: Optional[pulumi.Input[str]]=None, nat_ip_allocate_option: Optional[pulumi.Input['RouterNatNatIpAllocateOption']]=None, nat_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, rules: Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]]]=None, source_subnetwork_ip_ranges_to_nat: Optional[pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat']]=None, subnetworks: Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]]]=None, tcp_established_idle_timeout_sec: Optional[pulumi.Input[int]]=None, tcp_time_wait_timeout_sec: Optional[pulumi.Input[int]]=None, tcp_transitory_idle_timeout_sec: Optional[pulumi.Input[int]]=None, type: Optional[pulumi.Input['RouterNatType']]=None, udp_idle_timeout_sec: Optional[pulumi.Input[int]]=None):
"\n Represents a Nat resource. It enables the VMs within the specified subnetworks to access Internet without external IP addresses. It specifies a list of subnetworks (and the ranges within) that want to use NAT. Customers can also provide the external IPs that would be used for NAT. GCP would auto-allocate ephemeral IPs if no external IPs are provided.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] drain_nat_ips: A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT only.\n :param pulumi.Input[bool] enable_dynamic_port_allocation: Enable Dynamic Port Allocation. If not specified, it is disabled by default. If set to true, - Dynamic Port Allocation will be enabled on this NAT config. - enableEndpointIndependentMapping cannot be set to true. - If minPorts is set, minPortsPerVm must be set to a power of two greater than or equal to 32. If minPortsPerVm is not set, a minimum of 32 ports will be allocated to a VM from this NAT config. \n :param pulumi.Input[int] icmp_idle_timeout_sec: Timeout (in seconds) for ICMP connections. Defaults to 30s if not set.\n :param pulumi.Input['RouterNatLogConfigArgs'] log_config: Configure logging on this NAT.\n :param pulumi.Input[int] max_ports_per_vm: Maximum number of ports allocated to a VM from this NAT config when Dynamic Port Allocation is enabled. If Dynamic Port Allocation is not enabled, this field has no effect. If Dynamic Port Allocation is enabled, and this field is set, it must be set to a power of two greater than minPortsPerVm, or 64 if minPortsPerVm is not set. If Dynamic Port Allocation is enabled and this field is not set, a maximum of 65536 ports will be allocated to a VM from this NAT config.\n :param pulumi.Input[int] min_ports_per_vm: Minimum number of ports allocated to a VM from this NAT config. If not set, a default number of ports is allocated to a VM. This is rounded up to the nearest power of 2. For example, if the value of this field is 50, at least 64 ports are allocated to a VM.\n :param pulumi.Input[str] name: Unique name of this Nat service. The name must be 1-63 characters long and comply with RFC1035.\n :param pulumi.Input['RouterNatNatIpAllocateOption'] nat_ip_allocate_option: Specify the NatIpAllocateOption, which can take one of the following values: - MANUAL_ONLY: Uses only Nat IP addresses provided by customers. When there are not enough specified Nat IPs, the Nat service fails for new VMs. - AUTO_ONLY: Nat IPs are allocated by Google Cloud Platform; customers can't specify any Nat IPs. When choosing AUTO_ONLY, then nat_ip should be empty. \n :param pulumi.Input[Sequence[pulumi.Input[str]]] nat_ips: A list of URLs of the IP resources used for this Nat service. These IP addresses must be valid static external IP addresses assigned to the project.\n :param pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]] rules: A list of rules associated with this NAT.\n :param pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat'] source_subnetwork_ip_ranges_to_nat: Specify the Nat option, which can take one of the following values: - ALL_SUBNETWORKS_ALL_IP_RANGES: All of the IP ranges in every Subnetwork are allowed to Nat. - ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES: All of the primary IP ranges in every Subnetwork are allowed to Nat. - LIST_OF_SUBNETWORKS: A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) The default is SUBNETWORK_IP_RANGE_TO_NAT_OPTION_UNSPECIFIED. Note that if this field contains ALL_SUBNETWORKS_ALL_IP_RANGES or ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES, then there should not be any other Router.Nat section in any Router for this network in this region.\n :param pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]] subnetworks: A list of Subnetwork resources whose traffic should be translated by NAT Gateway. It is used only when LIST_OF_SUBNETWORKS is selected for the SubnetworkIpRangeToNatOption above.\n :param pulumi.Input[int] tcp_established_idle_timeout_sec: Timeout (in seconds) for TCP established connections. Defaults to 1200s if not set.\n :param pulumi.Input[int] tcp_time_wait_timeout_sec: Timeout (in seconds) for TCP connections that are in TIME_WAIT state. Defaults to 120s if not set.\n :param pulumi.Input[int] tcp_transitory_idle_timeout_sec: Timeout (in seconds) for TCP transitory connections. Defaults to 30s if not set.\n :param pulumi.Input['RouterNatType'] type: Indicates whether this NAT is used for public or private IP translation. If unspecified, it defaults to PUBLIC.\n :param pulumi.Input[int] udp_idle_timeout_sec: Timeout (in seconds) for UDP connections. Defaults to 30s if not set.\n "
if (drain_nat_ips is not None):
pulumi.set(__self__, 'drain_nat_ips', drain_nat_ips)
if (enable_dynamic_port_allocation is not None):
pulumi.set(__self__, 'enable_dynamic_port_allocation', enable_dynamic_port_allocation)
if (enable_endpoint_independent_mapping is not None):
pulumi.set(__self__, 'enable_endpoint_independent_mapping', enable_endpoint_independent_mapping)
if (icmp_idle_timeout_sec is not None):
pulumi.set(__self__, 'icmp_idle_timeout_sec', icmp_idle_timeout_sec)
if (log_config is not None):
pulumi.set(__self__, 'log_config', log_config)
if (max_ports_per_vm is not None):
pulumi.set(__self__, 'max_ports_per_vm', max_ports_per_vm)
if (min_ports_per_vm is not None):
pulumi.set(__self__, 'min_ports_per_vm', min_ports_per_vm)
if (name is not None):
pulumi.set(__self__, 'name', name)
if (nat_ip_allocate_option is not None):
pulumi.set(__self__, 'nat_ip_allocate_option', nat_ip_allocate_option)
if (nat_ips is not None):
pulumi.set(__self__, 'nat_ips', nat_ips)
if (rules is not None):
pulumi.set(__self__, 'rules', rules)
if (source_subnetwork_ip_ranges_to_nat is not None):
pulumi.set(__self__, 'source_subnetwork_ip_ranges_to_nat', source_subnetwork_ip_ranges_to_nat)
if (subnetworks is not None):
pulumi.set(__self__, 'subnetworks', subnetworks)
if (tcp_established_idle_timeout_sec is not None):
pulumi.set(__self__, 'tcp_established_idle_timeout_sec', tcp_established_idle_timeout_sec)
if (tcp_time_wait_timeout_sec is not None):
pulumi.set(__self__, 'tcp_time_wait_timeout_sec', tcp_time_wait_timeout_sec)
if (tcp_transitory_idle_timeout_sec is not None):
pulumi.set(__self__, 'tcp_transitory_idle_timeout_sec', tcp_transitory_idle_timeout_sec)
if (type is not None):
pulumi.set(__self__, 'type', type)
if (udp_idle_timeout_sec is not None):
pulumi.set(__self__, 'udp_idle_timeout_sec', udp_idle_timeout_sec)
| -5,636,303,622,563,892,000
|
Represents a Nat resource. It enables the VMs within the specified subnetworks to access Internet without external IP addresses. It specifies a list of subnetworks (and the ranges within) that want to use NAT. Customers can also provide the external IPs that would be used for NAT. GCP would auto-allocate ephemeral IPs if no external IPs are provided.
:param pulumi.Input[Sequence[pulumi.Input[str]]] drain_nat_ips: A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT only.
:param pulumi.Input[bool] enable_dynamic_port_allocation: Enable Dynamic Port Allocation. If not specified, it is disabled by default. If set to true, - Dynamic Port Allocation will be enabled on this NAT config. - enableEndpointIndependentMapping cannot be set to true. - If minPorts is set, minPortsPerVm must be set to a power of two greater than or equal to 32. If minPortsPerVm is not set, a minimum of 32 ports will be allocated to a VM from this NAT config.
:param pulumi.Input[int] icmp_idle_timeout_sec: Timeout (in seconds) for ICMP connections. Defaults to 30s if not set.
:param pulumi.Input['RouterNatLogConfigArgs'] log_config: Configure logging on this NAT.
:param pulumi.Input[int] max_ports_per_vm: Maximum number of ports allocated to a VM from this NAT config when Dynamic Port Allocation is enabled. If Dynamic Port Allocation is not enabled, this field has no effect. If Dynamic Port Allocation is enabled, and this field is set, it must be set to a power of two greater than minPortsPerVm, or 64 if minPortsPerVm is not set. If Dynamic Port Allocation is enabled and this field is not set, a maximum of 65536 ports will be allocated to a VM from this NAT config.
:param pulumi.Input[int] min_ports_per_vm: Minimum number of ports allocated to a VM from this NAT config. If not set, a default number of ports is allocated to a VM. This is rounded up to the nearest power of 2. For example, if the value of this field is 50, at least 64 ports are allocated to a VM.
:param pulumi.Input[str] name: Unique name of this Nat service. The name must be 1-63 characters long and comply with RFC1035.
:param pulumi.Input['RouterNatNatIpAllocateOption'] nat_ip_allocate_option: Specify the NatIpAllocateOption, which can take one of the following values: - MANUAL_ONLY: Uses only Nat IP addresses provided by customers. When there are not enough specified Nat IPs, the Nat service fails for new VMs. - AUTO_ONLY: Nat IPs are allocated by Google Cloud Platform; customers can't specify any Nat IPs. When choosing AUTO_ONLY, then nat_ip should be empty.
:param pulumi.Input[Sequence[pulumi.Input[str]]] nat_ips: A list of URLs of the IP resources used for this Nat service. These IP addresses must be valid static external IP addresses assigned to the project.
:param pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]] rules: A list of rules associated with this NAT.
:param pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat'] source_subnetwork_ip_ranges_to_nat: Specify the Nat option, which can take one of the following values: - ALL_SUBNETWORKS_ALL_IP_RANGES: All of the IP ranges in every Subnetwork are allowed to Nat. - ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES: All of the primary IP ranges in every Subnetwork are allowed to Nat. - LIST_OF_SUBNETWORKS: A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) The default is SUBNETWORK_IP_RANGE_TO_NAT_OPTION_UNSPECIFIED. Note that if this field contains ALL_SUBNETWORKS_ALL_IP_RANGES or ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES, then there should not be any other Router.Nat section in any Router for this network in this region.
:param pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]] subnetworks: A list of Subnetwork resources whose traffic should be translated by NAT Gateway. It is used only when LIST_OF_SUBNETWORKS is selected for the SubnetworkIpRangeToNatOption above.
:param pulumi.Input[int] tcp_established_idle_timeout_sec: Timeout (in seconds) for TCP established connections. Defaults to 1200s if not set.
:param pulumi.Input[int] tcp_time_wait_timeout_sec: Timeout (in seconds) for TCP connections that are in TIME_WAIT state. Defaults to 120s if not set.
:param pulumi.Input[int] tcp_transitory_idle_timeout_sec: Timeout (in seconds) for TCP transitory connections. Defaults to 30s if not set.
:param pulumi.Input['RouterNatType'] type: Indicates whether this NAT is used for public or private IP translation. If unspecified, it defaults to PUBLIC.
:param pulumi.Input[int] udp_idle_timeout_sec: Timeout (in seconds) for UDP connections. Defaults to 30s if not set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, drain_nat_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, enable_dynamic_port_allocation: Optional[pulumi.Input[bool]]=None, enable_endpoint_independent_mapping: Optional[pulumi.Input[bool]]=None, icmp_idle_timeout_sec: Optional[pulumi.Input[int]]=None, log_config: Optional[pulumi.Input['RouterNatLogConfigArgs']]=None, max_ports_per_vm: Optional[pulumi.Input[int]]=None, min_ports_per_vm: Optional[pulumi.Input[int]]=None, name: Optional[pulumi.Input[str]]=None, nat_ip_allocate_option: Optional[pulumi.Input['RouterNatNatIpAllocateOption']]=None, nat_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, rules: Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]]]=None, source_subnetwork_ip_ranges_to_nat: Optional[pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat']]=None, subnetworks: Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]]]=None, tcp_established_idle_timeout_sec: Optional[pulumi.Input[int]]=None, tcp_time_wait_timeout_sec: Optional[pulumi.Input[int]]=None, tcp_transitory_idle_timeout_sec: Optional[pulumi.Input[int]]=None, type: Optional[pulumi.Input['RouterNatType']]=None, udp_idle_timeout_sec: Optional[pulumi.Input[int]]=None):
"\n Represents a Nat resource. It enables the VMs within the specified subnetworks to access Internet without external IP addresses. It specifies a list of subnetworks (and the ranges within) that want to use NAT. Customers can also provide the external IPs that would be used for NAT. GCP would auto-allocate ephemeral IPs if no external IPs are provided.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] drain_nat_ips: A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT only.\n :param pulumi.Input[bool] enable_dynamic_port_allocation: Enable Dynamic Port Allocation. If not specified, it is disabled by default. If set to true, - Dynamic Port Allocation will be enabled on this NAT config. - enableEndpointIndependentMapping cannot be set to true. - If minPorts is set, minPortsPerVm must be set to a power of two greater than or equal to 32. If minPortsPerVm is not set, a minimum of 32 ports will be allocated to a VM from this NAT config. \n :param pulumi.Input[int] icmp_idle_timeout_sec: Timeout (in seconds) for ICMP connections. Defaults to 30s if not set.\n :param pulumi.Input['RouterNatLogConfigArgs'] log_config: Configure logging on this NAT.\n :param pulumi.Input[int] max_ports_per_vm: Maximum number of ports allocated to a VM from this NAT config when Dynamic Port Allocation is enabled. If Dynamic Port Allocation is not enabled, this field has no effect. If Dynamic Port Allocation is enabled, and this field is set, it must be set to a power of two greater than minPortsPerVm, or 64 if minPortsPerVm is not set. If Dynamic Port Allocation is enabled and this field is not set, a maximum of 65536 ports will be allocated to a VM from this NAT config.\n :param pulumi.Input[int] min_ports_per_vm: Minimum number of ports allocated to a VM from this NAT config. If not set, a default number of ports is allocated to a VM. This is rounded up to the nearest power of 2. For example, if the value of this field is 50, at least 64 ports are allocated to a VM.\n :param pulumi.Input[str] name: Unique name of this Nat service. The name must be 1-63 characters long and comply with RFC1035.\n :param pulumi.Input['RouterNatNatIpAllocateOption'] nat_ip_allocate_option: Specify the NatIpAllocateOption, which can take one of the following values: - MANUAL_ONLY: Uses only Nat IP addresses provided by customers. When there are not enough specified Nat IPs, the Nat service fails for new VMs. - AUTO_ONLY: Nat IPs are allocated by Google Cloud Platform; customers can't specify any Nat IPs. When choosing AUTO_ONLY, then nat_ip should be empty. \n :param pulumi.Input[Sequence[pulumi.Input[str]]] nat_ips: A list of URLs of the IP resources used for this Nat service. These IP addresses must be valid static external IP addresses assigned to the project.\n :param pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]] rules: A list of rules associated with this NAT.\n :param pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat'] source_subnetwork_ip_ranges_to_nat: Specify the Nat option, which can take one of the following values: - ALL_SUBNETWORKS_ALL_IP_RANGES: All of the IP ranges in every Subnetwork are allowed to Nat. - ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES: All of the primary IP ranges in every Subnetwork are allowed to Nat. - LIST_OF_SUBNETWORKS: A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) The default is SUBNETWORK_IP_RANGE_TO_NAT_OPTION_UNSPECIFIED. Note that if this field contains ALL_SUBNETWORKS_ALL_IP_RANGES or ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES, then there should not be any other Router.Nat section in any Router for this network in this region.\n :param pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]] subnetworks: A list of Subnetwork resources whose traffic should be translated by NAT Gateway. It is used only when LIST_OF_SUBNETWORKS is selected for the SubnetworkIpRangeToNatOption above.\n :param pulumi.Input[int] tcp_established_idle_timeout_sec: Timeout (in seconds) for TCP established connections. Defaults to 1200s if not set.\n :param pulumi.Input[int] tcp_time_wait_timeout_sec: Timeout (in seconds) for TCP connections that are in TIME_WAIT state. Defaults to 120s if not set.\n :param pulumi.Input[int] tcp_transitory_idle_timeout_sec: Timeout (in seconds) for TCP transitory connections. Defaults to 30s if not set.\n :param pulumi.Input['RouterNatType'] type: Indicates whether this NAT is used for public or private IP translation. If unspecified, it defaults to PUBLIC.\n :param pulumi.Input[int] udp_idle_timeout_sec: Timeout (in seconds) for UDP connections. Defaults to 30s if not set.\n "
if (drain_nat_ips is not None):
pulumi.set(__self__, 'drain_nat_ips', drain_nat_ips)
if (enable_dynamic_port_allocation is not None):
pulumi.set(__self__, 'enable_dynamic_port_allocation', enable_dynamic_port_allocation)
if (enable_endpoint_independent_mapping is not None):
pulumi.set(__self__, 'enable_endpoint_independent_mapping', enable_endpoint_independent_mapping)
if (icmp_idle_timeout_sec is not None):
pulumi.set(__self__, 'icmp_idle_timeout_sec', icmp_idle_timeout_sec)
if (log_config is not None):
pulumi.set(__self__, 'log_config', log_config)
if (max_ports_per_vm is not None):
pulumi.set(__self__, 'max_ports_per_vm', max_ports_per_vm)
if (min_ports_per_vm is not None):
pulumi.set(__self__, 'min_ports_per_vm', min_ports_per_vm)
if (name is not None):
pulumi.set(__self__, 'name', name)
if (nat_ip_allocate_option is not None):
pulumi.set(__self__, 'nat_ip_allocate_option', nat_ip_allocate_option)
if (nat_ips is not None):
pulumi.set(__self__, 'nat_ips', nat_ips)
if (rules is not None):
pulumi.set(__self__, 'rules', rules)
if (source_subnetwork_ip_ranges_to_nat is not None):
pulumi.set(__self__, 'source_subnetwork_ip_ranges_to_nat', source_subnetwork_ip_ranges_to_nat)
if (subnetworks is not None):
pulumi.set(__self__, 'subnetworks', subnetworks)
if (tcp_established_idle_timeout_sec is not None):
pulumi.set(__self__, 'tcp_established_idle_timeout_sec', tcp_established_idle_timeout_sec)
if (tcp_time_wait_timeout_sec is not None):
pulumi.set(__self__, 'tcp_time_wait_timeout_sec', tcp_time_wait_timeout_sec)
if (tcp_transitory_idle_timeout_sec is not None):
pulumi.set(__self__, 'tcp_transitory_idle_timeout_sec', tcp_transitory_idle_timeout_sec)
if (type is not None):
pulumi.set(__self__, 'type', type)
if (udp_idle_timeout_sec is not None):
pulumi.set(__self__, 'udp_idle_timeout_sec', udp_idle_timeout_sec)
|
@property
@pulumi.getter(name='drainNatIps')
def drain_nat_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT only.\n '
return pulumi.get(self, 'drain_nat_ips')
| -5,878,189,624,190,387,000
|
A list of URLs of the IP resources to be drained. These IPs must be valid static external IPs that have been assigned to the NAT. These IPs should be used for updating/patching a NAT only.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
drain_nat_ips
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='drainNatIps')
def drain_nat_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'drain_nat_ips')
|
@property
@pulumi.getter(name='enableDynamicPortAllocation')
def enable_dynamic_port_allocation(self) -> Optional[pulumi.Input[bool]]:
'\n Enable Dynamic Port Allocation. If not specified, it is disabled by default. If set to true, - Dynamic Port Allocation will be enabled on this NAT config. - enableEndpointIndependentMapping cannot be set to true. - If minPorts is set, minPortsPerVm must be set to a power of two greater than or equal to 32. If minPortsPerVm is not set, a minimum of 32 ports will be allocated to a VM from this NAT config. \n '
return pulumi.get(self, 'enable_dynamic_port_allocation')
| 1,161,900,052,798,609,400
|
Enable Dynamic Port Allocation. If not specified, it is disabled by default. If set to true, - Dynamic Port Allocation will be enabled on this NAT config. - enableEndpointIndependentMapping cannot be set to true. - If minPorts is set, minPortsPerVm must be set to a power of two greater than or equal to 32. If minPortsPerVm is not set, a minimum of 32 ports will be allocated to a VM from this NAT config.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enable_dynamic_port_allocation
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='enableDynamicPortAllocation')
def enable_dynamic_port_allocation(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'enable_dynamic_port_allocation')
|
@property
@pulumi.getter(name='icmpIdleTimeoutSec')
def icmp_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Timeout (in seconds) for ICMP connections. Defaults to 30s if not set.\n '
return pulumi.get(self, 'icmp_idle_timeout_sec')
| 8,039,146,417,379,173,000
|
Timeout (in seconds) for ICMP connections. Defaults to 30s if not set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
icmp_idle_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='icmpIdleTimeoutSec')
def icmp_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'icmp_idle_timeout_sec')
|
@property
@pulumi.getter(name='logConfig')
def log_config(self) -> Optional[pulumi.Input['RouterNatLogConfigArgs']]:
'\n Configure logging on this NAT.\n '
return pulumi.get(self, 'log_config')
| -4,460,420,049,438,829,600
|
Configure logging on this NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
log_config
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='logConfig')
def log_config(self) -> Optional[pulumi.Input['RouterNatLogConfigArgs']]:
'\n \n '
return pulumi.get(self, 'log_config')
|
@property
@pulumi.getter(name='maxPortsPerVm')
def max_ports_per_vm(self) -> Optional[pulumi.Input[int]]:
'\n Maximum number of ports allocated to a VM from this NAT config when Dynamic Port Allocation is enabled. If Dynamic Port Allocation is not enabled, this field has no effect. If Dynamic Port Allocation is enabled, and this field is set, it must be set to a power of two greater than minPortsPerVm, or 64 if minPortsPerVm is not set. If Dynamic Port Allocation is enabled and this field is not set, a maximum of 65536 ports will be allocated to a VM from this NAT config.\n '
return pulumi.get(self, 'max_ports_per_vm')
| -6,772,637,938,642,619,000
|
Maximum number of ports allocated to a VM from this NAT config when Dynamic Port Allocation is enabled. If Dynamic Port Allocation is not enabled, this field has no effect. If Dynamic Port Allocation is enabled, and this field is set, it must be set to a power of two greater than minPortsPerVm, or 64 if minPortsPerVm is not set. If Dynamic Port Allocation is enabled and this field is not set, a maximum of 65536 ports will be allocated to a VM from this NAT config.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_ports_per_vm
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxPortsPerVm')
def max_ports_per_vm(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_ports_per_vm')
|
@property
@pulumi.getter(name='minPortsPerVm')
def min_ports_per_vm(self) -> Optional[pulumi.Input[int]]:
'\n Minimum number of ports allocated to a VM from this NAT config. If not set, a default number of ports is allocated to a VM. This is rounded up to the nearest power of 2. For example, if the value of this field is 50, at least 64 ports are allocated to a VM.\n '
return pulumi.get(self, 'min_ports_per_vm')
| -5,344,407,459,660,418,000
|
Minimum number of ports allocated to a VM from this NAT config. If not set, a default number of ports is allocated to a VM. This is rounded up to the nearest power of 2. For example, if the value of this field is 50, at least 64 ports are allocated to a VM.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
min_ports_per_vm
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='minPortsPerVm')
def min_ports_per_vm(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'min_ports_per_vm')
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n Unique name of this Nat service. The name must be 1-63 characters long and comply with RFC1035.\n '
return pulumi.get(self, 'name')
| -7,420,344,901,635,800,000
|
Unique name of this Nat service. The name must be 1-63 characters long and comply with RFC1035.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'name')
|
@property
@pulumi.getter(name='natIpAllocateOption')
def nat_ip_allocate_option(self) -> Optional[pulumi.Input['RouterNatNatIpAllocateOption']]:
"\n Specify the NatIpAllocateOption, which can take one of the following values: - MANUAL_ONLY: Uses only Nat IP addresses provided by customers. When there are not enough specified Nat IPs, the Nat service fails for new VMs. - AUTO_ONLY: Nat IPs are allocated by Google Cloud Platform; customers can't specify any Nat IPs. When choosing AUTO_ONLY, then nat_ip should be empty. \n "
return pulumi.get(self, 'nat_ip_allocate_option')
| 3,740,261,712,209,230,000
|
Specify the NatIpAllocateOption, which can take one of the following values: - MANUAL_ONLY: Uses only Nat IP addresses provided by customers. When there are not enough specified Nat IPs, the Nat service fails for new VMs. - AUTO_ONLY: Nat IPs are allocated by Google Cloud Platform; customers can't specify any Nat IPs. When choosing AUTO_ONLY, then nat_ip should be empty.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
nat_ip_allocate_option
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='natIpAllocateOption')
def nat_ip_allocate_option(self) -> Optional[pulumi.Input['RouterNatNatIpAllocateOption']]:
"\n \n "
return pulumi.get(self, 'nat_ip_allocate_option')
|
@property
@pulumi.getter(name='natIps')
def nat_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n A list of URLs of the IP resources used for this Nat service. These IP addresses must be valid static external IP addresses assigned to the project.\n '
return pulumi.get(self, 'nat_ips')
| 1,976,691,138,817,289,200
|
A list of URLs of the IP resources used for this Nat service. These IP addresses must be valid static external IP addresses assigned to the project.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
nat_ips
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='natIps')
def nat_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'nat_ips')
|
@property
@pulumi.getter
def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]]]:
'\n A list of rules associated with this NAT.\n '
return pulumi.get(self, 'rules')
| -8,326,606,250,769,778,000
|
A list of rules associated with this NAT.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
rules
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatRuleArgs']]]]:
'\n \n '
return pulumi.get(self, 'rules')
|
@property
@pulumi.getter(name='sourceSubnetworkIpRangesToNat')
def source_subnetwork_ip_ranges_to_nat(self) -> Optional[pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat']]:
'\n Specify the Nat option, which can take one of the following values: - ALL_SUBNETWORKS_ALL_IP_RANGES: All of the IP ranges in every Subnetwork are allowed to Nat. - ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES: All of the primary IP ranges in every Subnetwork are allowed to Nat. - LIST_OF_SUBNETWORKS: A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) The default is SUBNETWORK_IP_RANGE_TO_NAT_OPTION_UNSPECIFIED. Note that if this field contains ALL_SUBNETWORKS_ALL_IP_RANGES or ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES, then there should not be any other Router.Nat section in any Router for this network in this region.\n '
return pulumi.get(self, 'source_subnetwork_ip_ranges_to_nat')
| -1,695,776,336,979,387,100
|
Specify the Nat option, which can take one of the following values: - ALL_SUBNETWORKS_ALL_IP_RANGES: All of the IP ranges in every Subnetwork are allowed to Nat. - ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES: All of the primary IP ranges in every Subnetwork are allowed to Nat. - LIST_OF_SUBNETWORKS: A list of Subnetworks are allowed to Nat (specified in the field subnetwork below) The default is SUBNETWORK_IP_RANGE_TO_NAT_OPTION_UNSPECIFIED. Note that if this field contains ALL_SUBNETWORKS_ALL_IP_RANGES or ALL_SUBNETWORKS_ALL_PRIMARY_IP_RANGES, then there should not be any other Router.Nat section in any Router for this network in this region.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_subnetwork_ip_ranges_to_nat
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceSubnetworkIpRangesToNat')
def source_subnetwork_ip_ranges_to_nat(self) -> Optional[pulumi.Input['RouterNatSourceSubnetworkIpRangesToNat']]:
'\n \n '
return pulumi.get(self, 'source_subnetwork_ip_ranges_to_nat')
|
@property
@pulumi.getter
def subnetworks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]]]:
'\n A list of Subnetwork resources whose traffic should be translated by NAT Gateway. It is used only when LIST_OF_SUBNETWORKS is selected for the SubnetworkIpRangeToNatOption above.\n '
return pulumi.get(self, 'subnetworks')
| -3,795,839,003,035,363,000
|
A list of Subnetwork resources whose traffic should be translated by NAT Gateway. It is used only when LIST_OF_SUBNETWORKS is selected for the SubnetworkIpRangeToNatOption above.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
subnetworks
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def subnetworks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterNatSubnetworkToNatArgs']]]]:
'\n \n '
return pulumi.get(self, 'subnetworks')
|
@property
@pulumi.getter(name='tcpEstablishedIdleTimeoutSec')
def tcp_established_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Timeout (in seconds) for TCP established connections. Defaults to 1200s if not set.\n '
return pulumi.get(self, 'tcp_established_idle_timeout_sec')
| -2,384,358,366,014,408,700
|
Timeout (in seconds) for TCP established connections. Defaults to 1200s if not set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
tcp_established_idle_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='tcpEstablishedIdleTimeoutSec')
def tcp_established_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'tcp_established_idle_timeout_sec')
|
@property
@pulumi.getter(name='tcpTimeWaitTimeoutSec')
def tcp_time_wait_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Timeout (in seconds) for TCP connections that are in TIME_WAIT state. Defaults to 120s if not set.\n '
return pulumi.get(self, 'tcp_time_wait_timeout_sec')
| -849,532,242,647,316,100
|
Timeout (in seconds) for TCP connections that are in TIME_WAIT state. Defaults to 120s if not set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
tcp_time_wait_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='tcpTimeWaitTimeoutSec')
def tcp_time_wait_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'tcp_time_wait_timeout_sec')
|
@property
@pulumi.getter(name='tcpTransitoryIdleTimeoutSec')
def tcp_transitory_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Timeout (in seconds) for TCP transitory connections. Defaults to 30s if not set.\n '
return pulumi.get(self, 'tcp_transitory_idle_timeout_sec')
| -7,636,423,792,874,004,000
|
Timeout (in seconds) for TCP transitory connections. Defaults to 30s if not set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
tcp_transitory_idle_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='tcpTransitoryIdleTimeoutSec')
def tcp_transitory_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'tcp_transitory_idle_timeout_sec')
|
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input['RouterNatType']]:
'\n Indicates whether this NAT is used for public or private IP translation. If unspecified, it defaults to PUBLIC.\n '
return pulumi.get(self, 'type')
| -9,120,737,859,185,580,000
|
Indicates whether this NAT is used for public or private IP translation. If unspecified, it defaults to PUBLIC.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
type
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def type(self) -> Optional[pulumi.Input['RouterNatType']]:
'\n \n '
return pulumi.get(self, 'type')
|
@property
@pulumi.getter(name='udpIdleTimeoutSec')
def udp_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Timeout (in seconds) for UDP connections. Defaults to 30s if not set.\n '
return pulumi.get(self, 'udp_idle_timeout_sec')
| -7,461,310,452,382,491,000
|
Timeout (in seconds) for UDP connections. Defaults to 30s if not set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
udp_idle_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='udpIdleTimeoutSec')
def udp_idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'udp_idle_timeout_sec')
|
def __init__(__self__, *, action: Optional[pulumi.Input['RuleAction']]=None, conditions: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]]=None, description: Optional[pulumi.Input[str]]=None, ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, log_configs: Optional[pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]]]=None, not_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, permissions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n This is deprecated and has no effect. Do not use.\n :param pulumi.Input['RuleAction'] action: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]] conditions: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[str] description: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] ins: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]] log_configs: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] not_ins: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] permissions: This is deprecated and has no effect. Do not use.\n "
if (action is not None):
pulumi.set(__self__, 'action', action)
if (conditions is not None):
pulumi.set(__self__, 'conditions', conditions)
if (description is not None):
pulumi.set(__self__, 'description', description)
if (ins is not None):
pulumi.set(__self__, 'ins', ins)
if (log_configs is not None):
pulumi.set(__self__, 'log_configs', log_configs)
if (not_ins is not None):
pulumi.set(__self__, 'not_ins', not_ins)
if (permissions is not None):
pulumi.set(__self__, 'permissions', permissions)
| 1,227,554,893,652,110,600
|
This is deprecated and has no effect. Do not use.
:param pulumi.Input['RuleAction'] action: This is deprecated and has no effect. Do not use.
:param pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]] conditions: This is deprecated and has no effect. Do not use.
:param pulumi.Input[str] description: This is deprecated and has no effect. Do not use.
:param pulumi.Input[Sequence[pulumi.Input[str]]] ins: This is deprecated and has no effect. Do not use.
:param pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]] log_configs: This is deprecated and has no effect. Do not use.
:param pulumi.Input[Sequence[pulumi.Input[str]]] not_ins: This is deprecated and has no effect. Do not use.
:param pulumi.Input[Sequence[pulumi.Input[str]]] permissions: This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, action: Optional[pulumi.Input['RuleAction']]=None, conditions: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]]=None, description: Optional[pulumi.Input[str]]=None, ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, log_configs: Optional[pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]]]=None, not_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, permissions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n This is deprecated and has no effect. Do not use.\n :param pulumi.Input['RuleAction'] action: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]] conditions: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[str] description: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] ins: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]] log_configs: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] not_ins: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] permissions: This is deprecated and has no effect. Do not use.\n "
if (action is not None):
pulumi.set(__self__, 'action', action)
if (conditions is not None):
pulumi.set(__self__, 'conditions', conditions)
if (description is not None):
pulumi.set(__self__, 'description', description)
if (ins is not None):
pulumi.set(__self__, 'ins', ins)
if (log_configs is not None):
pulumi.set(__self__, 'log_configs', log_configs)
if (not_ins is not None):
pulumi.set(__self__, 'not_ins', not_ins)
if (permissions is not None):
pulumi.set(__self__, 'permissions', permissions)
|
@property
@pulumi.getter
def action(self) -> Optional[pulumi.Input['RuleAction']]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'action')
| 6,830,838,082,035,949,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
action
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def action(self) -> Optional[pulumi.Input['RuleAction']]:
'\n \n '
return pulumi.get(self, 'action')
|
@property
@pulumi.getter
def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'conditions')
| 575,429,536,344,870,600
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
conditions
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConditionArgs']]]]:
'\n \n '
return pulumi.get(self, 'conditions')
|
@property
@pulumi.getter
def description(self) -> Optional[pulumi.Input[str]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'description')
| -7,536,398,630,613,299,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
description
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def description(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'description')
|
@property
@pulumi.getter
def ins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'ins')
| -6,447,770,915,347,703,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
ins
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def ins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'ins')
|
@property
@pulumi.getter(name='logConfigs')
def log_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'log_configs')
| 8,461,996,341,315,181,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
log_configs
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='logConfigs')
def log_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LogConfigArgs']]]]:
'\n \n '
return pulumi.get(self, 'log_configs')
|
@property
@pulumi.getter(name='notIns')
def not_ins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'not_ins')
| 8,785,413,740,568,024,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
not_ins
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='notIns')
def not_ins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'not_ins')
|
@property
@pulumi.getter
def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'permissions')
| -2,012,016,187,070,160,600
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
permissions
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'permissions')
|
def __init__(__self__, *, port: Optional[pulumi.Input[int]]=None, port_name: Optional[pulumi.Input[str]]=None, port_specification: Optional[pulumi.Input['SSLHealthCheckPortSpecification']]=None, proxy_header: Optional[pulumi.Input['SSLHealthCheckProxyHeader']]=None, request: Optional[pulumi.Input[str]]=None, response: Optional[pulumi.Input[str]]=None):
"\n :param pulumi.Input[int] port: The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535.\n :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence.\n :param pulumi.Input['SSLHealthCheckPortSpecification'] port_specification: Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields.\n :param pulumi.Input['SSLHealthCheckProxyHeader'] proxy_header: Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.\n :param pulumi.Input[str] request: The application data to send once the SSL connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII.\n :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII.\n "
if (port is not None):
pulumi.set(__self__, 'port', port)
if (port_name is not None):
pulumi.set(__self__, 'port_name', port_name)
if (port_specification is not None):
pulumi.set(__self__, 'port_specification', port_specification)
if (proxy_header is not None):
pulumi.set(__self__, 'proxy_header', proxy_header)
if (request is not None):
pulumi.set(__self__, 'request', request)
if (response is not None):
pulumi.set(__self__, 'response', response)
| 7,534,966,882,045,052,000
|
:param pulumi.Input[int] port: The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535.
:param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence.
:param pulumi.Input['SSLHealthCheckPortSpecification'] port_specification: Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields.
:param pulumi.Input['SSLHealthCheckProxyHeader'] proxy_header: Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
:param pulumi.Input[str] request: The application data to send once the SSL connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII.
:param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, port: Optional[pulumi.Input[int]]=None, port_name: Optional[pulumi.Input[str]]=None, port_specification: Optional[pulumi.Input['SSLHealthCheckPortSpecification']]=None, proxy_header: Optional[pulumi.Input['SSLHealthCheckProxyHeader']]=None, request: Optional[pulumi.Input[str]]=None, response: Optional[pulumi.Input[str]]=None):
"\n :param pulumi.Input[int] port: The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535.\n :param pulumi.Input[str] port_name: Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence.\n :param pulumi.Input['SSLHealthCheckPortSpecification'] port_specification: Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields.\n :param pulumi.Input['SSLHealthCheckProxyHeader'] proxy_header: Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.\n :param pulumi.Input[str] request: The application data to send once the SSL connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII.\n :param pulumi.Input[str] response: The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII.\n "
if (port is not None):
pulumi.set(__self__, 'port', port)
if (port_name is not None):
pulumi.set(__self__, 'port_name', port_name)
if (port_specification is not None):
pulumi.set(__self__, 'port_specification', port_specification)
if (proxy_header is not None):
pulumi.set(__self__, 'proxy_header', proxy_header)
if (request is not None):
pulumi.set(__self__, 'request', request)
if (response is not None):
pulumi.set(__self__, 'response', response)
|
@property
@pulumi.getter
def port(self) -> Optional[pulumi.Input[int]]:
'\n The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535.\n '
return pulumi.get(self, 'port')
| -6,819,451,309,770,002,000
|
The TCP port number for the health check request. The default value is 443. Valid values are 1 through 65535.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
port
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def port(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'port')
|
@property
@pulumi.getter(name='portName')
def port_name(self) -> Optional[pulumi.Input[str]]:
'\n Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence.\n '
return pulumi.get(self, 'port_name')
| -819,122,187,026,193,200
|
Port name as defined in InstanceGroup#NamedPort#name. If both port and port_name are defined, port takes precedence.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
port_name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='portName')
def port_name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'port_name')
|
@property
@pulumi.getter(name='portSpecification')
def port_specification(self) -> Optional[pulumi.Input['SSLHealthCheckPortSpecification']]:
'\n Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields.\n '
return pulumi.get(self, 'port_specification')
| -5,459,066,904,997,992,000
|
Specifies how port is selected for health checking, can be one of following values: USE_FIXED_PORT: The port number in port is used for health checking. USE_NAMED_PORT: The portName is used for health checking. USE_SERVING_PORT: For NetworkEndpointGroup, the port specified for each network endpoint is used for health checking. For other backends, the port or named port specified in the Backend Service is used for health checking. If not specified, SSL health check follows behavior specified in port and portName fields.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
port_specification
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='portSpecification')
def port_specification(self) -> Optional[pulumi.Input['SSLHealthCheckPortSpecification']]:
'\n \n '
return pulumi.get(self, 'port_specification')
|
@property
@pulumi.getter(name='proxyHeader')
def proxy_header(self) -> Optional[pulumi.Input['SSLHealthCheckProxyHeader']]:
'\n Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.\n '
return pulumi.get(self, 'proxy_header')
| -4,241,343,832,756,747,300
|
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
proxy_header
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='proxyHeader')
def proxy_header(self) -> Optional[pulumi.Input['SSLHealthCheckProxyHeader']]:
'\n \n '
return pulumi.get(self, 'proxy_header')
|
@property
@pulumi.getter
def request(self) -> Optional[pulumi.Input[str]]:
'\n The application data to send once the SSL connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII.\n '
return pulumi.get(self, 'request')
| 1,239,217,374,376,145,700
|
The application data to send once the SSL connection has been established (default value is empty). If both request and response are empty, the connection establishment alone will indicate health. The request data can only be ASCII.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
request
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def request(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'request')
|
@property
@pulumi.getter
def response(self) -> Optional[pulumi.Input[str]]:
'\n The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII.\n '
return pulumi.get(self, 'response')
| -5,870,028,318,372,682,000
|
The bytes to match against the beginning of the response data. If left empty (the default value), any response will indicate health. The response data can only be ASCII.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
response
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def response(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'response')
|
def __init__(__self__, *, source_disk: Optional[pulumi.Input[str]]=None):
'\n An instance-attached disk resource.\n :param pulumi.Input[str] source_disk: Specifies a URL of the disk attached to the source instance.\n '
if (source_disk is not None):
pulumi.set(__self__, 'source_disk', source_disk)
| -4,223,406,243,559,398,000
|
An instance-attached disk resource.
:param pulumi.Input[str] source_disk: Specifies a URL of the disk attached to the source instance.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, source_disk: Optional[pulumi.Input[str]]=None):
'\n An instance-attached disk resource.\n :param pulumi.Input[str] source_disk: Specifies a URL of the disk attached to the source instance.\n '
if (source_disk is not None):
pulumi.set(__self__, 'source_disk', source_disk)
|
@property
@pulumi.getter(name='sourceDisk')
def source_disk(self) -> Optional[pulumi.Input[str]]:
'\n Specifies a URL of the disk attached to the source instance.\n '
return pulumi.get(self, 'source_disk')
| -8,914,586,324,138,874,000
|
Specifies a URL of the disk attached to the source instance.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
source_disk
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sourceDisk')
def source_disk(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'source_disk')
|
def __init__(__self__, *, key: Optional[pulumi.Input[str]]=None, operator: Optional[pulumi.Input['SchedulingNodeAffinityOperator']]=None, values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n Node Affinity: the configuration of desired nodes onto which this Instance could be scheduled.\n :param pulumi.Input[str] key: Corresponds to the label key of Node resource.\n :param pulumi.Input['SchedulingNodeAffinityOperator'] operator: Defines the operation of node selection. Valid operators are IN for affinity and NOT_IN for anti-affinity.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of Node resource.\n "
if (key is not None):
pulumi.set(__self__, 'key', key)
if (operator is not None):
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
| 2,045,913,256,836,206,800
|
Node Affinity: the configuration of desired nodes onto which this Instance could be scheduled.
:param pulumi.Input[str] key: Corresponds to the label key of Node resource.
:param pulumi.Input['SchedulingNodeAffinityOperator'] operator: Defines the operation of node selection. Valid operators are IN for affinity and NOT_IN for anti-affinity.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of Node resource.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, key: Optional[pulumi.Input[str]]=None, operator: Optional[pulumi.Input['SchedulingNodeAffinityOperator']]=None, values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n Node Affinity: the configuration of desired nodes onto which this Instance could be scheduled.\n :param pulumi.Input[str] key: Corresponds to the label key of Node resource.\n :param pulumi.Input['SchedulingNodeAffinityOperator'] operator: Defines the operation of node selection. Valid operators are IN for affinity and NOT_IN for anti-affinity.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Corresponds to the label values of Node resource.\n "
if (key is not None):
pulumi.set(__self__, 'key', key)
if (operator is not None):
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
@property
@pulumi.getter
def key(self) -> Optional[pulumi.Input[str]]:
'\n Corresponds to the label key of Node resource.\n '
return pulumi.get(self, 'key')
| 2,186,225,952,229,067,000
|
Corresponds to the label key of Node resource.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
key
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def key(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def operator(self) -> Optional[pulumi.Input['SchedulingNodeAffinityOperator']]:
'\n Defines the operation of node selection. Valid operators are IN for affinity and NOT_IN for anti-affinity.\n '
return pulumi.get(self, 'operator')
| -540,619,149,230,469,570
|
Defines the operation of node selection. Valid operators are IN for affinity and NOT_IN for anti-affinity.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
operator
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def operator(self) -> Optional[pulumi.Input['SchedulingNodeAffinityOperator']]:
'\n \n '
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Corresponds to the label values of Node resource.\n '
return pulumi.get(self, 'values')
| -6,931,721,285,501,705,000
|
Corresponds to the label values of Node resource.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
values
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
def __init__(__self__, *, automatic_restart: Optional[pulumi.Input[bool]]=None, availability_domain: Optional[pulumi.Input[int]]=None, current_cpus: Optional[pulumi.Input[int]]=None, current_memory_mb: Optional[pulumi.Input[str]]=None, host_error_timeout_seconds: Optional[pulumi.Input[int]]=None, instance_termination_action: Optional[pulumi.Input['SchedulingInstanceTerminationAction']]=None, latency_tolerant: Optional[pulumi.Input[bool]]=None, location_hint: Optional[pulumi.Input[str]]=None, maintenance_freeze_duration_hours: Optional[pulumi.Input[int]]=None, maintenance_interval: Optional[pulumi.Input['SchedulingMaintenanceInterval']]=None, max_run_duration: Optional[pulumi.Input['DurationArgs']]=None, min_node_cpus: Optional[pulumi.Input[int]]=None, node_affinities: Optional[pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]]]=None, on_host_maintenance: Optional[pulumi.Input['SchedulingOnHostMaintenance']]=None, preemptible: Optional[pulumi.Input[bool]]=None, provisioning_model: Optional[pulumi.Input['SchedulingProvisioningModel']]=None, termination_time: Optional[pulumi.Input[str]]=None):
"\n Sets the scheduling options for an Instance. NextID: 21\n :param pulumi.Input[bool] automatic_restart: Specifies whether the instance should be automatically restarted if it is terminated by Compute Engine (not terminated by a user). You can only set the automatic restart option for standard instances. Preemptible instances cannot be automatically restarted. By default, this is set to true so an instance is automatically restarted if it is terminated by Compute Engine.\n :param pulumi.Input[int] availability_domain: Specifies the availability domain (AD), which this instance should be scheduled on. The AD belongs to the spread GroupPlacementPolicy resource policy that has been assigned to the instance. Specify a value between 1-max count of availability domains in your GroupPlacementPolicy. See go/placement-policy-extension for more details.\n :param pulumi.Input[int] current_cpus: Current number of vCPUs available for VM. 0 or unset means default vCPUs of the current machine type.\n :param pulumi.Input[str] current_memory_mb: Current amount of memory (in MB) available for VM. 0 or unset means default amount of memory of the current machine type.\n :param pulumi.Input[int] host_error_timeout_seconds: Specify the time in seconds for host error detection, the value must be within the range of [90, 330] with the increment of 30, if unset, the default behavior of host error recovery will be used.\n :param pulumi.Input['SchedulingInstanceTerminationAction'] instance_termination_action: Specifies the termination action for the instance.\n :param pulumi.Input[bool] latency_tolerant: Defines whether the instance is tolerant of higher cpu latency. This can only be set during instance creation, or when the instance is not currently running. It must not be set if the preemptible option is also set.\n :param pulumi.Input[str] location_hint: An opaque location hint used to place the instance close to other resources. This field is for use by internal tools that use the public API.\n :param pulumi.Input[int] maintenance_freeze_duration_hours: Specifies the number of hours after VM instance creation where the VM won't be scheduled for maintenance.\n :param pulumi.Input['SchedulingMaintenanceInterval'] maintenance_interval: For more information about maintenance intervals, see Setting maintenance intervals.\n :param pulumi.Input['DurationArgs'] max_run_duration: Specifies the max run duration for the given instance. If specified, the instance termination action will be performed at the end of the run duration.\n :param pulumi.Input[int] min_node_cpus: The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.\n :param pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]] node_affinities: A set of node affinity and anti-affinity configurations. Refer to Configuring node affinity for more information. Overrides reservationAffinity.\n :param pulumi.Input['SchedulingOnHostMaintenance'] on_host_maintenance: Defines the maintenance behavior for this instance. For standard instances, the default behavior is MIGRATE. For preemptible instances, the default and only possible behavior is TERMINATE. For more information, see Setting Instance Scheduling Options.\n :param pulumi.Input[bool] preemptible: Defines whether the instance is preemptible. This can only be set during instance creation or while the instance is stopped and therefore, in a `TERMINATED` state. See Instance Life Cycle for more information on the possible instance states.\n :param pulumi.Input['SchedulingProvisioningModel'] provisioning_model: Specifies the provisioning model of the instance.\n :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.\n "
if (automatic_restart is not None):
pulumi.set(__self__, 'automatic_restart', automatic_restart)
if (availability_domain is not None):
pulumi.set(__self__, 'availability_domain', availability_domain)
if (current_cpus is not None):
pulumi.set(__self__, 'current_cpus', current_cpus)
if (current_memory_mb is not None):
pulumi.set(__self__, 'current_memory_mb', current_memory_mb)
if (host_error_timeout_seconds is not None):
pulumi.set(__self__, 'host_error_timeout_seconds', host_error_timeout_seconds)
if (instance_termination_action is not None):
pulumi.set(__self__, 'instance_termination_action', instance_termination_action)
if (latency_tolerant is not None):
pulumi.set(__self__, 'latency_tolerant', latency_tolerant)
if (location_hint is not None):
pulumi.set(__self__, 'location_hint', location_hint)
if (maintenance_freeze_duration_hours is not None):
pulumi.set(__self__, 'maintenance_freeze_duration_hours', maintenance_freeze_duration_hours)
if (maintenance_interval is not None):
pulumi.set(__self__, 'maintenance_interval', maintenance_interval)
if (max_run_duration is not None):
pulumi.set(__self__, 'max_run_duration', max_run_duration)
if (min_node_cpus is not None):
pulumi.set(__self__, 'min_node_cpus', min_node_cpus)
if (node_affinities is not None):
pulumi.set(__self__, 'node_affinities', node_affinities)
if (on_host_maintenance is not None):
pulumi.set(__self__, 'on_host_maintenance', on_host_maintenance)
if (preemptible is not None):
pulumi.set(__self__, 'preemptible', preemptible)
if (provisioning_model is not None):
pulumi.set(__self__, 'provisioning_model', provisioning_model)
if (termination_time is not None):
pulumi.set(__self__, 'termination_time', termination_time)
| 5,438,104,034,675,397,000
|
Sets the scheduling options for an Instance. NextID: 21
:param pulumi.Input[bool] automatic_restart: Specifies whether the instance should be automatically restarted if it is terminated by Compute Engine (not terminated by a user). You can only set the automatic restart option for standard instances. Preemptible instances cannot be automatically restarted. By default, this is set to true so an instance is automatically restarted if it is terminated by Compute Engine.
:param pulumi.Input[int] availability_domain: Specifies the availability domain (AD), which this instance should be scheduled on. The AD belongs to the spread GroupPlacementPolicy resource policy that has been assigned to the instance. Specify a value between 1-max count of availability domains in your GroupPlacementPolicy. See go/placement-policy-extension for more details.
:param pulumi.Input[int] current_cpus: Current number of vCPUs available for VM. 0 or unset means default vCPUs of the current machine type.
:param pulumi.Input[str] current_memory_mb: Current amount of memory (in MB) available for VM. 0 or unset means default amount of memory of the current machine type.
:param pulumi.Input[int] host_error_timeout_seconds: Specify the time in seconds for host error detection, the value must be within the range of [90, 330] with the increment of 30, if unset, the default behavior of host error recovery will be used.
:param pulumi.Input['SchedulingInstanceTerminationAction'] instance_termination_action: Specifies the termination action for the instance.
:param pulumi.Input[bool] latency_tolerant: Defines whether the instance is tolerant of higher cpu latency. This can only be set during instance creation, or when the instance is not currently running. It must not be set if the preemptible option is also set.
:param pulumi.Input[str] location_hint: An opaque location hint used to place the instance close to other resources. This field is for use by internal tools that use the public API.
:param pulumi.Input[int] maintenance_freeze_duration_hours: Specifies the number of hours after VM instance creation where the VM won't be scheduled for maintenance.
:param pulumi.Input['SchedulingMaintenanceInterval'] maintenance_interval: For more information about maintenance intervals, see Setting maintenance intervals.
:param pulumi.Input['DurationArgs'] max_run_duration: Specifies the max run duration for the given instance. If specified, the instance termination action will be performed at the end of the run duration.
:param pulumi.Input[int] min_node_cpus: The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.
:param pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]] node_affinities: A set of node affinity and anti-affinity configurations. Refer to Configuring node affinity for more information. Overrides reservationAffinity.
:param pulumi.Input['SchedulingOnHostMaintenance'] on_host_maintenance: Defines the maintenance behavior for this instance. For standard instances, the default behavior is MIGRATE. For preemptible instances, the default and only possible behavior is TERMINATE. For more information, see Setting Instance Scheduling Options.
:param pulumi.Input[bool] preemptible: Defines whether the instance is preemptible. This can only be set during instance creation or while the instance is stopped and therefore, in a `TERMINATED` state. See Instance Life Cycle for more information on the possible instance states.
:param pulumi.Input['SchedulingProvisioningModel'] provisioning_model: Specifies the provisioning model of the instance.
:param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, automatic_restart: Optional[pulumi.Input[bool]]=None, availability_domain: Optional[pulumi.Input[int]]=None, current_cpus: Optional[pulumi.Input[int]]=None, current_memory_mb: Optional[pulumi.Input[str]]=None, host_error_timeout_seconds: Optional[pulumi.Input[int]]=None, instance_termination_action: Optional[pulumi.Input['SchedulingInstanceTerminationAction']]=None, latency_tolerant: Optional[pulumi.Input[bool]]=None, location_hint: Optional[pulumi.Input[str]]=None, maintenance_freeze_duration_hours: Optional[pulumi.Input[int]]=None, maintenance_interval: Optional[pulumi.Input['SchedulingMaintenanceInterval']]=None, max_run_duration: Optional[pulumi.Input['DurationArgs']]=None, min_node_cpus: Optional[pulumi.Input[int]]=None, node_affinities: Optional[pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]]]=None, on_host_maintenance: Optional[pulumi.Input['SchedulingOnHostMaintenance']]=None, preemptible: Optional[pulumi.Input[bool]]=None, provisioning_model: Optional[pulumi.Input['SchedulingProvisioningModel']]=None, termination_time: Optional[pulumi.Input[str]]=None):
"\n Sets the scheduling options for an Instance. NextID: 21\n :param pulumi.Input[bool] automatic_restart: Specifies whether the instance should be automatically restarted if it is terminated by Compute Engine (not terminated by a user). You can only set the automatic restart option for standard instances. Preemptible instances cannot be automatically restarted. By default, this is set to true so an instance is automatically restarted if it is terminated by Compute Engine.\n :param pulumi.Input[int] availability_domain: Specifies the availability domain (AD), which this instance should be scheduled on. The AD belongs to the spread GroupPlacementPolicy resource policy that has been assigned to the instance. Specify a value between 1-max count of availability domains in your GroupPlacementPolicy. See go/placement-policy-extension for more details.\n :param pulumi.Input[int] current_cpus: Current number of vCPUs available for VM. 0 or unset means default vCPUs of the current machine type.\n :param pulumi.Input[str] current_memory_mb: Current amount of memory (in MB) available for VM. 0 or unset means default amount of memory of the current machine type.\n :param pulumi.Input[int] host_error_timeout_seconds: Specify the time in seconds for host error detection, the value must be within the range of [90, 330] with the increment of 30, if unset, the default behavior of host error recovery will be used.\n :param pulumi.Input['SchedulingInstanceTerminationAction'] instance_termination_action: Specifies the termination action for the instance.\n :param pulumi.Input[bool] latency_tolerant: Defines whether the instance is tolerant of higher cpu latency. This can only be set during instance creation, or when the instance is not currently running. It must not be set if the preemptible option is also set.\n :param pulumi.Input[str] location_hint: An opaque location hint used to place the instance close to other resources. This field is for use by internal tools that use the public API.\n :param pulumi.Input[int] maintenance_freeze_duration_hours: Specifies the number of hours after VM instance creation where the VM won't be scheduled for maintenance.\n :param pulumi.Input['SchedulingMaintenanceInterval'] maintenance_interval: For more information about maintenance intervals, see Setting maintenance intervals.\n :param pulumi.Input['DurationArgs'] max_run_duration: Specifies the max run duration for the given instance. If specified, the instance termination action will be performed at the end of the run duration.\n :param pulumi.Input[int] min_node_cpus: The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.\n :param pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]] node_affinities: A set of node affinity and anti-affinity configurations. Refer to Configuring node affinity for more information. Overrides reservationAffinity.\n :param pulumi.Input['SchedulingOnHostMaintenance'] on_host_maintenance: Defines the maintenance behavior for this instance. For standard instances, the default behavior is MIGRATE. For preemptible instances, the default and only possible behavior is TERMINATE. For more information, see Setting Instance Scheduling Options.\n :param pulumi.Input[bool] preemptible: Defines whether the instance is preemptible. This can only be set during instance creation or while the instance is stopped and therefore, in a `TERMINATED` state. See Instance Life Cycle for more information on the possible instance states.\n :param pulumi.Input['SchedulingProvisioningModel'] provisioning_model: Specifies the provisioning model of the instance.\n :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.\n "
if (automatic_restart is not None):
pulumi.set(__self__, 'automatic_restart', automatic_restart)
if (availability_domain is not None):
pulumi.set(__self__, 'availability_domain', availability_domain)
if (current_cpus is not None):
pulumi.set(__self__, 'current_cpus', current_cpus)
if (current_memory_mb is not None):
pulumi.set(__self__, 'current_memory_mb', current_memory_mb)
if (host_error_timeout_seconds is not None):
pulumi.set(__self__, 'host_error_timeout_seconds', host_error_timeout_seconds)
if (instance_termination_action is not None):
pulumi.set(__self__, 'instance_termination_action', instance_termination_action)
if (latency_tolerant is not None):
pulumi.set(__self__, 'latency_tolerant', latency_tolerant)
if (location_hint is not None):
pulumi.set(__self__, 'location_hint', location_hint)
if (maintenance_freeze_duration_hours is not None):
pulumi.set(__self__, 'maintenance_freeze_duration_hours', maintenance_freeze_duration_hours)
if (maintenance_interval is not None):
pulumi.set(__self__, 'maintenance_interval', maintenance_interval)
if (max_run_duration is not None):
pulumi.set(__self__, 'max_run_duration', max_run_duration)
if (min_node_cpus is not None):
pulumi.set(__self__, 'min_node_cpus', min_node_cpus)
if (node_affinities is not None):
pulumi.set(__self__, 'node_affinities', node_affinities)
if (on_host_maintenance is not None):
pulumi.set(__self__, 'on_host_maintenance', on_host_maintenance)
if (preemptible is not None):
pulumi.set(__self__, 'preemptible', preemptible)
if (provisioning_model is not None):
pulumi.set(__self__, 'provisioning_model', provisioning_model)
if (termination_time is not None):
pulumi.set(__self__, 'termination_time', termination_time)
|
@property
@pulumi.getter(name='automaticRestart')
def automatic_restart(self) -> Optional[pulumi.Input[bool]]:
'\n Specifies whether the instance should be automatically restarted if it is terminated by Compute Engine (not terminated by a user). You can only set the automatic restart option for standard instances. Preemptible instances cannot be automatically restarted. By default, this is set to true so an instance is automatically restarted if it is terminated by Compute Engine.\n '
return pulumi.get(self, 'automatic_restart')
| 8,733,416,993,200,916,000
|
Specifies whether the instance should be automatically restarted if it is terminated by Compute Engine (not terminated by a user). You can only set the automatic restart option for standard instances. Preemptible instances cannot be automatically restarted. By default, this is set to true so an instance is automatically restarted if it is terminated by Compute Engine.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
automatic_restart
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='automaticRestart')
def automatic_restart(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'automatic_restart')
|
@property
@pulumi.getter(name='availabilityDomain')
def availability_domain(self) -> Optional[pulumi.Input[int]]:
'\n Specifies the availability domain (AD), which this instance should be scheduled on. The AD belongs to the spread GroupPlacementPolicy resource policy that has been assigned to the instance. Specify a value between 1-max count of availability domains in your GroupPlacementPolicy. See go/placement-policy-extension for more details.\n '
return pulumi.get(self, 'availability_domain')
| 1,781,841,880,973,392,000
|
Specifies the availability domain (AD), which this instance should be scheduled on. The AD belongs to the spread GroupPlacementPolicy resource policy that has been assigned to the instance. Specify a value between 1-max count of availability domains in your GroupPlacementPolicy. See go/placement-policy-extension for more details.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
availability_domain
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='availabilityDomain')
def availability_domain(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'availability_domain')
|
@property
@pulumi.getter(name='currentCpus')
def current_cpus(self) -> Optional[pulumi.Input[int]]:
'\n Current number of vCPUs available for VM. 0 or unset means default vCPUs of the current machine type.\n '
return pulumi.get(self, 'current_cpus')
| 7,954,104,138,225,163,000
|
Current number of vCPUs available for VM. 0 or unset means default vCPUs of the current machine type.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
current_cpus
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='currentCpus')
def current_cpus(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'current_cpus')
|
@property
@pulumi.getter(name='currentMemoryMb')
def current_memory_mb(self) -> Optional[pulumi.Input[str]]:
'\n Current amount of memory (in MB) available for VM. 0 or unset means default amount of memory of the current machine type.\n '
return pulumi.get(self, 'current_memory_mb')
| 530,783,762,059,123,700
|
Current amount of memory (in MB) available for VM. 0 or unset means default amount of memory of the current machine type.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
current_memory_mb
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='currentMemoryMb')
def current_memory_mb(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'current_memory_mb')
|
@property
@pulumi.getter(name='hostErrorTimeoutSeconds')
def host_error_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
'\n Specify the time in seconds for host error detection, the value must be within the range of [90, 330] with the increment of 30, if unset, the default behavior of host error recovery will be used.\n '
return pulumi.get(self, 'host_error_timeout_seconds')
| -1,305,724,194,555,336,000
|
Specify the time in seconds for host error detection, the value must be within the range of [90, 330] with the increment of 30, if unset, the default behavior of host error recovery will be used.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
host_error_timeout_seconds
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='hostErrorTimeoutSeconds')
def host_error_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'host_error_timeout_seconds')
|
@property
@pulumi.getter(name='instanceTerminationAction')
def instance_termination_action(self) -> Optional[pulumi.Input['SchedulingInstanceTerminationAction']]:
'\n Specifies the termination action for the instance.\n '
return pulumi.get(self, 'instance_termination_action')
| -1,707,256,493,339,798,000
|
Specifies the termination action for the instance.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
instance_termination_action
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='instanceTerminationAction')
def instance_termination_action(self) -> Optional[pulumi.Input['SchedulingInstanceTerminationAction']]:
'\n \n '
return pulumi.get(self, 'instance_termination_action')
|
@property
@pulumi.getter(name='latencyTolerant')
def latency_tolerant(self) -> Optional[pulumi.Input[bool]]:
'\n Defines whether the instance is tolerant of higher cpu latency. This can only be set during instance creation, or when the instance is not currently running. It must not be set if the preemptible option is also set.\n '
return pulumi.get(self, 'latency_tolerant')
| -541,641,757,580,480,000
|
Defines whether the instance is tolerant of higher cpu latency. This can only be set during instance creation, or when the instance is not currently running. It must not be set if the preemptible option is also set.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
latency_tolerant
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='latencyTolerant')
def latency_tolerant(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'latency_tolerant')
|
@property
@pulumi.getter(name='locationHint')
def location_hint(self) -> Optional[pulumi.Input[str]]:
'\n An opaque location hint used to place the instance close to other resources. This field is for use by internal tools that use the public API.\n '
return pulumi.get(self, 'location_hint')
| 2,960,517,105,046,379,000
|
An opaque location hint used to place the instance close to other resources. This field is for use by internal tools that use the public API.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
location_hint
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='locationHint')
def location_hint(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'location_hint')
|
@property
@pulumi.getter(name='maintenanceFreezeDurationHours')
def maintenance_freeze_duration_hours(self) -> Optional[pulumi.Input[int]]:
"\n Specifies the number of hours after VM instance creation where the VM won't be scheduled for maintenance.\n "
return pulumi.get(self, 'maintenance_freeze_duration_hours')
| 2,032,344,892,288,068,600
|
Specifies the number of hours after VM instance creation where the VM won't be scheduled for maintenance.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
maintenance_freeze_duration_hours
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maintenanceFreezeDurationHours')
def maintenance_freeze_duration_hours(self) -> Optional[pulumi.Input[int]]:
"\n \n "
return pulumi.get(self, 'maintenance_freeze_duration_hours')
|
@property
@pulumi.getter(name='maintenanceInterval')
def maintenance_interval(self) -> Optional[pulumi.Input['SchedulingMaintenanceInterval']]:
'\n For more information about maintenance intervals, see Setting maintenance intervals.\n '
return pulumi.get(self, 'maintenance_interval')
| 1,433,510,902,926,023,400
|
For more information about maintenance intervals, see Setting maintenance intervals.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
maintenance_interval
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maintenanceInterval')
def maintenance_interval(self) -> Optional[pulumi.Input['SchedulingMaintenanceInterval']]:
'\n \n '
return pulumi.get(self, 'maintenance_interval')
|
@property
@pulumi.getter(name='maxRunDuration')
def max_run_duration(self) -> Optional[pulumi.Input['DurationArgs']]:
'\n Specifies the max run duration for the given instance. If specified, the instance termination action will be performed at the end of the run duration.\n '
return pulumi.get(self, 'max_run_duration')
| 4,404,646,975,086,458,400
|
Specifies the max run duration for the given instance. If specified, the instance termination action will be performed at the end of the run duration.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_run_duration
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRunDuration')
def max_run_duration(self) -> Optional[pulumi.Input['DurationArgs']]:
'\n \n '
return pulumi.get(self, 'max_run_duration')
|
@property
@pulumi.getter(name='minNodeCpus')
def min_node_cpus(self) -> Optional[pulumi.Input[int]]:
'\n The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.\n '
return pulumi.get(self, 'min_node_cpus')
| 8,067,065,183,407,906,000
|
The minimum number of virtual CPUs this instance will consume when running on a sole-tenant node.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
min_node_cpus
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='minNodeCpus')
def min_node_cpus(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'min_node_cpus')
|
@property
@pulumi.getter(name='nodeAffinities')
def node_affinities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]]]:
'\n A set of node affinity and anti-affinity configurations. Refer to Configuring node affinity for more information. Overrides reservationAffinity.\n '
return pulumi.get(self, 'node_affinities')
| 3,877,139,526,386,842,000
|
A set of node affinity and anti-affinity configurations. Refer to Configuring node affinity for more information. Overrides reservationAffinity.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
node_affinities
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='nodeAffinities')
def node_affinities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SchedulingNodeAffinityArgs']]]]:
'\n \n '
return pulumi.get(self, 'node_affinities')
|
@property
@pulumi.getter(name='onHostMaintenance')
def on_host_maintenance(self) -> Optional[pulumi.Input['SchedulingOnHostMaintenance']]:
'\n Defines the maintenance behavior for this instance. For standard instances, the default behavior is MIGRATE. For preemptible instances, the default and only possible behavior is TERMINATE. For more information, see Setting Instance Scheduling Options.\n '
return pulumi.get(self, 'on_host_maintenance')
| 3,198,654,360,662,332,000
|
Defines the maintenance behavior for this instance. For standard instances, the default behavior is MIGRATE. For preemptible instances, the default and only possible behavior is TERMINATE. For more information, see Setting Instance Scheduling Options.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
on_host_maintenance
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='onHostMaintenance')
def on_host_maintenance(self) -> Optional[pulumi.Input['SchedulingOnHostMaintenance']]:
'\n \n '
return pulumi.get(self, 'on_host_maintenance')
|
@property
@pulumi.getter
def preemptible(self) -> Optional[pulumi.Input[bool]]:
'\n Defines whether the instance is preemptible. This can only be set during instance creation or while the instance is stopped and therefore, in a `TERMINATED` state. See Instance Life Cycle for more information on the possible instance states.\n '
return pulumi.get(self, 'preemptible')
| -5,489,850,241,551,729,000
|
Defines whether the instance is preemptible. This can only be set during instance creation or while the instance is stopped and therefore, in a `TERMINATED` state. See Instance Life Cycle for more information on the possible instance states.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
preemptible
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def preemptible(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'preemptible')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.