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
def ttl(self) -> Optional[pulumi.Input[int]]:
'\n The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n '
return pulumi.get(self, 'ttl')
| 7,303,850,336,050,947,000
|
The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
ttl
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def ttl(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'ttl')
|
def __init__(__self__, *, bypass_cache_on_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs']]]]=None, cache_key_policy: Optional[pulumi.Input['CacheKeyPolicyArgs']]=None, cache_mode: Optional[pulumi.Input['BackendServiceCdnPolicyCacheMode']]=None, client_ttl: Optional[pulumi.Input[int]]=None, default_ttl: Optional[pulumi.Input[int]]=None, max_ttl: Optional[pulumi.Input[int]]=None, negative_caching: Optional[pulumi.Input[bool]]=None, negative_caching_policy: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]=None, request_coalescing: Optional[pulumi.Input[bool]]=None, serve_while_stale: Optional[pulumi.Input[int]]=None, signed_url_cache_max_age_sec: Optional[pulumi.Input[str]]=None):
'\n Message containing Cloud CDN configuration for a backend service.\n :param pulumi.Input[Sequence[pulumi.Input[\'BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs\']]] bypass_cache_on_request_headers: Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.\n :param pulumi.Input[\'CacheKeyPolicyArgs\'] cache_key_policy: The CacheKeyPolicy for this CdnPolicy.\n :param pulumi.Input[\'BackendServiceCdnPolicyCacheMode\'] cache_mode: Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google\'s edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.\n :param pulumi.Input[int] client_ttl: Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).\n :param pulumi.Input[int] default_ttl: Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n :param pulumi.Input[int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n :param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.\n :param pulumi.Input[Sequence[pulumi.Input[\'BackendServiceCdnPolicyNegativeCachingPolicyArgs\']]] negative_caching_policy: Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN\'s default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.\n :param pulumi.Input[bool] request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.\n :param pulumi.Input[int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.\n :param pulumi.Input[str] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.\n '
if (bypass_cache_on_request_headers is not None):
pulumi.set(__self__, 'bypass_cache_on_request_headers', bypass_cache_on_request_headers)
if (cache_key_policy is not None):
pulumi.set(__self__, 'cache_key_policy', cache_key_policy)
if (cache_mode is not None):
pulumi.set(__self__, 'cache_mode', cache_mode)
if (client_ttl is not None):
pulumi.set(__self__, 'client_ttl', client_ttl)
if (default_ttl is not None):
pulumi.set(__self__, 'default_ttl', default_ttl)
if (max_ttl is not None):
pulumi.set(__self__, 'max_ttl', max_ttl)
if (negative_caching is not None):
pulumi.set(__self__, 'negative_caching', negative_caching)
if (negative_caching_policy is not None):
pulumi.set(__self__, 'negative_caching_policy', negative_caching_policy)
if (request_coalescing is not None):
pulumi.set(__self__, 'request_coalescing', request_coalescing)
if (serve_while_stale is not None):
pulumi.set(__self__, 'serve_while_stale', serve_while_stale)
if (signed_url_cache_max_age_sec is not None):
pulumi.set(__self__, 'signed_url_cache_max_age_sec', signed_url_cache_max_age_sec)
| -7,085,536,753,635,173,000
|
Message containing Cloud CDN configuration for a backend service.
:param pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs']]] bypass_cache_on_request_headers: Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
:param pulumi.Input['CacheKeyPolicyArgs'] cache_key_policy: The CacheKeyPolicy for this CdnPolicy.
:param pulumi.Input['BackendServiceCdnPolicyCacheMode'] cache_mode: Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
:param pulumi.Input[int] client_ttl: Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
:param pulumi.Input[int] default_ttl: Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
:param pulumi.Input[int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
:param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.
:param pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]] negative_caching_policy: Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.
:param pulumi.Input[bool] request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
:param pulumi.Input[int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.
:param pulumi.Input[str] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, bypass_cache_on_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs']]]]=None, cache_key_policy: Optional[pulumi.Input['CacheKeyPolicyArgs']]=None, cache_mode: Optional[pulumi.Input['BackendServiceCdnPolicyCacheMode']]=None, client_ttl: Optional[pulumi.Input[int]]=None, default_ttl: Optional[pulumi.Input[int]]=None, max_ttl: Optional[pulumi.Input[int]]=None, negative_caching: Optional[pulumi.Input[bool]]=None, negative_caching_policy: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]=None, request_coalescing: Optional[pulumi.Input[bool]]=None, serve_while_stale: Optional[pulumi.Input[int]]=None, signed_url_cache_max_age_sec: Optional[pulumi.Input[str]]=None):
'\n Message containing Cloud CDN configuration for a backend service.\n :param pulumi.Input[Sequence[pulumi.Input[\'BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs\']]] bypass_cache_on_request_headers: Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.\n :param pulumi.Input[\'CacheKeyPolicyArgs\'] cache_key_policy: The CacheKeyPolicy for this CdnPolicy.\n :param pulumi.Input[\'BackendServiceCdnPolicyCacheMode\'] cache_mode: Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google\'s edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.\n :param pulumi.Input[int] client_ttl: Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).\n :param pulumi.Input[int] default_ttl: Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n :param pulumi.Input[int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n :param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.\n :param pulumi.Input[Sequence[pulumi.Input[\'BackendServiceCdnPolicyNegativeCachingPolicyArgs\']]] negative_caching_policy: Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN\'s default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.\n :param pulumi.Input[bool] request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.\n :param pulumi.Input[int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.\n :param pulumi.Input[str] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.\n '
if (bypass_cache_on_request_headers is not None):
pulumi.set(__self__, 'bypass_cache_on_request_headers', bypass_cache_on_request_headers)
if (cache_key_policy is not None):
pulumi.set(__self__, 'cache_key_policy', cache_key_policy)
if (cache_mode is not None):
pulumi.set(__self__, 'cache_mode', cache_mode)
if (client_ttl is not None):
pulumi.set(__self__, 'client_ttl', client_ttl)
if (default_ttl is not None):
pulumi.set(__self__, 'default_ttl', default_ttl)
if (max_ttl is not None):
pulumi.set(__self__, 'max_ttl', max_ttl)
if (negative_caching is not None):
pulumi.set(__self__, 'negative_caching', negative_caching)
if (negative_caching_policy is not None):
pulumi.set(__self__, 'negative_caching_policy', negative_caching_policy)
if (request_coalescing is not None):
pulumi.set(__self__, 'request_coalescing', request_coalescing)
if (serve_while_stale is not None):
pulumi.set(__self__, 'serve_while_stale', serve_while_stale)
if (signed_url_cache_max_age_sec is not None):
pulumi.set(__self__, 'signed_url_cache_max_age_sec', signed_url_cache_max_age_sec)
|
@property
@pulumi.getter(name='bypassCacheOnRequestHeaders')
def bypass_cache_on_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs']]]]:
'\n Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.\n '
return pulumi.get(self, 'bypass_cache_on_request_headers')
| -7,328,677,659,769,092,000
|
Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
bypass_cache_on_request_headers
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='bypassCacheOnRequestHeaders')
def bypass_cache_on_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs']]]]:
'\n \n '
return pulumi.get(self, 'bypass_cache_on_request_headers')
|
@property
@pulumi.getter(name='cacheKeyPolicy')
def cache_key_policy(self) -> Optional[pulumi.Input['CacheKeyPolicyArgs']]:
'\n The CacheKeyPolicy for this CdnPolicy.\n '
return pulumi.get(self, 'cache_key_policy')
| 6,398,405,873,392,553,000
|
The CacheKeyPolicy for this CdnPolicy.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
cache_key_policy
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='cacheKeyPolicy')
def cache_key_policy(self) -> Optional[pulumi.Input['CacheKeyPolicyArgs']]:
'\n \n '
return pulumi.get(self, 'cache_key_policy')
|
@property
@pulumi.getter(name='cacheMode')
def cache_mode(self) -> Optional[pulumi.Input['BackendServiceCdnPolicyCacheMode']]:
'\n Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google\'s edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.\n '
return pulumi.get(self, 'cache_mode')
| -5,697,566,139,542,915,000
|
Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
cache_mode
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='cacheMode')
def cache_mode(self) -> Optional[pulumi.Input['BackendServiceCdnPolicyCacheMode']]:
'\n Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google\'s edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.\n '
return pulumi.get(self, 'cache_mode')
|
@property
@pulumi.getter(name='clientTtl')
def client_ttl(self) -> Optional[pulumi.Input[int]]:
'\n Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).\n '
return pulumi.get(self, 'client_ttl')
| 1,891,707,978,725,079,600
|
Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
client_ttl
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='clientTtl')
def client_ttl(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'client_ttl')
|
@property
@pulumi.getter(name='defaultTtl')
def default_ttl(self) -> Optional[pulumi.Input[int]]:
'\n Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n '
return pulumi.get(self, 'default_ttl')
| 1,646,866,982,074,518,800
|
Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
default_ttl
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='defaultTtl')
def default_ttl(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'default_ttl')
|
@property
@pulumi.getter(name='maxTtl')
def max_ttl(self) -> Optional[pulumi.Input[int]]:
'\n Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.\n '
return pulumi.get(self, 'max_ttl')
| 287,892,752,124,727,070
|
Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_ttl
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxTtl')
def max_ttl(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_ttl')
|
@property
@pulumi.getter(name='negativeCaching')
def negative_caching(self) -> Optional[pulumi.Input[bool]]:
'\n Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.\n '
return pulumi.get(self, 'negative_caching')
| -8,970,266,672,833,103,000
|
Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
negative_caching
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='negativeCaching')
def negative_caching(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'negative_caching')
|
@property
@pulumi.getter(name='negativeCachingPolicy')
def negative_caching_policy(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]:
"\n Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.\n "
return pulumi.get(self, 'negative_caching_policy')
| 1,415,600,040,243,558,100
|
Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
negative_caching_policy
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='negativeCachingPolicy')
def negative_caching_policy(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]:
"\n \n "
return pulumi.get(self, 'negative_caching_policy')
|
@property
@pulumi.getter(name='requestCoalescing')
def request_coalescing(self) -> Optional[pulumi.Input[bool]]:
'\n If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.\n '
return pulumi.get(self, 'request_coalescing')
| -3,131,061,561,102,181,000
|
If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
request_coalescing
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='requestCoalescing')
def request_coalescing(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'request_coalescing')
|
@property
@pulumi.getter(name='serveWhileStale')
def serve_while_stale(self) -> Optional[pulumi.Input[int]]:
'\n Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.\n '
return pulumi.get(self, 'serve_while_stale')
| -2,761,373,988,786,550,000
|
Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
serve_while_stale
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='serveWhileStale')
def serve_while_stale(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'serve_while_stale')
|
@property
@pulumi.getter(name='signedUrlCacheMaxAgeSec')
def signed_url_cache_max_age_sec(self) -> Optional[pulumi.Input[str]]:
'\n Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.\n '
return pulumi.get(self, 'signed_url_cache_max_age_sec')
| 7,089,128,830,377,634,000
|
Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
signed_url_cache_max_age_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='signedUrlCacheMaxAgeSec')
def signed_url_cache_max_age_sec(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'signed_url_cache_max_age_sec')
|
def __init__(__self__, *, connection_persistence_on_unhealthy_backends: Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends']]=None, enable_strong_affinity: Optional[pulumi.Input[bool]]=None, idle_timeout_sec: Optional[pulumi.Input[int]]=None, tracking_mode: Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode']]=None):
"\n Connection Tracking configuration for this BackendService.\n :param pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends'] connection_persistence_on_unhealthy_backends: Specifies connection persistence when backends are unhealthy. The default value is DEFAULT_FOR_PROTOCOL. If set to DEFAULT_FOR_PROTOCOL, the existing connections persist on unhealthy backends only for connection-oriented protocols (TCP and SCTP) and only if the Tracking Mode is PER_CONNECTION (default tracking mode) or the Session Affinity is configured for 5-tuple. They do not persist for UDP. If set to NEVER_PERSIST, after a backend becomes unhealthy, the existing connections on the unhealthy backend are never persisted on the unhealthy backend. They are always diverted to newly selected healthy backends (unless all backends are unhealthy). If set to ALWAYS_PERSIST, existing connections always persist on unhealthy backends regardless of protocol and session affinity. It is generally not recommended to use this mode overriding the default. For more details, see [Connection Persistence for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#connection-persistence) and [Connection Persistence for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#connection-persistence).\n :param pulumi.Input[bool] enable_strong_affinity: Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.\n :param pulumi.Input[int] idle_timeout_sec: Specifies how long to keep a Connection Tracking entry while there is no matching traffic (in seconds). For Internal TCP/UDP Load Balancing: - The minimum (default) is 10 minutes and the maximum is 16 hours. - It can be set only if Connection Tracking is less than 5-tuple (i.e. Session Affinity is CLIENT_IP_NO_DESTINATION, CLIENT_IP or CLIENT_IP_PROTO, and Tracking Mode is PER_SESSION). For Network Load Balancer the default is 60 seconds. This option is not available publicly.\n :param pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode'] tracking_mode: Specifies the key used for connection tracking. There are two options: - PER_CONNECTION: This is the default mode. The Connection Tracking is performed as per the Connection Key (default Hash Method) for the specific protocol. - PER_SESSION: The Connection Tracking is performed as per the configured Session Affinity. It matches the configured Session Affinity. For more details, see [Tracking Mode for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#tracking-mode) and [Tracking Mode for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#tracking-mode).\n "
if (connection_persistence_on_unhealthy_backends is not None):
pulumi.set(__self__, 'connection_persistence_on_unhealthy_backends', connection_persistence_on_unhealthy_backends)
if (enable_strong_affinity is not None):
pulumi.set(__self__, 'enable_strong_affinity', enable_strong_affinity)
if (idle_timeout_sec is not None):
pulumi.set(__self__, 'idle_timeout_sec', idle_timeout_sec)
if (tracking_mode is not None):
pulumi.set(__self__, 'tracking_mode', tracking_mode)
| -3,541,910,723,339,858,000
|
Connection Tracking configuration for this BackendService.
:param pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends'] connection_persistence_on_unhealthy_backends: Specifies connection persistence when backends are unhealthy. The default value is DEFAULT_FOR_PROTOCOL. If set to DEFAULT_FOR_PROTOCOL, the existing connections persist on unhealthy backends only for connection-oriented protocols (TCP and SCTP) and only if the Tracking Mode is PER_CONNECTION (default tracking mode) or the Session Affinity is configured for 5-tuple. They do not persist for UDP. If set to NEVER_PERSIST, after a backend becomes unhealthy, the existing connections on the unhealthy backend are never persisted on the unhealthy backend. They are always diverted to newly selected healthy backends (unless all backends are unhealthy). If set to ALWAYS_PERSIST, existing connections always persist on unhealthy backends regardless of protocol and session affinity. It is generally not recommended to use this mode overriding the default. For more details, see [Connection Persistence for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#connection-persistence) and [Connection Persistence for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#connection-persistence).
:param pulumi.Input[bool] enable_strong_affinity: Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.
:param pulumi.Input[int] idle_timeout_sec: Specifies how long to keep a Connection Tracking entry while there is no matching traffic (in seconds). For Internal TCP/UDP Load Balancing: - The minimum (default) is 10 minutes and the maximum is 16 hours. - It can be set only if Connection Tracking is less than 5-tuple (i.e. Session Affinity is CLIENT_IP_NO_DESTINATION, CLIENT_IP or CLIENT_IP_PROTO, and Tracking Mode is PER_SESSION). For Network Load Balancer the default is 60 seconds. This option is not available publicly.
:param pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode'] tracking_mode: Specifies the key used for connection tracking. There are two options: - PER_CONNECTION: This is the default mode. The Connection Tracking is performed as per the Connection Key (default Hash Method) for the specific protocol. - PER_SESSION: The Connection Tracking is performed as per the configured Session Affinity. It matches the configured Session Affinity. For more details, see [Tracking Mode for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#tracking-mode) and [Tracking Mode for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#tracking-mode).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, connection_persistence_on_unhealthy_backends: Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends']]=None, enable_strong_affinity: Optional[pulumi.Input[bool]]=None, idle_timeout_sec: Optional[pulumi.Input[int]]=None, tracking_mode: Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode']]=None):
"\n Connection Tracking configuration for this BackendService.\n :param pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends'] connection_persistence_on_unhealthy_backends: Specifies connection persistence when backends are unhealthy. The default value is DEFAULT_FOR_PROTOCOL. If set to DEFAULT_FOR_PROTOCOL, the existing connections persist on unhealthy backends only for connection-oriented protocols (TCP and SCTP) and only if the Tracking Mode is PER_CONNECTION (default tracking mode) or the Session Affinity is configured for 5-tuple. They do not persist for UDP. If set to NEVER_PERSIST, after a backend becomes unhealthy, the existing connections on the unhealthy backend are never persisted on the unhealthy backend. They are always diverted to newly selected healthy backends (unless all backends are unhealthy). If set to ALWAYS_PERSIST, existing connections always persist on unhealthy backends regardless of protocol and session affinity. It is generally not recommended to use this mode overriding the default. For more details, see [Connection Persistence for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#connection-persistence) and [Connection Persistence for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#connection-persistence).\n :param pulumi.Input[bool] enable_strong_affinity: Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.\n :param pulumi.Input[int] idle_timeout_sec: Specifies how long to keep a Connection Tracking entry while there is no matching traffic (in seconds). For Internal TCP/UDP Load Balancing: - The minimum (default) is 10 minutes and the maximum is 16 hours. - It can be set only if Connection Tracking is less than 5-tuple (i.e. Session Affinity is CLIENT_IP_NO_DESTINATION, CLIENT_IP or CLIENT_IP_PROTO, and Tracking Mode is PER_SESSION). For Network Load Balancer the default is 60 seconds. This option is not available publicly.\n :param pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode'] tracking_mode: Specifies the key used for connection tracking. There are two options: - PER_CONNECTION: This is the default mode. The Connection Tracking is performed as per the Connection Key (default Hash Method) for the specific protocol. - PER_SESSION: The Connection Tracking is performed as per the configured Session Affinity. It matches the configured Session Affinity. For more details, see [Tracking Mode for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#tracking-mode) and [Tracking Mode for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#tracking-mode).\n "
if (connection_persistence_on_unhealthy_backends is not None):
pulumi.set(__self__, 'connection_persistence_on_unhealthy_backends', connection_persistence_on_unhealthy_backends)
if (enable_strong_affinity is not None):
pulumi.set(__self__, 'enable_strong_affinity', enable_strong_affinity)
if (idle_timeout_sec is not None):
pulumi.set(__self__, 'idle_timeout_sec', idle_timeout_sec)
if (tracking_mode is not None):
pulumi.set(__self__, 'tracking_mode', tracking_mode)
|
@property
@pulumi.getter(name='connectionPersistenceOnUnhealthyBackends')
def connection_persistence_on_unhealthy_backends(self) -> Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends']]:
'\n Specifies connection persistence when backends are unhealthy. The default value is DEFAULT_FOR_PROTOCOL. If set to DEFAULT_FOR_PROTOCOL, the existing connections persist on unhealthy backends only for connection-oriented protocols (TCP and SCTP) and only if the Tracking Mode is PER_CONNECTION (default tracking mode) or the Session Affinity is configured for 5-tuple. They do not persist for UDP. If set to NEVER_PERSIST, after a backend becomes unhealthy, the existing connections on the unhealthy backend are never persisted on the unhealthy backend. They are always diverted to newly selected healthy backends (unless all backends are unhealthy). If set to ALWAYS_PERSIST, existing connections always persist on unhealthy backends regardless of protocol and session affinity. It is generally not recommended to use this mode overriding the default. For more details, see [Connection Persistence for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#connection-persistence) and [Connection Persistence for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#connection-persistence).\n '
return pulumi.get(self, 'connection_persistence_on_unhealthy_backends')
| 1,409,351,243,232,961,000
|
Specifies connection persistence when backends are unhealthy. The default value is DEFAULT_FOR_PROTOCOL. If set to DEFAULT_FOR_PROTOCOL, the existing connections persist on unhealthy backends only for connection-oriented protocols (TCP and SCTP) and only if the Tracking Mode is PER_CONNECTION (default tracking mode) or the Session Affinity is configured for 5-tuple. They do not persist for UDP. If set to NEVER_PERSIST, after a backend becomes unhealthy, the existing connections on the unhealthy backend are never persisted on the unhealthy backend. They are always diverted to newly selected healthy backends (unless all backends are unhealthy). If set to ALWAYS_PERSIST, existing connections always persist on unhealthy backends regardless of protocol and session affinity. It is generally not recommended to use this mode overriding the default. For more details, see [Connection Persistence for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#connection-persistence) and [Connection Persistence for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#connection-persistence).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
connection_persistence_on_unhealthy_backends
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='connectionPersistenceOnUnhealthyBackends')
def connection_persistence_on_unhealthy_backends(self) -> Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends']]:
'\n \n '
return pulumi.get(self, 'connection_persistence_on_unhealthy_backends')
|
@property
@pulumi.getter(name='enableStrongAffinity')
def enable_strong_affinity(self) -> Optional[pulumi.Input[bool]]:
'\n Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.\n '
return pulumi.get(self, 'enable_strong_affinity')
| 5,950,112,157,441,820,000
|
Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enable_strong_affinity
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='enableStrongAffinity')
def enable_strong_affinity(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'enable_strong_affinity')
|
@property
@pulumi.getter(name='idleTimeoutSec')
def idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Specifies how long to keep a Connection Tracking entry while there is no matching traffic (in seconds). For Internal TCP/UDP Load Balancing: - The minimum (default) is 10 minutes and the maximum is 16 hours. - It can be set only if Connection Tracking is less than 5-tuple (i.e. Session Affinity is CLIENT_IP_NO_DESTINATION, CLIENT_IP or CLIENT_IP_PROTO, and Tracking Mode is PER_SESSION). For Network Load Balancer the default is 60 seconds. This option is not available publicly.\n '
return pulumi.get(self, 'idle_timeout_sec')
| -8,647,725,043,092,595,000
|
Specifies how long to keep a Connection Tracking entry while there is no matching traffic (in seconds). For Internal TCP/UDP Load Balancing: - The minimum (default) is 10 minutes and the maximum is 16 hours. - It can be set only if Connection Tracking is less than 5-tuple (i.e. Session Affinity is CLIENT_IP_NO_DESTINATION, CLIENT_IP or CLIENT_IP_PROTO, and Tracking Mode is PER_SESSION). For Network Load Balancer the default is 60 seconds. This option is not available publicly.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
idle_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='idleTimeoutSec')
def idle_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'idle_timeout_sec')
|
@property
@pulumi.getter(name='trackingMode')
def tracking_mode(self) -> Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode']]:
'\n Specifies the key used for connection tracking. There are two options: - PER_CONNECTION: This is the default mode. The Connection Tracking is performed as per the Connection Key (default Hash Method) for the specific protocol. - PER_SESSION: The Connection Tracking is performed as per the configured Session Affinity. It matches the configured Session Affinity. For more details, see [Tracking Mode for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#tracking-mode) and [Tracking Mode for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#tracking-mode).\n '
return pulumi.get(self, 'tracking_mode')
| -211,406,152,355,965,600
|
Specifies the key used for connection tracking. There are two options: - PER_CONNECTION: This is the default mode. The Connection Tracking is performed as per the Connection Key (default Hash Method) for the specific protocol. - PER_SESSION: The Connection Tracking is performed as per the configured Session Affinity. It matches the configured Session Affinity. For more details, see [Tracking Mode for Network Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-backend-service#tracking-mode) and [Tracking Mode for Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal#tracking-mode).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
tracking_mode
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='trackingMode')
def tracking_mode(self) -> Optional[pulumi.Input['BackendServiceConnectionTrackingPolicyTrackingMode']]:
'\n \n '
return pulumi.get(self, 'tracking_mode')
|
def __init__(__self__, *, disable_connection_drain_on_failover: Optional[pulumi.Input[bool]]=None, drop_traffic_if_unhealthy: Optional[pulumi.Input[bool]]=None, failover_ratio: Optional[pulumi.Input[float]]=None):
'\n For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). On failover or failback, this field indicates whether connection draining will be honored. Google Cloud has a fixed connection draining timeout of 10 minutes. A setting of true terminates existing TCP connections to the active pool during failover and failback, immediately draining traffic. A setting of false allows existing TCP connections to persist, even on VMs no longer in the active pool, for up to the duration of the connection draining timeout (10 minutes).\n :param pulumi.Input[bool] disable_connection_drain_on_failover: This can be set to true only if the protocol is TCP. The default is false.\n :param pulumi.Input[bool] drop_traffic_if_unhealthy: If set to true, connections to the load balancer are dropped when all primary and all backup backend VMs are unhealthy.If set to false, connections are distributed among all primary VMs when all primary and all backup backend VMs are unhealthy. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). The default is false.\n :param pulumi.Input[float] failover_ratio: The value of the field must be in the range [0, 1]. If the value is 0, the load balancer performs a failover when the number of healthy primary VMs equals zero. For all other values, the load balancer performs a failover when the total number of healthy primary VMs is less than this ratio. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).\n '
if (disable_connection_drain_on_failover is not None):
pulumi.set(__self__, 'disable_connection_drain_on_failover', disable_connection_drain_on_failover)
if (drop_traffic_if_unhealthy is not None):
pulumi.set(__self__, 'drop_traffic_if_unhealthy', drop_traffic_if_unhealthy)
if (failover_ratio is not None):
pulumi.set(__self__, 'failover_ratio', failover_ratio)
| 2,211,686,745,661,544,200
|
For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). On failover or failback, this field indicates whether connection draining will be honored. Google Cloud has a fixed connection draining timeout of 10 minutes. A setting of true terminates existing TCP connections to the active pool during failover and failback, immediately draining traffic. A setting of false allows existing TCP connections to persist, even on VMs no longer in the active pool, for up to the duration of the connection draining timeout (10 minutes).
:param pulumi.Input[bool] disable_connection_drain_on_failover: This can be set to true only if the protocol is TCP. The default is false.
:param pulumi.Input[bool] drop_traffic_if_unhealthy: If set to true, connections to the load balancer are dropped when all primary and all backup backend VMs are unhealthy.If set to false, connections are distributed among all primary VMs when all primary and all backup backend VMs are unhealthy. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). The default is false.
:param pulumi.Input[float] failover_ratio: The value of the field must be in the range [0, 1]. If the value is 0, the load balancer performs a failover when the number of healthy primary VMs equals zero. For all other values, the load balancer performs a failover when the total number of healthy primary VMs is less than this ratio. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, disable_connection_drain_on_failover: Optional[pulumi.Input[bool]]=None, drop_traffic_if_unhealthy: Optional[pulumi.Input[bool]]=None, failover_ratio: Optional[pulumi.Input[float]]=None):
'\n For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). On failover or failback, this field indicates whether connection draining will be honored. Google Cloud has a fixed connection draining timeout of 10 minutes. A setting of true terminates existing TCP connections to the active pool during failover and failback, immediately draining traffic. A setting of false allows existing TCP connections to persist, even on VMs no longer in the active pool, for up to the duration of the connection draining timeout (10 minutes).\n :param pulumi.Input[bool] disable_connection_drain_on_failover: This can be set to true only if the protocol is TCP. The default is false.\n :param pulumi.Input[bool] drop_traffic_if_unhealthy: If set to true, connections to the load balancer are dropped when all primary and all backup backend VMs are unhealthy.If set to false, connections are distributed among all primary VMs when all primary and all backup backend VMs are unhealthy. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). The default is false.\n :param pulumi.Input[float] failover_ratio: The value of the field must be in the range [0, 1]. If the value is 0, the load balancer performs a failover when the number of healthy primary VMs equals zero. For all other values, the load balancer performs a failover when the total number of healthy primary VMs is less than this ratio. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).\n '
if (disable_connection_drain_on_failover is not None):
pulumi.set(__self__, 'disable_connection_drain_on_failover', disable_connection_drain_on_failover)
if (drop_traffic_if_unhealthy is not None):
pulumi.set(__self__, 'drop_traffic_if_unhealthy', drop_traffic_if_unhealthy)
if (failover_ratio is not None):
pulumi.set(__self__, 'failover_ratio', failover_ratio)
|
@property
@pulumi.getter(name='disableConnectionDrainOnFailover')
def disable_connection_drain_on_failover(self) -> Optional[pulumi.Input[bool]]:
'\n This can be set to true only if the protocol is TCP. The default is false.\n '
return pulumi.get(self, 'disable_connection_drain_on_failover')
| 1,148,333,612,609,719,000
|
This can be set to true only if the protocol is TCP. The default is false.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
disable_connection_drain_on_failover
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='disableConnectionDrainOnFailover')
def disable_connection_drain_on_failover(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'disable_connection_drain_on_failover')
|
@property
@pulumi.getter(name='dropTrafficIfUnhealthy')
def drop_traffic_if_unhealthy(self) -> Optional[pulumi.Input[bool]]:
'\n If set to true, connections to the load balancer are dropped when all primary and all backup backend VMs are unhealthy.If set to false, connections are distributed among all primary VMs when all primary and all backup backend VMs are unhealthy. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). The default is false.\n '
return pulumi.get(self, 'drop_traffic_if_unhealthy')
| -8,927,352,690,569,201,000
|
If set to true, connections to the load balancer are dropped when all primary and all backup backend VMs are unhealthy.If set to false, connections are distributed among all primary VMs when all primary and all backup backend VMs are unhealthy. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). The default is false.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
drop_traffic_if_unhealthy
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='dropTrafficIfUnhealthy')
def drop_traffic_if_unhealthy(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'drop_traffic_if_unhealthy')
|
@property
@pulumi.getter(name='failoverRatio')
def failover_ratio(self) -> Optional[pulumi.Input[float]]:
'\n The value of the field must be in the range [0, 1]. If the value is 0, the load balancer performs a failover when the number of healthy primary VMs equals zero. For all other values, the load balancer performs a failover when the total number of healthy primary VMs is less than this ratio. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).\n '
return pulumi.get(self, 'failover_ratio')
| -3,470,401,804,743,568,400
|
The value of the field must be in the range [0, 1]. If the value is 0, the load balancer performs a failover when the number of healthy primary VMs equals zero. For all other values, the load balancer performs a failover when the total number of healthy primary VMs is less than this ratio. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
failover_ratio
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='failoverRatio')
def failover_ratio(self) -> Optional[pulumi.Input[float]]:
'\n \n '
return pulumi.get(self, 'failover_ratio')
|
def __init__(__self__, *, application_name: Optional[pulumi.Input[str]]=None, client_name: Optional[pulumi.Input[str]]=None, developer_email_address: Optional[pulumi.Input[str]]=None):
"\n :param pulumi.Input[str] application_name: Application name to be used in OAuth consent screen.\n :param pulumi.Input[str] client_name: Name of the client to be generated. Optional - If not provided, the name will be autogenerated by the backend.\n :param pulumi.Input[str] developer_email_address: Developer's information to be used in OAuth consent screen.\n "
if (application_name is not None):
pulumi.set(__self__, 'application_name', application_name)
if (client_name is not None):
pulumi.set(__self__, 'client_name', client_name)
if (developer_email_address is not None):
pulumi.set(__self__, 'developer_email_address', developer_email_address)
| -168,165,785,226,400,500
|
:param pulumi.Input[str] application_name: Application name to be used in OAuth consent screen.
:param pulumi.Input[str] client_name: Name of the client to be generated. Optional - If not provided, the name will be autogenerated by the backend.
:param pulumi.Input[str] developer_email_address: Developer's information to be used in OAuth consent screen.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, application_name: Optional[pulumi.Input[str]]=None, client_name: Optional[pulumi.Input[str]]=None, developer_email_address: Optional[pulumi.Input[str]]=None):
"\n :param pulumi.Input[str] application_name: Application name to be used in OAuth consent screen.\n :param pulumi.Input[str] client_name: Name of the client to be generated. Optional - If not provided, the name will be autogenerated by the backend.\n :param pulumi.Input[str] developer_email_address: Developer's information to be used in OAuth consent screen.\n "
if (application_name is not None):
pulumi.set(__self__, 'application_name', application_name)
if (client_name is not None):
pulumi.set(__self__, 'client_name', client_name)
if (developer_email_address is not None):
pulumi.set(__self__, 'developer_email_address', developer_email_address)
|
@property
@pulumi.getter(name='applicationName')
def application_name(self) -> Optional[pulumi.Input[str]]:
'\n Application name to be used in OAuth consent screen.\n '
return pulumi.get(self, 'application_name')
| -8,787,151,845,847,726,000
|
Application name to be used in OAuth consent screen.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
application_name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='applicationName')
def application_name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'application_name')
|
@property
@pulumi.getter(name='clientName')
def client_name(self) -> Optional[pulumi.Input[str]]:
'\n Name of the client to be generated. Optional - If not provided, the name will be autogenerated by the backend.\n '
return pulumi.get(self, 'client_name')
| 3,889,198,448,823,095,300
|
Name of the client to be generated. Optional - If not provided, the name will be autogenerated by the backend.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
client_name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='clientName')
def client_name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'client_name')
|
@property
@pulumi.getter(name='developerEmailAddress')
def developer_email_address(self) -> Optional[pulumi.Input[str]]:
"\n Developer's information to be used in OAuth consent screen.\n "
return pulumi.get(self, 'developer_email_address')
| -1,016,487,369,619,638,800
|
Developer's information to be used in OAuth consent screen.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
developer_email_address
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='developerEmailAddress')
def developer_email_address(self) -> Optional[pulumi.Input[str]]:
"\n \n "
return pulumi.get(self, 'developer_email_address')
|
def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None, oauth2_client_id: Optional[pulumi.Input[str]]=None, oauth2_client_info: Optional[pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs']]=None, oauth2_client_secret: Optional[pulumi.Input[str]]=None):
"\n Identity-Aware Proxy\n :param pulumi.Input[bool] enabled: Whether the serving infrastructure will authenticate and authorize all incoming requests. If true, the oauth2ClientId and oauth2ClientSecret fields must be non-empty.\n :param pulumi.Input[str] oauth2_client_id: OAuth2 client ID to use for the authentication flow.\n :param pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs'] oauth2_client_info: [Input Only] OAuth client info required to generate client id to be used for IAP.\n :param pulumi.Input[str] oauth2_client_secret: OAuth2 client secret to use for the authentication flow. For security reasons, this value cannot be retrieved via the API. Instead, the SHA-256 hash of the value is returned in the oauth2ClientSecretSha256 field. @InputOnly\n "
if (enabled is not None):
pulumi.set(__self__, 'enabled', enabled)
if (oauth2_client_id is not None):
pulumi.set(__self__, 'oauth2_client_id', oauth2_client_id)
if (oauth2_client_info is not None):
pulumi.set(__self__, 'oauth2_client_info', oauth2_client_info)
if (oauth2_client_secret is not None):
pulumi.set(__self__, 'oauth2_client_secret', oauth2_client_secret)
| 3,302,621,020,153,561,000
|
Identity-Aware Proxy
:param pulumi.Input[bool] enabled: Whether the serving infrastructure will authenticate and authorize all incoming requests. If true, the oauth2ClientId and oauth2ClientSecret fields must be non-empty.
:param pulumi.Input[str] oauth2_client_id: OAuth2 client ID to use for the authentication flow.
:param pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs'] oauth2_client_info: [Input Only] OAuth client info required to generate client id to be used for IAP.
:param pulumi.Input[str] oauth2_client_secret: OAuth2 client secret to use for the authentication flow. For security reasons, this value cannot be retrieved via the API. Instead, the SHA-256 hash of the value is returned in the oauth2ClientSecretSha256 field. @InputOnly
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, enabled: Optional[pulumi.Input[bool]]=None, oauth2_client_id: Optional[pulumi.Input[str]]=None, oauth2_client_info: Optional[pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs']]=None, oauth2_client_secret: Optional[pulumi.Input[str]]=None):
"\n Identity-Aware Proxy\n :param pulumi.Input[bool] enabled: Whether the serving infrastructure will authenticate and authorize all incoming requests. If true, the oauth2ClientId and oauth2ClientSecret fields must be non-empty.\n :param pulumi.Input[str] oauth2_client_id: OAuth2 client ID to use for the authentication flow.\n :param pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs'] oauth2_client_info: [Input Only] OAuth client info required to generate client id to be used for IAP.\n :param pulumi.Input[str] oauth2_client_secret: OAuth2 client secret to use for the authentication flow. For security reasons, this value cannot be retrieved via the API. Instead, the SHA-256 hash of the value is returned in the oauth2ClientSecretSha256 field. @InputOnly\n "
if (enabled is not None):
pulumi.set(__self__, 'enabled', enabled)
if (oauth2_client_id is not None):
pulumi.set(__self__, 'oauth2_client_id', oauth2_client_id)
if (oauth2_client_info is not None):
pulumi.set(__self__, 'oauth2_client_info', oauth2_client_info)
if (oauth2_client_secret is not None):
pulumi.set(__self__, 'oauth2_client_secret', oauth2_client_secret)
|
@property
@pulumi.getter
def enabled(self) -> Optional[pulumi.Input[bool]]:
'\n Whether the serving infrastructure will authenticate and authorize all incoming requests. If true, the oauth2ClientId and oauth2ClientSecret fields must be non-empty.\n '
return pulumi.get(self, 'enabled')
| -5,541,381,183,144,456,000
|
Whether the serving infrastructure will authenticate and authorize all incoming requests. If true, the oauth2ClientId and oauth2ClientSecret fields must be non-empty.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enabled
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def enabled(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'enabled')
|
@property
@pulumi.getter(name='oauth2ClientId')
def oauth2_client_id(self) -> Optional[pulumi.Input[str]]:
'\n OAuth2 client ID to use for the authentication flow.\n '
return pulumi.get(self, 'oauth2_client_id')
| 3,995,475,657,512,980,500
|
OAuth2 client ID to use for the authentication flow.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
oauth2_client_id
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='oauth2ClientId')
def oauth2_client_id(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'oauth2_client_id')
|
@property
@pulumi.getter(name='oauth2ClientInfo')
def oauth2_client_info(self) -> Optional[pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs']]:
'\n [Input Only] OAuth client info required to generate client id to be used for IAP.\n '
return pulumi.get(self, 'oauth2_client_info')
| 4,224,446,881,951,416,000
|
[Input Only] OAuth client info required to generate client id to be used for IAP.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
oauth2_client_info
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='oauth2ClientInfo')
def oauth2_client_info(self) -> Optional[pulumi.Input['BackendServiceIAPOAuth2ClientInfoArgs']]:
'\n \n '
return pulumi.get(self, 'oauth2_client_info')
|
@property
@pulumi.getter(name='oauth2ClientSecret')
def oauth2_client_secret(self) -> Optional[pulumi.Input[str]]:
'\n OAuth2 client secret to use for the authentication flow. For security reasons, this value cannot be retrieved via the API. Instead, the SHA-256 hash of the value is returned in the oauth2ClientSecretSha256 field. @InputOnly\n '
return pulumi.get(self, 'oauth2_client_secret')
| 5,368,539,521,055,534,000
|
OAuth2 client secret to use for the authentication flow. For security reasons, this value cannot be retrieved via the API. Instead, the SHA-256 hash of the value is returned in the oauth2ClientSecretSha256 field. @InputOnly
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
oauth2_client_secret
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='oauth2ClientSecret')
def oauth2_client_secret(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'oauth2_client_secret')
|
def __init__(__self__, *, enable: Optional[pulumi.Input[bool]]=None, sample_rate: Optional[pulumi.Input[float]]=None):
'\n The available logging options for the load balancer traffic served by this backend service.\n :param pulumi.Input[bool] enable: This field denotes whether to enable logging for the load balancer traffic served by this backend service.\n :param pulumi.Input[float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0.\n '
if (enable is not None):
pulumi.set(__self__, 'enable', enable)
if (sample_rate is not None):
pulumi.set(__self__, 'sample_rate', sample_rate)
| -6,456,858,306,148,110,000
|
The available logging options for the load balancer traffic served by this backend service.
:param pulumi.Input[bool] enable: This field denotes whether to enable logging for the load balancer traffic served by this backend service.
:param pulumi.Input[float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, enable: Optional[pulumi.Input[bool]]=None, sample_rate: Optional[pulumi.Input[float]]=None):
'\n The available logging options for the load balancer traffic served by this backend service.\n :param pulumi.Input[bool] enable: This field denotes whether to enable logging for the load balancer traffic served by this backend service.\n :param pulumi.Input[float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0.\n '
if (enable is not None):
pulumi.set(__self__, 'enable', enable)
if (sample_rate is not None):
pulumi.set(__self__, 'sample_rate', sample_rate)
|
@property
@pulumi.getter
def enable(self) -> Optional[pulumi.Input[bool]]:
'\n This field denotes whether to enable logging for the load balancer traffic served by this backend service.\n '
return pulumi.get(self, 'enable')
| 7,895,757,518,915,116,000
|
This field denotes whether to enable logging for the load balancer traffic served by this backend service.
|
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(name='sampleRate')
def sample_rate(self) -> Optional[pulumi.Input[float]]:
'\n This field can only be specified if logging is enabled for this backend service. The value of the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0.\n '
return pulumi.get(self, 'sample_rate')
| 5,660,743,272,130,536,000
|
This field can only be specified if logging is enabled for this backend service. The value of the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
sample_rate
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='sampleRate')
def sample_rate(self) -> Optional[pulumi.Input[float]]:
'\n \n '
return pulumi.get(self, 'sample_rate')
|
def __init__(__self__, *, balancing_mode: Optional[pulumi.Input['BackendBalancingMode']]=None, capacity_scaler: Optional[pulumi.Input[float]]=None, description: Optional[pulumi.Input[str]]=None, failover: Optional[pulumi.Input[bool]]=None, group: Optional[pulumi.Input[str]]=None, max_connections: Optional[pulumi.Input[int]]=None, max_connections_per_endpoint: Optional[pulumi.Input[int]]=None, max_connections_per_instance: Optional[pulumi.Input[int]]=None, max_rate: Optional[pulumi.Input[int]]=None, max_rate_per_endpoint: Optional[pulumi.Input[float]]=None, max_rate_per_instance: Optional[pulumi.Input[float]]=None, max_utilization: Optional[pulumi.Input[float]]=None):
"\n Message containing information of one individual backend.\n :param pulumi.Input['BackendBalancingMode'] balancing_mode: Specifies how to determine whether the backend of a load balancer can handle additional traffic or is fully loaded. For usage guidelines, see Connection balancing mode. Backends must use compatible balancing modes. For more information, see Supported balancing modes and target capacity settings and Restrictions and guidance for instance groups. Note: Currently, if you use the API to configure incompatible balancing modes, the configuration might be accepted even though it has no impact and is ignored. Specifically, Backend.maxUtilization is ignored when Backend.balancingMode is RATE. In the future, this incompatible combination will be rejected.\n :param pulumi.Input[float] capacity_scaler: A multiplier applied to the backend's target capacity of its balancing mode. The default value is 1, which means the group serves up to 100% of its configured capacity (depending on balancingMode). A setting of 0 means the group is completely drained, offering 0% of its available capacity. The valid ranges are 0.0 and [0.1,1.0]. You cannot configure a setting larger than 0 and smaller than 0.1. You cannot configure a setting of 0 when there is only one backend attached to the backend service.\n :param pulumi.Input[str] description: An optional description of this resource. Provide this property when you create the resource.\n :param pulumi.Input[bool] failover: This field designates whether this is a failover backend. More than one failover backend can be configured for a given BackendService.\n :param pulumi.Input[str] group: The fully-qualified URL of an instance group or network endpoint group (NEG) resource. To determine what types of backends a load balancer supports, see the [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service#backends). You must use the *fully-qualified* URL (starting with https://www.googleapis.com/) to specify the instance group or NEG. Partial URLs are not supported.\n :param pulumi.Input[int] max_connections: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n :param pulumi.Input[int] max_connections_per_endpoint: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n :param pulumi.Input[int] max_connections_per_instance: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n :param pulumi.Input[int] max_rate: Defines a maximum number of HTTP requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n :param pulumi.Input[float] max_rate_per_endpoint: Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n :param pulumi.Input[float] max_rate_per_instance: Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n :param pulumi.Input[float] max_utilization: Optional parameter to define a target capacity for the UTILIZATIONbalancing mode. The valid range is [0.0, 1.0]. For usage guidelines, see Utilization balancing mode.\n "
if (balancing_mode is not None):
pulumi.set(__self__, 'balancing_mode', balancing_mode)
if (capacity_scaler is not None):
pulumi.set(__self__, 'capacity_scaler', capacity_scaler)
if (description is not None):
pulumi.set(__self__, 'description', description)
if (failover is not None):
pulumi.set(__self__, 'failover', failover)
if (group is not None):
pulumi.set(__self__, 'group', group)
if (max_connections is not None):
pulumi.set(__self__, 'max_connections', max_connections)
if (max_connections_per_endpoint is not None):
pulumi.set(__self__, 'max_connections_per_endpoint', max_connections_per_endpoint)
if (max_connections_per_instance is not None):
pulumi.set(__self__, 'max_connections_per_instance', max_connections_per_instance)
if (max_rate is not None):
pulumi.set(__self__, 'max_rate', max_rate)
if (max_rate_per_endpoint is not None):
pulumi.set(__self__, 'max_rate_per_endpoint', max_rate_per_endpoint)
if (max_rate_per_instance is not None):
pulumi.set(__self__, 'max_rate_per_instance', max_rate_per_instance)
if (max_utilization is not None):
pulumi.set(__self__, 'max_utilization', max_utilization)
| 1,681,049,215,508,758,500
|
Message containing information of one individual backend.
:param pulumi.Input['BackendBalancingMode'] balancing_mode: Specifies how to determine whether the backend of a load balancer can handle additional traffic or is fully loaded. For usage guidelines, see Connection balancing mode. Backends must use compatible balancing modes. For more information, see Supported balancing modes and target capacity settings and Restrictions and guidance for instance groups. Note: Currently, if you use the API to configure incompatible balancing modes, the configuration might be accepted even though it has no impact and is ignored. Specifically, Backend.maxUtilization is ignored when Backend.balancingMode is RATE. In the future, this incompatible combination will be rejected.
:param pulumi.Input[float] capacity_scaler: A multiplier applied to the backend's target capacity of its balancing mode. The default value is 1, which means the group serves up to 100% of its configured capacity (depending on balancingMode). A setting of 0 means the group is completely drained, offering 0% of its available capacity. The valid ranges are 0.0 and [0.1,1.0]. You cannot configure a setting larger than 0 and smaller than 0.1. You cannot configure a setting of 0 when there is only one backend attached to the backend service.
:param pulumi.Input[str] description: An optional description of this resource. Provide this property when you create the resource.
:param pulumi.Input[bool] failover: This field designates whether this is a failover backend. More than one failover backend can be configured for a given BackendService.
:param pulumi.Input[str] group: The fully-qualified URL of an instance group or network endpoint group (NEG) resource. To determine what types of backends a load balancer supports, see the [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service#backends). You must use the *fully-qualified* URL (starting with https://www.googleapis.com/) to specify the instance group or NEG. Partial URLs are not supported.
:param pulumi.Input[int] max_connections: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.
:param pulumi.Input[int] max_connections_per_endpoint: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.
:param pulumi.Input[int] max_connections_per_instance: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.
:param pulumi.Input[int] max_rate: Defines a maximum number of HTTP requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.
:param pulumi.Input[float] max_rate_per_endpoint: Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.
:param pulumi.Input[float] max_rate_per_instance: Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.
:param pulumi.Input[float] max_utilization: Optional parameter to define a target capacity for the UTILIZATIONbalancing mode. The valid range is [0.0, 1.0]. For usage guidelines, see Utilization balancing mode.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, balancing_mode: Optional[pulumi.Input['BackendBalancingMode']]=None, capacity_scaler: Optional[pulumi.Input[float]]=None, description: Optional[pulumi.Input[str]]=None, failover: Optional[pulumi.Input[bool]]=None, group: Optional[pulumi.Input[str]]=None, max_connections: Optional[pulumi.Input[int]]=None, max_connections_per_endpoint: Optional[pulumi.Input[int]]=None, max_connections_per_instance: Optional[pulumi.Input[int]]=None, max_rate: Optional[pulumi.Input[int]]=None, max_rate_per_endpoint: Optional[pulumi.Input[float]]=None, max_rate_per_instance: Optional[pulumi.Input[float]]=None, max_utilization: Optional[pulumi.Input[float]]=None):
"\n Message containing information of one individual backend.\n :param pulumi.Input['BackendBalancingMode'] balancing_mode: Specifies how to determine whether the backend of a load balancer can handle additional traffic or is fully loaded. For usage guidelines, see Connection balancing mode. Backends must use compatible balancing modes. For more information, see Supported balancing modes and target capacity settings and Restrictions and guidance for instance groups. Note: Currently, if you use the API to configure incompatible balancing modes, the configuration might be accepted even though it has no impact and is ignored. Specifically, Backend.maxUtilization is ignored when Backend.balancingMode is RATE. In the future, this incompatible combination will be rejected.\n :param pulumi.Input[float] capacity_scaler: A multiplier applied to the backend's target capacity of its balancing mode. The default value is 1, which means the group serves up to 100% of its configured capacity (depending on balancingMode). A setting of 0 means the group is completely drained, offering 0% of its available capacity. The valid ranges are 0.0 and [0.1,1.0]. You cannot configure a setting larger than 0 and smaller than 0.1. You cannot configure a setting of 0 when there is only one backend attached to the backend service.\n :param pulumi.Input[str] description: An optional description of this resource. Provide this property when you create the resource.\n :param pulumi.Input[bool] failover: This field designates whether this is a failover backend. More than one failover backend can be configured for a given BackendService.\n :param pulumi.Input[str] group: The fully-qualified URL of an instance group or network endpoint group (NEG) resource. To determine what types of backends a load balancer supports, see the [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service#backends). You must use the *fully-qualified* URL (starting with https://www.googleapis.com/) to specify the instance group or NEG. Partial URLs are not supported.\n :param pulumi.Input[int] max_connections: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n :param pulumi.Input[int] max_connections_per_endpoint: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n :param pulumi.Input[int] max_connections_per_instance: Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n :param pulumi.Input[int] max_rate: Defines a maximum number of HTTP requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n :param pulumi.Input[float] max_rate_per_endpoint: Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n :param pulumi.Input[float] max_rate_per_instance: Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n :param pulumi.Input[float] max_utilization: Optional parameter to define a target capacity for the UTILIZATIONbalancing mode. The valid range is [0.0, 1.0]. For usage guidelines, see Utilization balancing mode.\n "
if (balancing_mode is not None):
pulumi.set(__self__, 'balancing_mode', balancing_mode)
if (capacity_scaler is not None):
pulumi.set(__self__, 'capacity_scaler', capacity_scaler)
if (description is not None):
pulumi.set(__self__, 'description', description)
if (failover is not None):
pulumi.set(__self__, 'failover', failover)
if (group is not None):
pulumi.set(__self__, 'group', group)
if (max_connections is not None):
pulumi.set(__self__, 'max_connections', max_connections)
if (max_connections_per_endpoint is not None):
pulumi.set(__self__, 'max_connections_per_endpoint', max_connections_per_endpoint)
if (max_connections_per_instance is not None):
pulumi.set(__self__, 'max_connections_per_instance', max_connections_per_instance)
if (max_rate is not None):
pulumi.set(__self__, 'max_rate', max_rate)
if (max_rate_per_endpoint is not None):
pulumi.set(__self__, 'max_rate_per_endpoint', max_rate_per_endpoint)
if (max_rate_per_instance is not None):
pulumi.set(__self__, 'max_rate_per_instance', max_rate_per_instance)
if (max_utilization is not None):
pulumi.set(__self__, 'max_utilization', max_utilization)
|
@property
@pulumi.getter(name='balancingMode')
def balancing_mode(self) -> Optional[pulumi.Input['BackendBalancingMode']]:
'\n Specifies how to determine whether the backend of a load balancer can handle additional traffic or is fully loaded. For usage guidelines, see Connection balancing mode. Backends must use compatible balancing modes. For more information, see Supported balancing modes and target capacity settings and Restrictions and guidance for instance groups. Note: Currently, if you use the API to configure incompatible balancing modes, the configuration might be accepted even though it has no impact and is ignored. Specifically, Backend.maxUtilization is ignored when Backend.balancingMode is RATE. In the future, this incompatible combination will be rejected.\n '
return pulumi.get(self, 'balancing_mode')
| -5,482,838,792,931,067,000
|
Specifies how to determine whether the backend of a load balancer can handle additional traffic or is fully loaded. For usage guidelines, see Connection balancing mode. Backends must use compatible balancing modes. For more information, see Supported balancing modes and target capacity settings and Restrictions and guidance for instance groups. Note: Currently, if you use the API to configure incompatible balancing modes, the configuration might be accepted even though it has no impact and is ignored. Specifically, Backend.maxUtilization is ignored when Backend.balancingMode is RATE. In the future, this incompatible combination will be rejected.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
balancing_mode
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='balancingMode')
def balancing_mode(self) -> Optional[pulumi.Input['BackendBalancingMode']]:
'\n \n '
return pulumi.get(self, 'balancing_mode')
|
@property
@pulumi.getter(name='capacityScaler')
def capacity_scaler(self) -> Optional[pulumi.Input[float]]:
"\n A multiplier applied to the backend's target capacity of its balancing mode. The default value is 1, which means the group serves up to 100% of its configured capacity (depending on balancingMode). A setting of 0 means the group is completely drained, offering 0% of its available capacity. The valid ranges are 0.0 and [0.1,1.0]. You cannot configure a setting larger than 0 and smaller than 0.1. You cannot configure a setting of 0 when there is only one backend attached to the backend service.\n "
return pulumi.get(self, 'capacity_scaler')
| 4,813,089,366,159,332,000
|
A multiplier applied to the backend's target capacity of its balancing mode. The default value is 1, which means the group serves up to 100% of its configured capacity (depending on balancingMode). A setting of 0 means the group is completely drained, offering 0% of its available capacity. The valid ranges are 0.0 and [0.1,1.0]. You cannot configure a setting larger than 0 and smaller than 0.1. You cannot configure a setting of 0 when there is only one backend attached to the backend service.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
capacity_scaler
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='capacityScaler')
def capacity_scaler(self) -> Optional[pulumi.Input[float]]:
"\n \n "
return pulumi.get(self, 'capacity_scaler')
|
@property
@pulumi.getter
def description(self) -> Optional[pulumi.Input[str]]:
'\n An optional description of this resource. Provide this property when you create the resource.\n '
return pulumi.get(self, 'description')
| -2,529,796,803,738,034,700
|
An optional description of this resource. Provide this property when you create the resource.
|
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 failover(self) -> Optional[pulumi.Input[bool]]:
'\n This field designates whether this is a failover backend. More than one failover backend can be configured for a given BackendService.\n '
return pulumi.get(self, 'failover')
| -5,305,271,153,839,311,000
|
This field designates whether this is a failover backend. More than one failover backend can be configured for a given BackendService.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
failover
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def failover(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'failover')
|
@property
@pulumi.getter
def group(self) -> Optional[pulumi.Input[str]]:
'\n The fully-qualified URL of an instance group or network endpoint group (NEG) resource. To determine what types of backends a load balancer supports, see the [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service#backends). You must use the *fully-qualified* URL (starting with https://www.googleapis.com/) to specify the instance group or NEG. Partial URLs are not supported.\n '
return pulumi.get(self, 'group')
| -5,332,979,928,007,285,000
|
The fully-qualified URL of an instance group or network endpoint group (NEG) resource. To determine what types of backends a load balancer supports, see the [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service#backends). You must use the *fully-qualified* URL (starting with https://www.googleapis.com/) to specify the instance group or NEG. Partial URLs are not supported.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
group
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def group(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'group')
|
@property
@pulumi.getter(name='maxConnections')
def max_connections(self) -> Optional[pulumi.Input[int]]:
"\n Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n "
return pulumi.get(self, 'max_connections')
| -1,892,850,349,073,865,000
|
Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_connections
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxConnections')
def max_connections(self) -> Optional[pulumi.Input[int]]:
"\n \n "
return pulumi.get(self, 'max_connections')
|
@property
@pulumi.getter(name='maxConnectionsPerEndpoint')
def max_connections_per_endpoint(self) -> Optional[pulumi.Input[int]]:
"\n Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n "
return pulumi.get(self, 'max_connections_per_endpoint')
| 3,216,313,083,383,264,000
|
Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_connections_per_endpoint
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxConnectionsPerEndpoint')
def max_connections_per_endpoint(self) -> Optional[pulumi.Input[int]]:
"\n \n "
return pulumi.get(self, 'max_connections_per_endpoint')
|
@property
@pulumi.getter(name='maxConnectionsPerInstance')
def max_connections_per_instance(self) -> Optional[pulumi.Input[int]]:
"\n Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.\n "
return pulumi.get(self, 'max_connections_per_instance')
| 7,071,319,734,630,168,000
|
Defines a target maximum number of simultaneous connections. For usage guidelines, see Connection balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is RATE.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_connections_per_instance
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxConnectionsPerInstance')
def max_connections_per_instance(self) -> Optional[pulumi.Input[int]]:
"\n \n "
return pulumi.get(self, 'max_connections_per_instance')
|
@property
@pulumi.getter(name='maxRate')
def max_rate(self) -> Optional[pulumi.Input[int]]:
"\n Defines a maximum number of HTTP requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n "
return pulumi.get(self, 'max_rate')
| 4,616,801,671,495,235,000
|
Defines a maximum number of HTTP requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_rate
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRate')
def max_rate(self) -> Optional[pulumi.Input[int]]:
"\n \n "
return pulumi.get(self, 'max_rate')
|
@property
@pulumi.getter(name='maxRatePerEndpoint')
def max_rate_per_endpoint(self) -> Optional[pulumi.Input[float]]:
"\n Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n "
return pulumi.get(self, 'max_rate_per_endpoint')
| 5,128,979,234,615,600,000
|
Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_rate_per_endpoint
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRatePerEndpoint')
def max_rate_per_endpoint(self) -> Optional[pulumi.Input[float]]:
"\n \n "
return pulumi.get(self, 'max_rate_per_endpoint')
|
@property
@pulumi.getter(name='maxRatePerInstance')
def max_rate_per_instance(self) -> Optional[pulumi.Input[float]]:
"\n Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.\n "
return pulumi.get(self, 'max_rate_per_instance')
| 6,007,030,917,044,903,000
|
Defines a maximum target for requests per second (RPS). For usage guidelines, see Rate balancing mode and Utilization balancing mode. Not available if the backend's balancingMode is CONNECTION.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_rate_per_instance
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRatePerInstance')
def max_rate_per_instance(self) -> Optional[pulumi.Input[float]]:
"\n \n "
return pulumi.get(self, 'max_rate_per_instance')
|
@property
@pulumi.getter(name='maxUtilization')
def max_utilization(self) -> Optional[pulumi.Input[float]]:
'\n Optional parameter to define a target capacity for the UTILIZATIONbalancing mode. The valid range is [0.0, 1.0]. For usage guidelines, see Utilization balancing mode.\n '
return pulumi.get(self, 'max_utilization')
| 2,870,472,718,075,897,300
|
Optional parameter to define a target capacity for the UTILIZATIONbalancing mode. The valid range is [0.0, 1.0]. For usage guidelines, see Utilization balancing mode.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_utilization
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxUtilization')
def max_utilization(self) -> Optional[pulumi.Input[float]]:
'\n \n '
return pulumi.get(self, 'max_utilization')
|
def __init__(__self__, *, binding_id: Optional[pulumi.Input[str]]=None, condition: Optional[pulumi.Input['ExprArgs']]=None, members: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, role: Optional[pulumi.Input[str]]=None):
"\n Associates `members`, or principals, with a `role`.\n :param pulumi.Input[str] binding_id: This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ExprArgs'] condition: The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).\n :param pulumi.Input[Sequence[pulumi.Input[str]]] members: Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, example@example.com.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. \n :param pulumi.Input[str] role: Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.\n "
if (binding_id is not None):
pulumi.set(__self__, 'binding_id', binding_id)
if (condition is not None):
pulumi.set(__self__, 'condition', condition)
if (members is not None):
pulumi.set(__self__, 'members', members)
if (role is not None):
pulumi.set(__self__, 'role', role)
| -19,701,830,681,015,930
|
Associates `members`, or principals, with a `role`.
:param pulumi.Input[str] binding_id: This is deprecated and has no effect. Do not use.
:param pulumi.Input['ExprArgs'] condition: The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
:param pulumi.Input[Sequence[pulumi.Input[str]]] members: Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, example@example.com.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
:param pulumi.Input[str] role: Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, binding_id: Optional[pulumi.Input[str]]=None, condition: Optional[pulumi.Input['ExprArgs']]=None, members: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, role: Optional[pulumi.Input[str]]=None):
"\n Associates `members`, or principals, with a `role`.\n :param pulumi.Input[str] binding_id: This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ExprArgs'] condition: The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).\n :param pulumi.Input[Sequence[pulumi.Input[str]]] members: Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, example@example.com.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. \n :param pulumi.Input[str] role: Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.\n "
if (binding_id is not None):
pulumi.set(__self__, 'binding_id', binding_id)
if (condition is not None):
pulumi.set(__self__, 'condition', condition)
if (members is not None):
pulumi.set(__self__, 'members', members)
if (role is not None):
pulumi.set(__self__, 'role', role)
|
@property
@pulumi.getter(name='bindingId')
def binding_id(self) -> Optional[pulumi.Input[str]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'binding_id')
| 1,185,394,240,722,588,400
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
binding_id
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='bindingId')
def binding_id(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'binding_id')
|
@property
@pulumi.getter
def condition(self) -> Optional[pulumi.Input['ExprArgs']]:
'\n The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).\n '
return pulumi.get(self, 'condition')
| 2,245,521,482,325,568,500
|
The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
condition
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def condition(self) -> Optional[pulumi.Input['ExprArgs']]:
'\n \n '
return pulumi.get(self, 'condition')
|
@property
@pulumi.getter
def members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, example@example.com.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. \n '
return pulumi.get(self, 'members')
| -9,134,363,411,387,648,000
|
Specifies the principals requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, example@example.com.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, example@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
members
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'members')
|
@property
@pulumi.getter
def role(self) -> Optional[pulumi.Input[str]]:
'\n Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.\n '
return pulumi.get(self, 'role')
| 1,585,069,071,171,494,000
|
Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
role
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def role(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'role')
|
def __init__(__self__, *, include_host: Optional[pulumi.Input[bool]]=None, include_http_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, include_named_cookies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, include_protocol: Optional[pulumi.Input[bool]]=None, include_query_string: Optional[pulumi.Input[bool]]=None, query_string_blacklist: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, query_string_whitelist: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n Message containing what to include in the cache key for a request for Cloud CDN.\n :param pulumi.Input[bool] include_host: If true, requests to different hosts will be cached separately.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] include_http_headers: Allows HTTP request headers (by name) to be used in the cache key.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] include_named_cookies: Allows HTTP cookies (by name) to be used in the cache key. The name=value pair will be used in the cache key Cloud CDN generates.\n :param pulumi.Input[bool] include_protocol: If true, http and https requests will be cached separately.\n :param pulumi.Input[bool] include_query_string: If true, include query string parameters in the cache key according to query_string_whitelist and query_string_blacklist. If neither is set, the entire query string will be included. If false, the query string will be excluded from the cache key entirely.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_blacklist: Names of query string parameters to exclude in cache keys. All other parameters will be included. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_whitelist: Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.\n "
if (include_host is not None):
pulumi.set(__self__, 'include_host', include_host)
if (include_http_headers is not None):
pulumi.set(__self__, 'include_http_headers', include_http_headers)
if (include_named_cookies is not None):
pulumi.set(__self__, 'include_named_cookies', include_named_cookies)
if (include_protocol is not None):
pulumi.set(__self__, 'include_protocol', include_protocol)
if (include_query_string is not None):
pulumi.set(__self__, 'include_query_string', include_query_string)
if (query_string_blacklist is not None):
pulumi.set(__self__, 'query_string_blacklist', query_string_blacklist)
if (query_string_whitelist is not None):
pulumi.set(__self__, 'query_string_whitelist', query_string_whitelist)
| -6,732,974,010,056,861,000
|
Message containing what to include in the cache key for a request for Cloud CDN.
:param pulumi.Input[bool] include_host: If true, requests to different hosts will be cached separately.
:param pulumi.Input[Sequence[pulumi.Input[str]]] include_http_headers: Allows HTTP request headers (by name) to be used in the cache key.
:param pulumi.Input[Sequence[pulumi.Input[str]]] include_named_cookies: Allows HTTP cookies (by name) to be used in the cache key. The name=value pair will be used in the cache key Cloud CDN generates.
:param pulumi.Input[bool] include_protocol: If true, http and https requests will be cached separately.
:param pulumi.Input[bool] include_query_string: If true, include query string parameters in the cache key according to query_string_whitelist and query_string_blacklist. If neither is set, the entire query string will be included. If false, the query string will be excluded from the cache key entirely.
:param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_blacklist: Names of query string parameters to exclude in cache keys. All other parameters will be included. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.
:param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_whitelist: Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, include_host: Optional[pulumi.Input[bool]]=None, include_http_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, include_named_cookies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, include_protocol: Optional[pulumi.Input[bool]]=None, include_query_string: Optional[pulumi.Input[bool]]=None, query_string_blacklist: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, query_string_whitelist: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n Message containing what to include in the cache key for a request for Cloud CDN.\n :param pulumi.Input[bool] include_host: If true, requests to different hosts will be cached separately.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] include_http_headers: Allows HTTP request headers (by name) to be used in the cache key.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] include_named_cookies: Allows HTTP cookies (by name) to be used in the cache key. The name=value pair will be used in the cache key Cloud CDN generates.\n :param pulumi.Input[bool] include_protocol: If true, http and https requests will be cached separately.\n :param pulumi.Input[bool] include_query_string: If true, include query string parameters in the cache key according to query_string_whitelist and query_string_blacklist. If neither is set, the entire query string will be included. If false, the query string will be excluded from the cache key entirely.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_blacklist: Names of query string parameters to exclude in cache keys. All other parameters will be included. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] query_string_whitelist: Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.\n "
if (include_host is not None):
pulumi.set(__self__, 'include_host', include_host)
if (include_http_headers is not None):
pulumi.set(__self__, 'include_http_headers', include_http_headers)
if (include_named_cookies is not None):
pulumi.set(__self__, 'include_named_cookies', include_named_cookies)
if (include_protocol is not None):
pulumi.set(__self__, 'include_protocol', include_protocol)
if (include_query_string is not None):
pulumi.set(__self__, 'include_query_string', include_query_string)
if (query_string_blacklist is not None):
pulumi.set(__self__, 'query_string_blacklist', query_string_blacklist)
if (query_string_whitelist is not None):
pulumi.set(__self__, 'query_string_whitelist', query_string_whitelist)
|
@property
@pulumi.getter(name='includeHost')
def include_host(self) -> Optional[pulumi.Input[bool]]:
'\n If true, requests to different hosts will be cached separately.\n '
return pulumi.get(self, 'include_host')
| 3,274,949,235,250,821,600
|
If true, requests to different hosts will be cached separately.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
include_host
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='includeHost')
def include_host(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'include_host')
|
@property
@pulumi.getter(name='includeHttpHeaders')
def include_http_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Allows HTTP request headers (by name) to be used in the cache key.\n '
return pulumi.get(self, 'include_http_headers')
| 68,200,754,198,893,220
|
Allows HTTP request headers (by name) to be used in the cache key.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
include_http_headers
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='includeHttpHeaders')
def include_http_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'include_http_headers')
|
@property
@pulumi.getter(name='includeNamedCookies')
def include_named_cookies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Allows HTTP cookies (by name) to be used in the cache key. The name=value pair will be used in the cache key Cloud CDN generates.\n '
return pulumi.get(self, 'include_named_cookies')
| -1,815,869,377,257,655,300
|
Allows HTTP cookies (by name) to be used in the cache key. The name=value pair will be used in the cache key Cloud CDN generates.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
include_named_cookies
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='includeNamedCookies')
def include_named_cookies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'include_named_cookies')
|
@property
@pulumi.getter(name='includeProtocol')
def include_protocol(self) -> Optional[pulumi.Input[bool]]:
'\n If true, http and https requests will be cached separately.\n '
return pulumi.get(self, 'include_protocol')
| -3,137,866,700,653,535,700
|
If true, http and https requests will be cached separately.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
include_protocol
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='includeProtocol')
def include_protocol(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'include_protocol')
|
@property
@pulumi.getter(name='includeQueryString')
def include_query_string(self) -> Optional[pulumi.Input[bool]]:
'\n If true, include query string parameters in the cache key according to query_string_whitelist and query_string_blacklist. If neither is set, the entire query string will be included. If false, the query string will be excluded from the cache key entirely.\n '
return pulumi.get(self, 'include_query_string')
| 365,005,727,067,363,460
|
If true, include query string parameters in the cache key according to query_string_whitelist and query_string_blacklist. If neither is set, the entire query string will be included. If false, the query string will be excluded from the cache key entirely.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
include_query_string
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='includeQueryString')
def include_query_string(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'include_query_string')
|
@property
@pulumi.getter(name='queryStringBlacklist')
def query_string_blacklist(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"\n Names of query string parameters to exclude in cache keys. All other parameters will be included. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.\n "
return pulumi.get(self, 'query_string_blacklist')
| 2,286,673,800,812,959,200
|
Names of query string parameters to exclude in cache keys. All other parameters will be included. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
query_string_blacklist
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='queryStringBlacklist')
def query_string_blacklist(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"\n \n "
return pulumi.get(self, 'query_string_blacklist')
|
@property
@pulumi.getter(name='queryStringWhitelist')
def query_string_whitelist(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"\n Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.\n "
return pulumi.get(self, 'query_string_whitelist')
| 7,434,839,725,413,765,000
|
Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify query_string_whitelist or query_string_blacklist, not both. '&' and '=' will be percent encoded and not treated as delimiters.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
query_string_whitelist
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='queryStringWhitelist')
def query_string_whitelist(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"\n \n "
return pulumi.get(self, 'query_string_whitelist')
|
def __init__(__self__, *, call_credential_type: Optional[pulumi.Input['CallCredentialsCallCredentialType']]=None, from_plugin: Optional[pulumi.Input['MetadataCredentialsFromPluginArgs']]=None):
"\n [Deprecated] gRPC call credentials to access the SDS server. gRPC call credentials to access the SDS server.\n :param pulumi.Input['CallCredentialsCallCredentialType'] call_credential_type: The type of call credentials to use for GRPC requests to the SDS server. This field can be set to one of the following: - GCE_VM: The local GCE VM service account credentials are used to access the SDS server. - FROM_PLUGIN: Custom authenticator credentials are used to access the SDS server.\n :param pulumi.Input['MetadataCredentialsFromPluginArgs'] from_plugin: Custom authenticator credentials. Valid if callCredentialType is FROM_PLUGIN.\n "
if (call_credential_type is not None):
pulumi.set(__self__, 'call_credential_type', call_credential_type)
if (from_plugin is not None):
pulumi.set(__self__, 'from_plugin', from_plugin)
| -1,292,203,736,488,974,600
|
[Deprecated] gRPC call credentials to access the SDS server. gRPC call credentials to access the SDS server.
:param pulumi.Input['CallCredentialsCallCredentialType'] call_credential_type: The type of call credentials to use for GRPC requests to the SDS server. This field can be set to one of the following: - GCE_VM: The local GCE VM service account credentials are used to access the SDS server. - FROM_PLUGIN: Custom authenticator credentials are used to access the SDS server.
:param pulumi.Input['MetadataCredentialsFromPluginArgs'] from_plugin: Custom authenticator credentials. Valid if callCredentialType is FROM_PLUGIN.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, call_credential_type: Optional[pulumi.Input['CallCredentialsCallCredentialType']]=None, from_plugin: Optional[pulumi.Input['MetadataCredentialsFromPluginArgs']]=None):
"\n [Deprecated] gRPC call credentials to access the SDS server. gRPC call credentials to access the SDS server.\n :param pulumi.Input['CallCredentialsCallCredentialType'] call_credential_type: The type of call credentials to use for GRPC requests to the SDS server. This field can be set to one of the following: - GCE_VM: The local GCE VM service account credentials are used to access the SDS server. - FROM_PLUGIN: Custom authenticator credentials are used to access the SDS server.\n :param pulumi.Input['MetadataCredentialsFromPluginArgs'] from_plugin: Custom authenticator credentials. Valid if callCredentialType is FROM_PLUGIN.\n "
if (call_credential_type is not None):
pulumi.set(__self__, 'call_credential_type', call_credential_type)
if (from_plugin is not None):
pulumi.set(__self__, 'from_plugin', from_plugin)
|
@property
@pulumi.getter(name='callCredentialType')
def call_credential_type(self) -> Optional[pulumi.Input['CallCredentialsCallCredentialType']]:
'\n The type of call credentials to use for GRPC requests to the SDS server. This field can be set to one of the following: - GCE_VM: The local GCE VM service account credentials are used to access the SDS server. - FROM_PLUGIN: Custom authenticator credentials are used to access the SDS server.\n '
return pulumi.get(self, 'call_credential_type')
| -2,330,224,380,156,651,000
|
The type of call credentials to use for GRPC requests to the SDS server. This field can be set to one of the following: - GCE_VM: The local GCE VM service account credentials are used to access the SDS server. - FROM_PLUGIN: Custom authenticator credentials are used to access the SDS server.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
call_credential_type
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='callCredentialType')
def call_credential_type(self) -> Optional[pulumi.Input['CallCredentialsCallCredentialType']]:
'\n \n '
return pulumi.get(self, 'call_credential_type')
|
@property
@pulumi.getter(name='fromPlugin')
def from_plugin(self) -> Optional[pulumi.Input['MetadataCredentialsFromPluginArgs']]:
'\n Custom authenticator credentials. Valid if callCredentialType is FROM_PLUGIN.\n '
return pulumi.get(self, 'from_plugin')
| -6,065,478,174,579,893,000
|
Custom authenticator credentials. Valid if callCredentialType is FROM_PLUGIN.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
from_plugin
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='fromPlugin')
def from_plugin(self) -> Optional[pulumi.Input['MetadataCredentialsFromPluginArgs']]:
'\n \n '
return pulumi.get(self, 'from_plugin')
|
def __init__(__self__, *, certificates: Optional[pulumi.Input['TlsCertificatePathsArgs']]=None, channel_credential_type: Optional[pulumi.Input['ChannelCredentialsChannelCredentialType']]=None):
"\n [Deprecated] gRPC channel credentials to access the SDS server. gRPC channel credentials to access the SDS server.\n :param pulumi.Input['TlsCertificatePathsArgs'] certificates: The call credentials to access the SDS server.\n :param pulumi.Input['ChannelCredentialsChannelCredentialType'] channel_credential_type: The channel credentials to access the SDS server. This field can be set to one of the following: CERTIFICATES: Use TLS certificates to access the SDS server. GCE_VM: Use local GCE VM credentials to access the SDS server.\n "
if (certificates is not None):
pulumi.set(__self__, 'certificates', certificates)
if (channel_credential_type is not None):
pulumi.set(__self__, 'channel_credential_type', channel_credential_type)
| -4,795,205,076,003,038,000
|
[Deprecated] gRPC channel credentials to access the SDS server. gRPC channel credentials to access the SDS server.
:param pulumi.Input['TlsCertificatePathsArgs'] certificates: The call credentials to access the SDS server.
:param pulumi.Input['ChannelCredentialsChannelCredentialType'] channel_credential_type: The channel credentials to access the SDS server. This field can be set to one of the following: CERTIFICATES: Use TLS certificates to access the SDS server. GCE_VM: Use local GCE VM credentials to access the SDS server.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, certificates: Optional[pulumi.Input['TlsCertificatePathsArgs']]=None, channel_credential_type: Optional[pulumi.Input['ChannelCredentialsChannelCredentialType']]=None):
"\n [Deprecated] gRPC channel credentials to access the SDS server. gRPC channel credentials to access the SDS server.\n :param pulumi.Input['TlsCertificatePathsArgs'] certificates: The call credentials to access the SDS server.\n :param pulumi.Input['ChannelCredentialsChannelCredentialType'] channel_credential_type: The channel credentials to access the SDS server. This field can be set to one of the following: CERTIFICATES: Use TLS certificates to access the SDS server. GCE_VM: Use local GCE VM credentials to access the SDS server.\n "
if (certificates is not None):
pulumi.set(__self__, 'certificates', certificates)
if (channel_credential_type is not None):
pulumi.set(__self__, 'channel_credential_type', channel_credential_type)
|
@property
@pulumi.getter
def certificates(self) -> Optional[pulumi.Input['TlsCertificatePathsArgs']]:
'\n The call credentials to access the SDS server.\n '
return pulumi.get(self, 'certificates')
| 6,041,749,909,231,287,000
|
The call credentials to access the SDS server.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
certificates
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def certificates(self) -> Optional[pulumi.Input['TlsCertificatePathsArgs']]:
'\n \n '
return pulumi.get(self, 'certificates')
|
@property
@pulumi.getter(name='channelCredentialType')
def channel_credential_type(self) -> Optional[pulumi.Input['ChannelCredentialsChannelCredentialType']]:
'\n The channel credentials to access the SDS server. This field can be set to one of the following: CERTIFICATES: Use TLS certificates to access the SDS server. GCE_VM: Use local GCE VM credentials to access the SDS server.\n '
return pulumi.get(self, 'channel_credential_type')
| 6,208,768,859,060,636,000
|
The channel credentials to access the SDS server. This field can be set to one of the following: CERTIFICATES: Use TLS certificates to access the SDS server. GCE_VM: Use local GCE VM credentials to access the SDS server.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
channel_credential_type
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='channelCredentialType')
def channel_credential_type(self) -> Optional[pulumi.Input['ChannelCredentialsChannelCredentialType']]:
'\n \n '
return pulumi.get(self, 'channel_credential_type')
|
def __init__(__self__, *, connect_timeout: Optional[pulumi.Input['DurationArgs']]=None, max_connections: Optional[pulumi.Input[int]]=None, max_pending_requests: Optional[pulumi.Input[int]]=None, max_requests: Optional[pulumi.Input[int]]=None, max_requests_per_connection: Optional[pulumi.Input[int]]=None, max_retries: Optional[pulumi.Input[int]]=None):
"\n Settings controlling the volume of requests, connections and retries to this backend service.\n :param pulumi.Input['DurationArgs'] connect_timeout: The timeout for new network connections to hosts.\n :param pulumi.Input[int] max_connections: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[int] max_pending_requests: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[int] max_requests: The maximum number of parallel requests that allowed to the backend service. If not specified, there is no limit.\n :param pulumi.Input[int] max_requests_per_connection: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[int] max_retries: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n "
if (connect_timeout is not None):
pulumi.set(__self__, 'connect_timeout', connect_timeout)
if (max_connections is not None):
pulumi.set(__self__, 'max_connections', max_connections)
if (max_pending_requests is not None):
pulumi.set(__self__, 'max_pending_requests', max_pending_requests)
if (max_requests is not None):
pulumi.set(__self__, 'max_requests', max_requests)
if (max_requests_per_connection is not None):
pulumi.set(__self__, 'max_requests_per_connection', max_requests_per_connection)
if (max_retries is not None):
pulumi.set(__self__, 'max_retries', max_retries)
| 7,782,014,397,820,148,000
|
Settings controlling the volume of requests, connections and retries to this backend service.
:param pulumi.Input['DurationArgs'] connect_timeout: The timeout for new network connections to hosts.
:param pulumi.Input[int] max_connections: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
:param pulumi.Input[int] max_pending_requests: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
:param pulumi.Input[int] max_requests: The maximum number of parallel requests that allowed to the backend service. If not specified, there is no limit.
:param pulumi.Input[int] max_requests_per_connection: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
:param pulumi.Input[int] max_retries: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, connect_timeout: Optional[pulumi.Input['DurationArgs']]=None, max_connections: Optional[pulumi.Input[int]]=None, max_pending_requests: Optional[pulumi.Input[int]]=None, max_requests: Optional[pulumi.Input[int]]=None, max_requests_per_connection: Optional[pulumi.Input[int]]=None, max_retries: Optional[pulumi.Input[int]]=None):
"\n Settings controlling the volume of requests, connections and retries to this backend service.\n :param pulumi.Input['DurationArgs'] connect_timeout: The timeout for new network connections to hosts.\n :param pulumi.Input[int] max_connections: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[int] max_pending_requests: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[int] max_requests: The maximum number of parallel requests that allowed to the backend service. If not specified, there is no limit.\n :param pulumi.Input[int] max_requests_per_connection: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[int] max_retries: Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n "
if (connect_timeout is not None):
pulumi.set(__self__, 'connect_timeout', connect_timeout)
if (max_connections is not None):
pulumi.set(__self__, 'max_connections', max_connections)
if (max_pending_requests is not None):
pulumi.set(__self__, 'max_pending_requests', max_pending_requests)
if (max_requests is not None):
pulumi.set(__self__, 'max_requests', max_requests)
if (max_requests_per_connection is not None):
pulumi.set(__self__, 'max_requests_per_connection', max_requests_per_connection)
if (max_retries is not None):
pulumi.set(__self__, 'max_retries', max_retries)
|
@property
@pulumi.getter(name='connectTimeout')
def connect_timeout(self) -> Optional[pulumi.Input['DurationArgs']]:
'\n The timeout for new network connections to hosts.\n '
return pulumi.get(self, 'connect_timeout')
| -5,468,990,751,924,852,000
|
The timeout for new network connections to hosts.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
connect_timeout
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='connectTimeout')
def connect_timeout(self) -> Optional[pulumi.Input['DurationArgs']]:
'\n \n '
return pulumi.get(self, 'connect_timeout')
|
@property
@pulumi.getter(name='maxConnections')
def max_connections(self) -> Optional[pulumi.Input[int]]:
'\n Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n '
return pulumi.get(self, 'max_connections')
| 2,263,622,881,324,202,000
|
Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_connections
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxConnections')
def max_connections(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_connections')
|
@property
@pulumi.getter(name='maxPendingRequests')
def max_pending_requests(self) -> Optional[pulumi.Input[int]]:
'\n Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n '
return pulumi.get(self, 'max_pending_requests')
| 3,178,091,801,943,332,400
|
Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_pending_requests
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxPendingRequests')
def max_pending_requests(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_pending_requests')
|
@property
@pulumi.getter(name='maxRequests')
def max_requests(self) -> Optional[pulumi.Input[int]]:
'\n The maximum number of parallel requests that allowed to the backend service. If not specified, there is no limit.\n '
return pulumi.get(self, 'max_requests')
| -1,730,104,396,020,949,500
|
The maximum number of parallel requests that allowed to the backend service. If not specified, there is no limit.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_requests
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRequests')
def max_requests(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_requests')
|
@property
@pulumi.getter(name='maxRequestsPerConnection')
def max_requests_per_connection(self) -> Optional[pulumi.Input[int]]:
'\n Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n '
return pulumi.get(self, 'max_requests_per_connection')
| 7,567,337,299,510,086,000
|
Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_requests_per_connection
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRequestsPerConnection')
def max_requests_per_connection(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_requests_per_connection')
|
@property
@pulumi.getter(name='maxRetries')
def max_retries(self) -> Optional[pulumi.Input[int]]:
'\n Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n '
return pulumi.get(self, 'max_retries')
| -8,177,553,232,781,593,000
|
Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_retries
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxRetries')
def max_retries(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_retries')
|
def __init__(__self__, *, iam: Optional[pulumi.Input['ConditionIam']]=None, op: Optional[pulumi.Input['ConditionOp']]=None, svc: Optional[pulumi.Input[str]]=None, sys: Optional[pulumi.Input['ConditionSys']]=None, values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ConditionIam'] iam: This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ConditionOp'] op: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[str] svc: This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ConditionSys'] sys: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: This is deprecated and has no effect. Do not use.\n "
if (iam is not None):
pulumi.set(__self__, 'iam', iam)
if (op is not None):
pulumi.set(__self__, 'op', op)
if (svc is not None):
pulumi.set(__self__, 'svc', svc)
if (sys is not None):
pulumi.set(__self__, 'sys', sys)
if (values is not None):
pulumi.set(__self__, 'values', values)
| -5,115,149,855,690,281,000
|
This is deprecated and has no effect. Do not use.
:param pulumi.Input['ConditionIam'] iam: This is deprecated and has no effect. Do not use.
:param pulumi.Input['ConditionOp'] op: This is deprecated and has no effect. Do not use.
:param pulumi.Input[str] svc: This is deprecated and has no effect. Do not use.
:param pulumi.Input['ConditionSys'] sys: This is deprecated and has no effect. Do not use.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: 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__, *, iam: Optional[pulumi.Input['ConditionIam']]=None, op: Optional[pulumi.Input['ConditionOp']]=None, svc: Optional[pulumi.Input[str]]=None, sys: Optional[pulumi.Input['ConditionSys']]=None, values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ConditionIam'] iam: This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ConditionOp'] op: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[str] svc: This is deprecated and has no effect. Do not use.\n :param pulumi.Input['ConditionSys'] sys: This is deprecated and has no effect. Do not use.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: This is deprecated and has no effect. Do not use.\n "
if (iam is not None):
pulumi.set(__self__, 'iam', iam)
if (op is not None):
pulumi.set(__self__, 'op', op)
if (svc is not None):
pulumi.set(__self__, 'svc', svc)
if (sys is not None):
pulumi.set(__self__, 'sys', sys)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
@property
@pulumi.getter
def iam(self) -> Optional[pulumi.Input['ConditionIam']]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'iam')
| 8,887,725,248,989,830,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
iam
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def iam(self) -> Optional[pulumi.Input['ConditionIam']]:
'\n \n '
return pulumi.get(self, 'iam')
|
@property
@pulumi.getter
def op(self) -> Optional[pulumi.Input['ConditionOp']]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'op')
| 7,170,664,052,515,583,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
op
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def op(self) -> Optional[pulumi.Input['ConditionOp']]:
'\n \n '
return pulumi.get(self, 'op')
|
@property
@pulumi.getter
def svc(self) -> Optional[pulumi.Input[str]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'svc')
| -4,654,939,928,921,449,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
svc
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def svc(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'svc')
|
@property
@pulumi.getter
def sys(self) -> Optional[pulumi.Input['ConditionSys']]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'sys')
| 2,889,650,376,923,536,000
|
This is deprecated and has no effect. Do not use.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
sys
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def sys(self) -> Optional[pulumi.Input['ConditionSys']]:
'\n \n '
return pulumi.get(self, 'sys')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n This is deprecated and has no effect. Do not use.\n '
return pulumi.get(self, 'values')
| -170,613,961,043,752,740
|
This is deprecated and has no effect. Do not use.
|
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__, *, enable_confidential_compute: Optional[pulumi.Input[bool]]=None):
'\n A set of Confidential Instance options.\n :param pulumi.Input[bool] enable_confidential_compute: Defines whether the instance should have confidential compute enabled.\n '
if (enable_confidential_compute is not None):
pulumi.set(__self__, 'enable_confidential_compute', enable_confidential_compute)
| 5,476,067,563,940,393,000
|
A set of Confidential Instance options.
:param pulumi.Input[bool] enable_confidential_compute: Defines whether the instance should have confidential compute enabled.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, enable_confidential_compute: Optional[pulumi.Input[bool]]=None):
'\n A set of Confidential Instance options.\n :param pulumi.Input[bool] enable_confidential_compute: Defines whether the instance should have confidential compute enabled.\n '
if (enable_confidential_compute is not None):
pulumi.set(__self__, 'enable_confidential_compute', enable_confidential_compute)
|
@property
@pulumi.getter(name='enableConfidentialCompute')
def enable_confidential_compute(self) -> Optional[pulumi.Input[bool]]:
'\n Defines whether the instance should have confidential compute enabled.\n '
return pulumi.get(self, 'enable_confidential_compute')
| 4,923,316,265,676,005,000
|
Defines whether the instance should have confidential compute enabled.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
enable_confidential_compute
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='enableConfidentialCompute')
def enable_confidential_compute(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'enable_confidential_compute')
|
def __init__(__self__, *, draining_timeout_sec: Optional[pulumi.Input[int]]=None):
'\n Message containing connection draining configuration.\n :param pulumi.Input[int] draining_timeout_sec: Configures a duration timeout for existing requests on a removed backend instance. For supported load balancers and protocols, as described in Enabling connection draining.\n '
if (draining_timeout_sec is not None):
pulumi.set(__self__, 'draining_timeout_sec', draining_timeout_sec)
| -371,517,320,746,123,500
|
Message containing connection draining configuration.
:param pulumi.Input[int] draining_timeout_sec: Configures a duration timeout for existing requests on a removed backend instance. For supported load balancers and protocols, as described in Enabling connection draining.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, draining_timeout_sec: Optional[pulumi.Input[int]]=None):
'\n Message containing connection draining configuration.\n :param pulumi.Input[int] draining_timeout_sec: Configures a duration timeout for existing requests on a removed backend instance. For supported load balancers and protocols, as described in Enabling connection draining.\n '
if (draining_timeout_sec is not None):
pulumi.set(__self__, 'draining_timeout_sec', draining_timeout_sec)
|
@property
@pulumi.getter(name='drainingTimeoutSec')
def draining_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n Configures a duration timeout for existing requests on a removed backend instance. For supported load balancers and protocols, as described in Enabling connection draining.\n '
return pulumi.get(self, 'draining_timeout_sec')
| -4,381,409,034,037,252,000
|
Configures a duration timeout for existing requests on a removed backend instance. For supported load balancers and protocols, as described in Enabling connection draining.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
draining_timeout_sec
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='drainingTimeoutSec')
def draining_timeout_sec(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'draining_timeout_sec')
|
def __init__(__self__, *, name: Optional[pulumi.Input[str]]=None, path: Optional[pulumi.Input[str]]=None, ttl: Optional[pulumi.Input['DurationArgs']]=None):
"\n The information about the HTTP Cookie on which the hash function is based for load balancing policies that use a consistent hash.\n :param pulumi.Input[str] name: Name of the cookie.\n :param pulumi.Input[str] path: Path to set for the cookie.\n :param pulumi.Input['DurationArgs'] ttl: Lifetime of the cookie.\n "
if (name is not None):
pulumi.set(__self__, 'name', name)
if (path is not None):
pulumi.set(__self__, 'path', path)
if (ttl is not None):
pulumi.set(__self__, 'ttl', ttl)
| -6,927,582,241,509,975,000
|
The information about the HTTP Cookie on which the hash function is based for load balancing policies that use a consistent hash.
:param pulumi.Input[str] name: Name of the cookie.
:param pulumi.Input[str] path: Path to set for the cookie.
:param pulumi.Input['DurationArgs'] ttl: Lifetime of the cookie.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, name: Optional[pulumi.Input[str]]=None, path: Optional[pulumi.Input[str]]=None, ttl: Optional[pulumi.Input['DurationArgs']]=None):
"\n The information about the HTTP Cookie on which the hash function is based for load balancing policies that use a consistent hash.\n :param pulumi.Input[str] name: Name of the cookie.\n :param pulumi.Input[str] path: Path to set for the cookie.\n :param pulumi.Input['DurationArgs'] ttl: Lifetime of the cookie.\n "
if (name is not None):
pulumi.set(__self__, 'name', name)
if (path is not None):
pulumi.set(__self__, 'path', path)
if (ttl is not None):
pulumi.set(__self__, 'ttl', ttl)
|
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
'\n Name of the cookie.\n '
return pulumi.get(self, 'name')
| -500,138,108,429,877,800
|
Name of the cookie.
|
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
def path(self) -> Optional[pulumi.Input[str]]:
'\n Path to set for the cookie.\n '
return pulumi.get(self, 'path')
| -826,530,077,737,847,200
|
Path to set for the cookie.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
path
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def path(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'path')
|
@property
@pulumi.getter
def ttl(self) -> Optional[pulumi.Input['DurationArgs']]:
'\n Lifetime of the cookie.\n '
return pulumi.get(self, 'ttl')
| -8,847,496,593,105,482,000
|
Lifetime of the cookie.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
ttl
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def ttl(self) -> Optional[pulumi.Input['DurationArgs']]:
'\n \n '
return pulumi.get(self, 'ttl')
|
def __init__(__self__, *, http_cookie: Optional[pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs']]=None, http_header_name: Optional[pulumi.Input[str]]=None, minimum_ring_size: Optional[pulumi.Input[str]]=None):
"\n This message defines settings for a consistent hash style load balancer.\n :param pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs'] http_cookie: Hash is based on HTTP Cookie. This field describes a HTTP cookie that will be used as the hash key for the consistent hash load balancer. If the cookie is not present, it will be generated. This field is applicable if the sessionAffinity is set to HTTP_COOKIE. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[str] http_header_name: The hash based on the value of the specified header field. This field is applicable if the sessionAffinity is set to HEADER_FIELD.\n :param pulumi.Input[str] minimum_ring_size: The minimum number of virtual nodes to use for the hash ring. Defaults to 1024. Larger ring sizes result in more granular load distributions. If the number of hosts in the load balancing pool is larger than the ring size, each host will be assigned a single virtual node.\n "
if (http_cookie is not None):
pulumi.set(__self__, 'http_cookie', http_cookie)
if (http_header_name is not None):
pulumi.set(__self__, 'http_header_name', http_header_name)
if (minimum_ring_size is not None):
pulumi.set(__self__, 'minimum_ring_size', minimum_ring_size)
| 5,200,828,895,893,153,000
|
This message defines settings for a consistent hash style load balancer.
:param pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs'] http_cookie: Hash is based on HTTP Cookie. This field describes a HTTP cookie that will be used as the hash key for the consistent hash load balancer. If the cookie is not present, it will be generated. This field is applicable if the sessionAffinity is set to HTTP_COOKIE. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
:param pulumi.Input[str] http_header_name: The hash based on the value of the specified header field. This field is applicable if the sessionAffinity is set to HEADER_FIELD.
:param pulumi.Input[str] minimum_ring_size: The minimum number of virtual nodes to use for the hash ring. Defaults to 1024. Larger ring sizes result in more granular load distributions. If the number of hosts in the load balancing pool is larger than the ring size, each host will be assigned a single virtual node.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, http_cookie: Optional[pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs']]=None, http_header_name: Optional[pulumi.Input[str]]=None, minimum_ring_size: Optional[pulumi.Input[str]]=None):
"\n This message defines settings for a consistent hash style load balancer.\n :param pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs'] http_cookie: Hash is based on HTTP Cookie. This field describes a HTTP cookie that will be used as the hash key for the consistent hash load balancer. If the cookie is not present, it will be generated. This field is applicable if the sessionAffinity is set to HTTP_COOKIE. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n :param pulumi.Input[str] http_header_name: The hash based on the value of the specified header field. This field is applicable if the sessionAffinity is set to HEADER_FIELD.\n :param pulumi.Input[str] minimum_ring_size: The minimum number of virtual nodes to use for the hash ring. Defaults to 1024. Larger ring sizes result in more granular load distributions. If the number of hosts in the load balancing pool is larger than the ring size, each host will be assigned a single virtual node.\n "
if (http_cookie is not None):
pulumi.set(__self__, 'http_cookie', http_cookie)
if (http_header_name is not None):
pulumi.set(__self__, 'http_header_name', http_header_name)
if (minimum_ring_size is not None):
pulumi.set(__self__, 'minimum_ring_size', minimum_ring_size)
|
@property
@pulumi.getter(name='httpCookie')
def http_cookie(self) -> Optional[pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs']]:
'\n Hash is based on HTTP Cookie. This field describes a HTTP cookie that will be used as the hash key for the consistent hash load balancer. If the cookie is not present, it will be generated. This field is applicable if the sessionAffinity is set to HTTP_COOKIE. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.\n '
return pulumi.get(self, 'http_cookie')
| 6,856,615,196,790,972,000
|
Hash is based on HTTP Cookie. This field describes a HTTP cookie that will be used as the hash key for the consistent hash load balancer. If the cookie is not present, it will be generated. This field is applicable if the sessionAffinity is set to HTTP_COOKIE. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
http_cookie
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='httpCookie')
def http_cookie(self) -> Optional[pulumi.Input['ConsistentHashLoadBalancerSettingsHttpCookieArgs']]:
'\n \n '
return pulumi.get(self, 'http_cookie')
|
@property
@pulumi.getter(name='httpHeaderName')
def http_header_name(self) -> Optional[pulumi.Input[str]]:
'\n The hash based on the value of the specified header field. This field is applicable if the sessionAffinity is set to HEADER_FIELD.\n '
return pulumi.get(self, 'http_header_name')
| 5,741,090,164,934,909,000
|
The hash based on the value of the specified header field. This field is applicable if the sessionAffinity is set to HEADER_FIELD.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
http_header_name
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='httpHeaderName')
def http_header_name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'http_header_name')
|
@property
@pulumi.getter(name='minimumRingSize')
def minimum_ring_size(self) -> Optional[pulumi.Input[str]]:
'\n The minimum number of virtual nodes to use for the hash ring. Defaults to 1024. Larger ring sizes result in more granular load distributions. If the number of hosts in the load balancing pool is larger than the ring size, each host will be assigned a single virtual node.\n '
return pulumi.get(self, 'minimum_ring_size')
| 595,528,884,179,451,900
|
The minimum number of virtual nodes to use for the hash ring. Defaults to 1024. Larger ring sizes result in more granular load distributions. If the number of hosts in the load balancing pool is larger than the ring size, each host will be assigned a single virtual node.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
minimum_ring_size
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='minimumRingSize')
def minimum_ring_size(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'minimum_ring_size')
|
def __init__(__self__, *, allow_credentials: Optional[pulumi.Input[bool]]=None, allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, disabled: Optional[pulumi.Input[bool]]=None, expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, max_age: Optional[pulumi.Input[int]]=None):
'\n The specification for allowing client-side cross-origin requests. For more information about the W3C recommendation for cross-origin resource sharing (CORS), see Fetch API Living Standard.\n :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header. Default is false.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies a regular expression that matches allowed origins. For more information about the regular expression syntax, see Syntax. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that is allowed to do CORS requests. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.\n :param pulumi.Input[bool] disabled: If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.\n :param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds. This field translates to the Access-Control-Max-Age header.\n '
if (allow_credentials is not None):
pulumi.set(__self__, 'allow_credentials', allow_credentials)
if (allow_headers is not None):
pulumi.set(__self__, 'allow_headers', allow_headers)
if (allow_methods is not None):
pulumi.set(__self__, 'allow_methods', allow_methods)
if (allow_origin_regexes is not None):
pulumi.set(__self__, 'allow_origin_regexes', allow_origin_regexes)
if (allow_origins is not None):
pulumi.set(__self__, 'allow_origins', allow_origins)
if (disabled is not None):
pulumi.set(__self__, 'disabled', disabled)
if (expose_headers is not None):
pulumi.set(__self__, 'expose_headers', expose_headers)
if (max_age is not None):
pulumi.set(__self__, 'max_age', max_age)
| -6,944,320,736,248,372,000
|
The specification for allowing client-side cross-origin requests. For more information about the W3C recommendation for cross-origin resource sharing (CORS), see Fetch API Living Standard.
:param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header. Default is false.
:param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.
:param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.
:param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies a regular expression that matches allowed origins. For more information about the regular expression syntax, see Syntax. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
:param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that is allowed to do CORS requests. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
:param pulumi.Input[bool] disabled: If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
:param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.
:param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds. This field translates to the Access-Control-Max-Age header.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
__init__
|
AaronFriel/pulumi-google-native
|
python
|
def __init__(__self__, *, allow_credentials: Optional[pulumi.Input[bool]]=None, allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, disabled: Optional[pulumi.Input[bool]]=None, expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None, max_age: Optional[pulumi.Input[int]]=None):
'\n The specification for allowing client-side cross-origin requests. For more information about the W3C recommendation for cross-origin resource sharing (CORS), see Fetch API Living Standard.\n :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header. Default is false.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers header.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods header.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies a regular expression that matches allowed origins. For more information about the regular expression syntax, see Syntax. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that is allowed to do CORS requests. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.\n :param pulumi.Input[bool] disabled: If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Expose-Headers header.\n :param pulumi.Input[int] max_age: Specifies how long results of a preflight request can be cached in seconds. This field translates to the Access-Control-Max-Age header.\n '
if (allow_credentials is not None):
pulumi.set(__self__, 'allow_credentials', allow_credentials)
if (allow_headers is not None):
pulumi.set(__self__, 'allow_headers', allow_headers)
if (allow_methods is not None):
pulumi.set(__self__, 'allow_methods', allow_methods)
if (allow_origin_regexes is not None):
pulumi.set(__self__, 'allow_origin_regexes', allow_origin_regexes)
if (allow_origins is not None):
pulumi.set(__self__, 'allow_origins', allow_origins)
if (disabled is not None):
pulumi.set(__self__, 'disabled', disabled)
if (expose_headers is not None):
pulumi.set(__self__, 'expose_headers', expose_headers)
if (max_age is not None):
pulumi.set(__self__, 'max_age', max_age)
|
@property
@pulumi.getter(name='allowCredentials')
def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
'\n In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header. Default is false.\n '
return pulumi.get(self, 'allow_credentials')
| -2,395,437,627,600,330,000
|
In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This field translates to the Access-Control-Allow-Credentials header. Default is false.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
allow_credentials
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='allowCredentials')
def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'allow_credentials')
|
@property
@pulumi.getter(name='allowHeaders')
def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Specifies the content for the Access-Control-Allow-Headers header.\n '
return pulumi.get(self, 'allow_headers')
| 6,354,314,702,094,814,000
|
Specifies the content for the Access-Control-Allow-Headers header.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
allow_headers
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='allowHeaders')
def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'allow_headers')
|
@property
@pulumi.getter(name='allowMethods')
def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Specifies the content for the Access-Control-Allow-Methods header.\n '
return pulumi.get(self, 'allow_methods')
| -8,779,748,014,897,788,000
|
Specifies the content for the Access-Control-Allow-Methods header.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
allow_methods
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='allowMethods')
def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'allow_methods')
|
@property
@pulumi.getter(name='allowOriginRegexes')
def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Specifies a regular expression that matches allowed origins. For more information about the regular expression syntax, see Syntax. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.\n '
return pulumi.get(self, 'allow_origin_regexes')
| 3,145,246,050,022,605,000
|
Specifies a regular expression that matches allowed origins. For more information about the regular expression syntax, see Syntax. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
allow_origin_regexes
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='allowOriginRegexes')
def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'allow_origin_regexes')
|
@property
@pulumi.getter(name='allowOrigins')
def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Specifies the list of origins that is allowed to do CORS requests. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.\n '
return pulumi.get(self, 'allow_origins')
| -564,553,056,125,064,100
|
Specifies the list of origins that is allowed to do CORS requests. An origin is allowed if it matches either an item in allowOrigins or an item in allowOriginRegexes.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
allow_origins
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='allowOrigins')
def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'allow_origins')
|
@property
@pulumi.getter
def disabled(self) -> Optional[pulumi.Input[bool]]:
'\n If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.\n '
return pulumi.get(self, 'disabled')
| 3,678,149,334,437,232,600
|
If true, the setting specifies the CORS policy is disabled. The default value of false, which indicates that the CORS policy is in effect.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
disabled
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter
def disabled(self) -> Optional[pulumi.Input[bool]]:
'\n \n '
return pulumi.get(self, 'disabled')
|
@property
@pulumi.getter(name='exposeHeaders')
def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n Specifies the content for the Access-Control-Expose-Headers header.\n '
return pulumi.get(self, 'expose_headers')
| 8,687,930,182,652,714,000
|
Specifies the content for the Access-Control-Expose-Headers header.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
expose_headers
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='exposeHeaders')
def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'expose_headers')
|
@property
@pulumi.getter(name='maxAge')
def max_age(self) -> Optional[pulumi.Input[int]]:
'\n Specifies how long results of a preflight request can be cached in seconds. This field translates to the Access-Control-Max-Age header.\n '
return pulumi.get(self, 'max_age')
| -2,083,157,153,672,528,400
|
Specifies how long results of a preflight request can be cached in seconds. This field translates to the Access-Control-Max-Age header.
|
sdk/python/pulumi_google_native/compute/alpha/_inputs.py
|
max_age
|
AaronFriel/pulumi-google-native
|
python
|
@property
@pulumi.getter(name='maxAge')
def max_age(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'max_age')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.