@pulumi/yandex
Version:
A Pulumi package for creating and managing yandex cloud resources.
1,334 lines • 229 kB
TypeScript
import * as pulumi from "@pulumi/pulumi";
import { input as inputs } from "../types";
export interface AlbBackendGroupGrpcBackend {
/**
* Healthcheck specification that will be used by this backend. Structure is documented below.
*/
healthcheck?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendHealthcheck>;
/**
* Load Balancing Config specification that will be used by this backend. Structure is documented below.
*/
loadBalancingConfig?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendLoadBalancingConfig>;
/**
* Name of the backend.
*/
name: pulumi.Input<string>;
/**
* Port for incoming traffic.
*/
port?: pulumi.Input<number>;
/**
* References target groups for the backend.
*/
targetGroupIds: pulumi.Input<pulumi.Input<string>[]>;
/**
* Tls specification that will be used by this backend. Structure is documented below.
*/
tls?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendTls>;
/**
* Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
*/
weight?: pulumi.Input<number>;
}
export interface AlbBackendGroupGrpcBackendHealthcheck {
/**
* Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
grpcHealthcheck?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheck>;
/**
* Optional alternative port for health checking.
*/
healthcheckPort?: pulumi.Input<number>;
/**
* Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
*/
healthyThreshold?: pulumi.Input<number>;
/**
* Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
httpHealthcheck?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheck>;
/**
* Interval between health checks.
*/
interval: pulumi.Input<string>;
/**
* An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * intervalJitterPercent / 100) will be added to the wait time.
*/
intervalJitterPercent?: pulumi.Input<number>;
/**
* Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
streamHealthcheck?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheck>;
/**
* Time to wait for a health check response.
*/
timeout: pulumi.Input<string>;
/**
* Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
*/
unhealthyThreshold?: pulumi.Input<number>;
}
export interface AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheck {
/**
* Service name for grpc.health.v1.HealthCheckRequest message.
*/
serviceName?: pulumi.Input<string>;
}
export interface AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheck {
/**
* "Host" HTTP header value.
*/
host?: pulumi.Input<string>;
/**
* If set, health checks will use HTTP2.
*/
http2?: pulumi.Input<boolean>;
/**
* HTTP path.
*/
path: pulumi.Input<string>;
}
export interface AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheck {
/**
* Text to search in reply.
*/
receive?: pulumi.Input<string>;
/**
* Message to send. If empty, it's a connect-only health check.
*/
send?: pulumi.Input<string>;
}
export interface AlbBackendGroupGrpcBackendLoadBalancingConfig {
/**
* Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
*/
localityAwareRoutingPercent?: pulumi.Input<number>;
/**
* If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading when everything is bad. Zero means no panic threshold.
*/
panicThreshold?: pulumi.Input<number>;
/**
* If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
*/
strictLocality?: pulumi.Input<boolean>;
}
export interface AlbBackendGroupGrpcBackendTls {
/**
* [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
* * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
* * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
*/
sni?: pulumi.Input<string>;
validationContext?: pulumi.Input<inputs.AlbBackendGroupGrpcBackendTlsValidationContext>;
}
export interface AlbBackendGroupGrpcBackendTlsValidationContext {
trustedCaBytes?: pulumi.Input<string>;
trustedCaId?: pulumi.Input<string>;
}
export interface AlbBackendGroupHttpBackend {
/**
* Healthcheck specification that will be used by this backend. Structure is documented below.
*/
healthcheck?: pulumi.Input<inputs.AlbBackendGroupHttpBackendHealthcheck>;
/**
* If set, health checks will use HTTP2.
*/
http2?: pulumi.Input<boolean>;
/**
* Load Balancing Config specification that will be used by this backend. Structure is documented below.
*/
loadBalancingConfig?: pulumi.Input<inputs.AlbBackendGroupHttpBackendLoadBalancingConfig>;
/**
* Name of the backend.
*/
name: pulumi.Input<string>;
/**
* Port for incoming traffic.
*/
port?: pulumi.Input<number>;
/**
* References target groups for the backend.
*/
targetGroupIds: pulumi.Input<pulumi.Input<string>[]>;
/**
* Tls specification that will be used by this backend. Structure is documented below.
*/
tls?: pulumi.Input<inputs.AlbBackendGroupHttpBackendTls>;
/**
* Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
*/
weight?: pulumi.Input<number>;
}
export interface AlbBackendGroupHttpBackendHealthcheck {
/**
* Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
grpcHealthcheck?: pulumi.Input<inputs.AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheck>;
/**
* Optional alternative port for health checking.
*/
healthcheckPort?: pulumi.Input<number>;
/**
* Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
*/
healthyThreshold?: pulumi.Input<number>;
/**
* Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
httpHealthcheck?: pulumi.Input<inputs.AlbBackendGroupHttpBackendHealthcheckHttpHealthcheck>;
/**
* Interval between health checks.
*/
interval: pulumi.Input<string>;
/**
* An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * intervalJitterPercent / 100) will be added to the wait time.
*/
intervalJitterPercent?: pulumi.Input<number>;
/**
* Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
streamHealthcheck?: pulumi.Input<inputs.AlbBackendGroupHttpBackendHealthcheckStreamHealthcheck>;
/**
* Time to wait for a health check response.
*/
timeout: pulumi.Input<string>;
/**
* Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
*/
unhealthyThreshold?: pulumi.Input<number>;
}
export interface AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheck {
/**
* Service name for grpc.health.v1.HealthCheckRequest message.
*/
serviceName?: pulumi.Input<string>;
}
export interface AlbBackendGroupHttpBackendHealthcheckHttpHealthcheck {
/**
* "Host" HTTP header value.
*/
host?: pulumi.Input<string>;
/**
* If set, health checks will use HTTP2.
*/
http2?: pulumi.Input<boolean>;
/**
* HTTP path.
*/
path: pulumi.Input<string>;
}
export interface AlbBackendGroupHttpBackendHealthcheckStreamHealthcheck {
/**
* Text to search in reply.
*/
receive?: pulumi.Input<string>;
/**
* Message to send. If empty, it's a connect-only health check.
*/
send?: pulumi.Input<string>;
}
export interface AlbBackendGroupHttpBackendLoadBalancingConfig {
/**
* Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
*/
localityAwareRoutingPercent?: pulumi.Input<number>;
/**
* If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading when everything is bad. Zero means no panic threshold.
*/
panicThreshold?: pulumi.Input<number>;
/**
* If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
*/
strictLocality?: pulumi.Input<boolean>;
}
export interface AlbBackendGroupHttpBackendTls {
/**
* [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
* * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
* * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
*/
sni?: pulumi.Input<string>;
validationContext?: pulumi.Input<inputs.AlbBackendGroupHttpBackendTlsValidationContext>;
}
export interface AlbBackendGroupHttpBackendTlsValidationContext {
trustedCaBytes?: pulumi.Input<string>;
trustedCaId?: pulumi.Input<string>;
}
export interface AlbBackendGroupStreamBackend {
/**
* Healthcheck specification that will be used by this backend. Structure is documented below.
*/
healthcheck?: pulumi.Input<inputs.AlbBackendGroupStreamBackendHealthcheck>;
/**
* Load Balancing Config specification that will be used by this backend. Structure is documented below.
*/
loadBalancingConfig?: pulumi.Input<inputs.AlbBackendGroupStreamBackendLoadBalancingConfig>;
/**
* Name of the backend.
*/
name: pulumi.Input<string>;
/**
* Port for incoming traffic.
*/
port?: pulumi.Input<number>;
/**
* References target groups for the backend.
*/
targetGroupIds: pulumi.Input<pulumi.Input<string>[]>;
/**
* Tls specification that will be used by this backend. Structure is documented below.
*/
tls?: pulumi.Input<inputs.AlbBackendGroupStreamBackendTls>;
/**
* Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
*/
weight?: pulumi.Input<number>;
}
export interface AlbBackendGroupStreamBackendHealthcheck {
/**
* Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
grpcHealthcheck?: pulumi.Input<inputs.AlbBackendGroupStreamBackendHealthcheckGrpcHealthcheck>;
/**
* Optional alternative port for health checking.
*/
healthcheckPort?: pulumi.Input<number>;
/**
* Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
*/
healthyThreshold?: pulumi.Input<number>;
/**
* Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
httpHealthcheck?: pulumi.Input<inputs.AlbBackendGroupStreamBackendHealthcheckHttpHealthcheck>;
/**
* Interval between health checks.
*/
interval: pulumi.Input<string>;
/**
* An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * intervalJitterPercent / 100) will be added to the wait time.
*/
intervalJitterPercent?: pulumi.Input<number>;
/**
* Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
*/
streamHealthcheck?: pulumi.Input<inputs.AlbBackendGroupStreamBackendHealthcheckStreamHealthcheck>;
/**
* Time to wait for a health check response.
*/
timeout: pulumi.Input<string>;
/**
* Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
*/
unhealthyThreshold?: pulumi.Input<number>;
}
export interface AlbBackendGroupStreamBackendHealthcheckGrpcHealthcheck {
/**
* Service name for grpc.health.v1.HealthCheckRequest message.
*/
serviceName?: pulumi.Input<string>;
}
export interface AlbBackendGroupStreamBackendHealthcheckHttpHealthcheck {
/**
* "Host" HTTP header value.
*/
host?: pulumi.Input<string>;
/**
* If set, health checks will use HTTP2.
*/
http2?: pulumi.Input<boolean>;
/**
* HTTP path.
*/
path: pulumi.Input<string>;
}
export interface AlbBackendGroupStreamBackendHealthcheckStreamHealthcheck {
/**
* Text to search in reply.
*/
receive?: pulumi.Input<string>;
/**
* Message to send. If empty, it's a connect-only health check.
*/
send?: pulumi.Input<string>;
}
export interface AlbBackendGroupStreamBackendLoadBalancingConfig {
/**
* Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
*/
localityAwareRoutingPercent?: pulumi.Input<number>;
/**
* If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading when everything is bad. Zero means no panic threshold.
*/
panicThreshold?: pulumi.Input<number>;
/**
* If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
*/
strictLocality?: pulumi.Input<boolean>;
}
export interface AlbBackendGroupStreamBackendTls {
/**
* [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
* * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
* * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
*/
sni?: pulumi.Input<string>;
validationContext?: pulumi.Input<inputs.AlbBackendGroupStreamBackendTlsValidationContext>;
}
export interface AlbBackendGroupStreamBackendTlsValidationContext {
trustedCaBytes?: pulumi.Input<string>;
trustedCaId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerAllocationPolicy {
/**
* Unique set of locations. The structure is documented below.
*/
locations: pulumi.Input<pulumi.Input<inputs.AlbLoadBalancerAllocationPolicyLocation>[]>;
}
export interface AlbLoadBalancerAllocationPolicyLocation {
/**
* If set, will disable all L7 instances in the zone for request handling.
*/
disableTraffic?: pulumi.Input<boolean>;
/**
* Provided by the client or computed automatically.
*/
subnetId: pulumi.Input<string>;
/**
* ID of the zone that location is located at.
*/
zoneId: pulumi.Input<string>;
}
export interface AlbLoadBalancerListener {
/**
* Network endpoints (addresses and ports) of the listener. The structure is documented below.
*/
endpoints?: pulumi.Input<pulumi.Input<inputs.AlbLoadBalancerListenerEndpoint>[]>;
/**
* HTTP listener resource. The structure is documented below.
*/
http?: pulumi.Input<inputs.AlbLoadBalancerListenerHttp>;
/**
* name of SNI match.
*/
name: pulumi.Input<string>;
/**
* Stream listener resource. The structure is documented below.
*/
stream?: pulumi.Input<inputs.AlbLoadBalancerListenerStream>;
/**
* TLS listener resource. The structure is documented below.
*/
tls?: pulumi.Input<inputs.AlbLoadBalancerListenerTls>;
}
export interface AlbLoadBalancerListenerEndpoint {
/**
* Provided by the client or computed automatically.
*/
addresses: pulumi.Input<pulumi.Input<inputs.AlbLoadBalancerListenerEndpointAddress>[]>;
/**
* One or more ports to listen on.
*/
ports: pulumi.Input<pulumi.Input<number>[]>;
}
export interface AlbLoadBalancerListenerEndpointAddress {
/**
* External IPv4 address. The structure is documented below.
*/
externalIpv4Address?: pulumi.Input<inputs.AlbLoadBalancerListenerEndpointAddressExternalIpv4Address>;
/**
* External IPv6 address. The structure is documented below.
*/
externalIpv6Address?: pulumi.Input<inputs.AlbLoadBalancerListenerEndpointAddressExternalIpv6Address>;
/**
* Internal IPv4 address. The structure is documented below.
*/
internalIpv4Address?: pulumi.Input<inputs.AlbLoadBalancerListenerEndpointAddressInternalIpv4Address>;
}
export interface AlbLoadBalancerListenerEndpointAddressExternalIpv4Address {
/**
* Provided by the client or computed automatically.
*/
address?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerEndpointAddressExternalIpv6Address {
/**
* Provided by the client or computed automatically.
*/
address?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerEndpointAddressInternalIpv4Address {
/**
* Provided by the client or computed automatically.
*/
address?: pulumi.Input<string>;
/**
* Provided by the client or computed automatically.
*/
subnetId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerHttp {
/**
* HTTP handler that sets plaintext HTTP router. The structure is documented below.
*/
handler?: pulumi.Input<inputs.AlbLoadBalancerListenerHttpHandler>;
/**
* Shortcut for adding http > https redirects. The structure is documented below.
*/
redirects?: pulumi.Input<inputs.AlbLoadBalancerListenerHttpRedirects>;
}
export interface AlbLoadBalancerListenerHttpHandler {
/**
* If set, will enable only HTTP1 protocol with HTTP1.0 support.
*/
allowHttp10?: pulumi.Input<boolean>;
/**
* If set, will enable HTTP2 protocol for the handler. The structure is documented below.
*/
http2Options?: pulumi.Input<inputs.AlbLoadBalancerListenerHttpHandlerHttp2Options>;
/**
* HTTP router id.
*/
httpRouterId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerHttpHandlerHttp2Options {
/**
* Maximum number of concurrent streams.
*/
maxConcurrentStreams?: pulumi.Input<number>;
}
export interface AlbLoadBalancerListenerHttpRedirects {
httpToHttps?: pulumi.Input<boolean>;
}
export interface AlbLoadBalancerListenerStream {
/**
* HTTP handler that sets plaintext HTTP router. The structure is documented below.
*/
handler?: pulumi.Input<inputs.AlbLoadBalancerListenerStreamHandler>;
}
export interface AlbLoadBalancerListenerStreamHandler {
/**
* Backend group id.
*/
backendGroupId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerTls {
/**
* TLS handler resource. The structure is documented below.
*/
defaultHandler: pulumi.Input<inputs.AlbLoadBalancerListenerTlsDefaultHandler>;
/**
* SNI match resource. The structure is documented below.
*/
sniHandlers?: pulumi.Input<pulumi.Input<inputs.AlbLoadBalancerListenerTlsSniHandler>[]>;
}
export interface AlbLoadBalancerListenerTlsDefaultHandler {
/**
* Certificate IDs in the Certificate Manager. Multiple TLS certificates can be associated
* with the same context to allow both RSA and ECDSA certificates. Only the first certificate of each type will be used.
*/
certificateIds: pulumi.Input<pulumi.Input<string>[]>;
/**
* HTTP handler resource. The structure is documented below.
*/
httpHandler?: pulumi.Input<inputs.AlbLoadBalancerListenerTlsDefaultHandlerHttpHandler>;
/**
* Stream handler resource. The structure is documented below.
*/
streamHandler?: pulumi.Input<inputs.AlbLoadBalancerListenerTlsDefaultHandlerStreamHandler>;
}
export interface AlbLoadBalancerListenerTlsDefaultHandlerHttpHandler {
/**
* If set, will enable only HTTP1 protocol with HTTP1.0 support.
*/
allowHttp10?: pulumi.Input<boolean>;
/**
* If set, will enable HTTP2 protocol for the handler. The structure is documented below.
*/
http2Options?: pulumi.Input<inputs.AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2Options>;
/**
* HTTP router id.
*/
httpRouterId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2Options {
/**
* Maximum number of concurrent streams.
*/
maxConcurrentStreams?: pulumi.Input<number>;
}
export interface AlbLoadBalancerListenerTlsDefaultHandlerStreamHandler {
/**
* Backend group id.
*/
backendGroupId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerTlsSniHandler {
/**
* HTTP handler that sets plaintext HTTP router. The structure is documented below.
*/
handler: pulumi.Input<inputs.AlbLoadBalancerListenerTlsSniHandlerHandler>;
/**
* name of SNI match.
*/
name: pulumi.Input<string>;
/**
* A set of server names.
*/
serverNames: pulumi.Input<pulumi.Input<string>[]>;
}
export interface AlbLoadBalancerListenerTlsSniHandlerHandler {
/**
* Certificate IDs in the Certificate Manager. Multiple TLS certificates can be associated
* with the same context to allow both RSA and ECDSA certificates. Only the first certificate of each type will be used.
*/
certificateIds: pulumi.Input<pulumi.Input<string>[]>;
/**
* HTTP handler resource. The structure is documented below.
*/
httpHandler?: pulumi.Input<inputs.AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandler>;
/**
* Stream handler resource. The structure is documented below.
*/
streamHandler?: pulumi.Input<inputs.AlbLoadBalancerListenerTlsSniHandlerHandlerStreamHandler>;
}
export interface AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandler {
/**
* If set, will enable only HTTP1 protocol with HTTP1.0 support.
*/
allowHttp10?: pulumi.Input<boolean>;
/**
* If set, will enable HTTP2 protocol for the handler. The structure is documented below.
*/
http2Options?: pulumi.Input<inputs.AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2Options>;
/**
* HTTP router id.
*/
httpRouterId?: pulumi.Input<string>;
}
export interface AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2Options {
/**
* Maximum number of concurrent streams.
*/
maxConcurrentStreams?: pulumi.Input<number>;
}
export interface AlbLoadBalancerListenerTlsSniHandlerHandlerStreamHandler {
/**
* Backend group id.
*/
backendGroupId?: pulumi.Input<string>;
}
export interface AlbTargetGroupTarget {
/**
* IP address of the target.
*/
ipAddress: pulumi.Input<string>;
privateIpv4Address?: pulumi.Input<boolean>;
/**
* ID of the subnet that targets are connected to.
* All targets in the target group must be connected to the same subnet within a single availability zone.
*/
subnetId?: pulumi.Input<string>;
}
export interface AlbVirtualHostModifyRequestHeader {
/**
* Append string to the header value.
*/
append?: pulumi.Input<string>;
/**
* name of the route.
*/
name: pulumi.Input<string>;
/**
* If set, remove the header.
*/
remove?: pulumi.Input<boolean>;
/**
* New value for a header. Header values support the following
* [formatters](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/headers#custom-request-response-headers).
*/
replace?: pulumi.Input<string>;
}
export interface AlbVirtualHostModifyResponseHeader {
/**
* Append string to the header value.
*/
append?: pulumi.Input<string>;
/**
* name of the route.
*/
name: pulumi.Input<string>;
/**
* If set, remove the header.
*/
remove?: pulumi.Input<boolean>;
/**
* New value for a header. Header values support the following
* [formatters](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/headers#custom-request-response-headers).
*/
replace?: pulumi.Input<string>;
}
export interface AlbVirtualHostRoute {
/**
* GRPC route resource. The structure is documented below.
*/
grpcRoute?: pulumi.Input<inputs.AlbVirtualHostRouteGrpcRoute>;
/**
* HTTP route resource. The structure is documented below.
*/
httpRoute?: pulumi.Input<inputs.AlbVirtualHostRouteHttpRoute>;
/**
* name of the route.
*/
name?: pulumi.Input<string>;
}
export interface AlbVirtualHostRouteGrpcRoute {
/**
* Checks "/" prefix by default. The structure is documented below.
*/
grpcMatches?: pulumi.Input<pulumi.Input<inputs.AlbVirtualHostRouteGrpcRouteGrpcMatch>[]>;
/**
* GRPC route action resource. The structure is documented below.
*/
grpcRouteAction?: pulumi.Input<inputs.AlbVirtualHostRouteGrpcRouteGrpcRouteAction>;
/**
* GRPC status response action resource. The structure is documented below.
*/
grpcStatusResponseAction?: pulumi.Input<inputs.AlbVirtualHostRouteGrpcRouteGrpcStatusResponseAction>;
}
export interface AlbVirtualHostRouteGrpcRouteGrpcMatch {
/**
* If not set, all services/methods are assumed. The structure is documented below.
*/
fqmn?: pulumi.Input<inputs.AlbVirtualHostRouteGrpcRouteGrpcMatchFqmn>;
}
export interface AlbVirtualHostRouteGrpcRouteGrpcMatchFqmn {
/**
* Match exactly.
*/
exact?: pulumi.Input<string>;
/**
* Match prefix.
*/
prefix?: pulumi.Input<string>;
}
export interface AlbVirtualHostRouteGrpcRouteGrpcRouteAction {
/**
* If set, will automatically rewrite host.
*/
autoHostRewrite?: pulumi.Input<boolean>;
/**
* Backend group to route requests.
*/
backendGroupId: pulumi.Input<string>;
/**
* Host rewrite specifier.
*/
hostRewrite?: pulumi.Input<string>;
/**
* Specifies the idle timeout (time without any data transfer for the active request) for the
* route. It is useful for streaming scenarios - one should set idleTimeout to something meaningful and maxTimeout
* to the maximum time the stream is allowed to be alive. If not specified, there is no
* per-route idle timeout.
*/
idleTimeout?: pulumi.Input<string>;
/**
* Lower timeout may be specified by the client (using grpc-timeout header). If not set, default is
* 60 seconds.
*/
maxTimeout?: pulumi.Input<string>;
}
export interface AlbVirtualHostRouteGrpcRouteGrpcStatusResponseAction {
/**
* The status of the response. Supported values are: ok, invalid_argumet, not_found,
* permission_denied, unauthenticated, unimplemented, internal, unavailable.
*/
status?: pulumi.Input<string>;
}
export interface AlbVirtualHostRouteHttpRoute {
/**
* Direct response action resource. The structure is documented below.
*/
directResponseAction?: pulumi.Input<inputs.AlbVirtualHostRouteHttpRouteDirectResponseAction>;
/**
* Checks "/" prefix by default. The structure is documented below.
*/
httpMatches?: pulumi.Input<pulumi.Input<inputs.AlbVirtualHostRouteHttpRouteHttpMatch>[]>;
/**
* HTTP route action resource. The structure is documented below.
*/
httpRouteAction?: pulumi.Input<inputs.AlbVirtualHostRouteHttpRouteHttpRouteAction>;
/**
* Redirect action resource. The structure is documented below.
*/
redirectAction?: pulumi.Input<inputs.AlbVirtualHostRouteHttpRouteRedirectAction>;
}
export interface AlbVirtualHostRouteHttpRouteDirectResponseAction {
/**
* Response body text.
*/
body?: pulumi.Input<string>;
/**
* The status of the response. Supported values are: ok, invalid_argumet, not_found,
* permission_denied, unauthenticated, unimplemented, internal, unavailable.
*/
status?: pulumi.Input<number>;
}
export interface AlbVirtualHostRouteHttpRouteHttpMatch {
/**
* List of methods(strings).
*/
httpMethods?: pulumi.Input<pulumi.Input<string>[]>;
/**
* If not set, '/' is assumed. The structure is documented below.
*/
path?: pulumi.Input<inputs.AlbVirtualHostRouteHttpRouteHttpMatchPath>;
}
export interface AlbVirtualHostRouteHttpRouteHttpMatchPath {
/**
* Match exactly.
*/
exact?: pulumi.Input<string>;
/**
* Match prefix.
*/
prefix?: pulumi.Input<string>;
}
export interface AlbVirtualHostRouteHttpRouteHttpRouteAction {
/**
* If set, will automatically rewrite host.
*/
autoHostRewrite?: pulumi.Input<boolean>;
/**
* Backend group to route requests.
*/
backendGroupId: pulumi.Input<string>;
/**
* Host rewrite specifier.
*/
hostRewrite?: pulumi.Input<string>;
/**
* Specifies the idle timeout (time without any data transfer for the active request) for the
* route. It is useful for streaming scenarios - one should set idleTimeout to something meaningful and maxTimeout
* to the maximum time the stream is allowed to be alive. If not specified, there is no
* per-route idle timeout.
*/
idleTimeout?: pulumi.Input<string>;
/**
* If not empty, matched path prefix will be replaced by this value.
*/
prefixRewrite?: pulumi.Input<string>;
/**
* Specifies the request timeout (overall time request processing is allowed to take) for the
* route. If not set, default is 60 seconds.
*/
timeout?: pulumi.Input<string>;
/**
* List of upgrade types. Only specified upgrade types will be allowed. For example,
* "websocket".
*/
upgradeTypes?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface AlbVirtualHostRouteHttpRouteRedirectAction {
removeQuery?: pulumi.Input<boolean>;
/**
* Replaces hostname.
*/
replaceHost?: pulumi.Input<string>;
/**
* Replace path.
*/
replacePath?: pulumi.Input<string>;
/**
* Replaces port.
*/
replacePort?: pulumi.Input<number>;
/**
* Replace only matched prefix. Example:<br/> match:{ prefix_match: "/some" } <br/>
* redirect: { replace_prefix: "/other" } <br/> will redirect "/something" to "/otherthing".
*/
replacePrefix?: pulumi.Input<string>;
/**
* Replaces scheme. If the original scheme is `http` or `https`, will also remove the
* 80 or 443 port, if present.
*/
replaceScheme?: pulumi.Input<string>;
/**
* The HTTP status code to use in the redirect response. Supported values are:
* moved_permanently, found, see_other, temporary_redirect, permanent_redirect.
*/
responseCode?: pulumi.Input<string>;
}
export interface CdnOriginGroupOrigin {
backup?: pulumi.Input<boolean>;
enabled?: pulumi.Input<boolean>;
originGroupId?: pulumi.Input<number>;
source: pulumi.Input<string>;
}
export interface CdnResourceOptions {
/**
* HTTP methods for your CDN content. By default the following methods are allowed: GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS. In case some methods are not allowed to the user, they will get the 405 (Method Not Allowed) response. If the method is not supported, the user gets the 501 (Not Implemented) response.
*/
allowedHttpMethods?: pulumi.Input<pulumi.Input<string>[]>;
/**
* set up a cache period for the end-users browser. Content will be cached due to origin settings. If there are no cache settings on your origin, the content will not be cached. The list of HTTP response codes that can be cached in browsers: 200, 201, 204, 206, 301, 302, 303, 304, 307, 308. Other response codes will not be cached. The default value is 4 days.
*/
browserCacheSettings?: pulumi.Input<number>;
/**
* list HTTP headers that must be included in responses to clients.
*/
cacheHttpHeaders?: pulumi.Input<pulumi.Input<string>[]>;
/**
* parameter that lets browsers get access to selected resources from a domain different to a domain from which the request is received.
*/
cors?: pulumi.Input<pulumi.Input<string>[]>;
/**
* custom value for the Host header. Your server must be able to process requests with the chosen header.
*/
customHostHeader?: pulumi.Input<string>;
/**
* wildcard additional CNAME. If a resource has a wildcard additional CNAME, you can use your own certificate for content delivery via HTTPS. Read-only.
*/
customServerName?: pulumi.Input<string>;
/**
* setup a cache status.
*/
disableCache?: pulumi.Input<boolean>;
/**
* disabling proxy force ranges.
*/
disableProxyForceRanges?: pulumi.Input<boolean>;
/**
* content will be cached according to origin cache settings. The value applies for a response with codes 200, 201, 204, 206, 301, 302, 303, 304, 307, 308 if an origin server does not have caching HTTP headers. Responses with other codes will not be cached.
*/
edgeCacheSettings?: pulumi.Input<number>;
/**
* option helps you to reduce the bandwidth between origin and CDN servers. Also, content delivery speed becomes higher because of reducing the time for compressing files in a CDN.
*/
fetchedCompressed?: pulumi.Input<boolean>;
/**
* choose the Forward Host header option if is important to send in the request to the Origin the same Host header as was sent in the request to CDN server.
*/
forwardHostHeader?: pulumi.Input<boolean>;
/**
* GZip compression at CDN servers reduces file size by 70% and can be as high as 90%.
*/
gzipOn?: pulumi.Input<boolean>;
/**
* set for ignoring cookie.
*/
ignoreCookie?: pulumi.Input<boolean>;
/**
* files with different query parameters are cached as objects with the same key regardless of the parameter value. selected by default.
*/
ignoreQueryParams?: pulumi.Input<boolean>;
/**
* allows caching for GET, HEAD and POST requests.
*/
proxyCacheMethodsSet?: pulumi.Input<boolean>;
/**
* files with the specified query parameters are cached as objects with the same key, files with other parameters are cached as objects with different keys.
*/
queryParamsBlacklists?: pulumi.Input<pulumi.Input<string>[]>;
/**
* files with the specified query parameters are cached as objects with different keys, files with other parameters are cached as objects with the same key.
*/
queryParamsWhitelists?: pulumi.Input<pulumi.Input<string>[]>;
/**
* set up a redirect from HTTP to HTTPS.
*/
redirectHttpToHttps?: pulumi.Input<boolean>;
/**
* set up a redirect from HTTPS to HTTP.
*/
redirectHttpsToHttp?: pulumi.Input<boolean>;
/**
* files larger than 10 MB will be requested and cached in parts (no larger than 10 MB each part). It reduces time to first byte. The origin must support HTTP Range requests.
*/
slice?: pulumi.Input<boolean>;
/**
* set up custom headers that CDN servers send in requests to origins.
*/
staticRequestHeaders?: pulumi.Input<pulumi.Input<string>[]>;
staticResponseHeaders?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
}
export interface CdnResourceSslCertificate {
certificateManagerId?: pulumi.Input<string>;
status?: pulumi.Input<string>;
type: pulumi.Input<string>;
}
export interface ComputeDiskDiskPlacementPolicy {
/**
* Specifies Disk Placement Group id.
*/
diskPlacementGroupId: pulumi.Input<string>;
}
export interface ComputeInstanceBootDisk {
/**
* Whether the disk is auto-deleted when the instance
* is deleted. The default value is false.
*/
autoDelete?: pulumi.Input<boolean>;
/**
* Name that can be used to access an attached disk
* under `/dev/disk/by-id/`.
*/
deviceName?: pulumi.Input<string>;
/**
* ID of the disk that is attached to the instance.
*/
diskId?: pulumi.Input<string>;
/**
* Parameters for a new disk that will be created
* alongside the new instance. Either `initializeParams` or `diskId` must be set. The structure is documented below.
*/
initializeParams?: pulumi.Input<inputs.ComputeInstanceBootDiskInitializeParams>;
/**
* Type of access to the disk resource. By default, a disk is attached in `READ_WRITE` mode.
*/
mode?: pulumi.Input<string>;
}
export interface ComputeInstanceBootDiskInitializeParams {
blockSize?: pulumi.Input<number>;
/**
* Description of the boot disk.
*/
description?: pulumi.Input<string>;
/**
* A disk image to initialize this disk from.
*/
imageId?: pulumi.Input<string>;
/**
* Name of the boot disk.
*/
name?: pulumi.Input<string>;
/**
* Size of the disk in GB.
*/
size?: pulumi.Input<number>;
/**
* A snapshot to initialize this disk from.
*/
snapshotId?: pulumi.Input<string>;
/**
* Disk type.
*/
type?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupAllocationPolicy {
/**
* A list of availability zones.
*/
zones: pulumi.Input<pulumi.Input<string>[]>;
}
export interface ComputeInstanceGroupApplicationLoadBalancer {
/**
* Timeout for waiting for the VM to be checked by the load balancer. If the timeout is exceeded, the VM will be turned off based on the deployment policy. Specified in seconds.
*/
maxOpeningTrafficDuration?: pulumi.Input<number>;
/**
* The status message of the instance.
*/
statusMessage?: pulumi.Input<string>;
/**
* A description of the target group.
*/
targetGroupDescription?: pulumi.Input<string>;
targetGroupId?: pulumi.Input<string>;
/**
* A set of key/value label pairs.
*/
targetGroupLabels?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
/**
* The name of the target group.
*/
targetGroupName?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupDeployPolicy {
/**
* The maximum number of instances that can be created at the same time.
*/
maxCreating?: pulumi.Input<number>;
/**
* The maximum number of instances that can be deleted at the same time.
*/
maxDeleting?: pulumi.Input<number>;
/**
* The maximum number of instances that can be temporarily allocated above the group's target size
* during the update process.
*/
maxExpansion: pulumi.Input<number>;
/**
* The maximum number of running instances that can be taken offline (stopped or deleted) at the same time
* during the update process.
*/
maxUnavailable: pulumi.Input<number>;
/**
* The amount of time in seconds to allow for an instance to start.
* Instance will be considered up and running (and start receiving traffic) only after the startupDuration
* has elapsed and all health checks are passed.
*/
startupDuration?: pulumi.Input<number>;
/**
* Affects the lifecycle of the instance during deployment. If set to `proactive` (default), Instance Groups
* can forcefully stop a running instance. If `opportunistic`, Instance Groups does not stop a running instance. Instead,
* it will wait until the instance stops itself or becomes unhealthy.
*/
strategy?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupHealthCheck {
/**
* The number of successful health checks before the managed instance is declared healthy.
*/
healthyThreshold?: pulumi.Input<number>;
/**
* HTTP check options. The structure is documented below.
*/
httpOptions?: pulumi.Input<pulumi.Input<inputs.ComputeInstanceGroupHealthCheckHttpOption>[]>;
/**
* The interval to wait between health checks in seconds.
*/
interval?: pulumi.Input<number>;
/**
* TCP check options. The structure is documented below.
*/
tcpOptions?: pulumi.Input<inputs.ComputeInstanceGroupHealthCheckTcpOptions>;
/**
* The length of time to wait for a response before the health check times out in seconds.
*/
timeout?: pulumi.Input<number>;
/**
* The number of failed health checks before the managed instance is declared unhealthy.
*/
unhealthyThreshold?: pulumi.Input<number>;
}
export interface ComputeInstanceGroupHealthCheckHttpOption {
/**
* The URL path used for health check requests.
*/
path: pulumi.Input<string>;
/**
* The port used for TCP health checks.
*/
port: pulumi.Input<number>;
}
export interface ComputeInstanceGroupHealthCheckTcpOptions {
/**
* The port used for TCP health checks.
*/
port: pulumi.Input<number>;
}
export interface ComputeInstanceGroupInstance {
/**
* DNS record fqdn (must have dot at the end).
*/
fqdn?: pulumi.Input<string>;
/**
* The ID of the instance.
*/
instanceId?: pulumi.Input<string>;
/**
* Name template of the instance.
* In order to be unique it must contain at least one of instance unique placeholders:
* {instance.short_id}
* {instance.index}
* combination of {instance.zone_id} and {instance.index_in_zone}
* Example: my-instance-{instance.index}
* If not set, default is used: {instance_group.id}-{instance.short_id}
* It may also contain another placeholders, see metadata doc for full list.
*/
name?: pulumi.Input<string>;
/**
* Network specifications for the instance. This can be used multiple times for adding multiple interfaces. The structure is documented below.
*/
networkInterfaces?: pulumi.Input<pulumi.Input<inputs.ComputeInstanceGroupInstanceNetworkInterface>[]>;
/**
* The status of the instance.
*/
status?: pulumi.Input<string>;
statusChangedAt?: pulumi.Input<string>;
/**
* The status message of the instance.
*/
statusMessage?: pulumi.Input<string>;
/**
* The ID of the availability zone where the instance resides.
*/
zoneId?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupInstanceNetworkInterface {
/**
* The index of the network interface as generated by the server.
*/
index?: pulumi.Input<number>;
/**
* Manual set static IP address.
*/
ipAddress?: pulumi.Input<string>;
/**
* True if IPv4 address allocated for the network interface.
*/
ipv4?: pulumi.Input<boolean>;
ipv6?: pulumi.Input<boolean>;
/**
* Manual set static IPv6 address.
*/
ipv6Address?: pulumi.Input<string>;
/**
* The MAC address assigned to the network interface.
*/
macAddress?: pulumi.Input<string>;
/**
* Flag for using NAT.
*/
nat?: pulumi.Input<boolean>;
/**
* A public address that can be used to access the internet over NAT. Use `variables` to set.
*/
natIpAddress?: pulumi.Input<string>;
/**
* The IP version for the public address.
*/
natIpVersion?: pulumi.Input<string>;
/**
* The ID of the subnet to attach this interface to. The subnet must reside in the same zone where this instance was created.
*/
subnetId?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupInstanceTemplate {
/**
* Boot disk specifications for the instance. The structure is documented below.
*/
bootDisk: pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateBootDisk>;
/**
* A description of the boot disk.
*/
description?: pulumi.Input<string>;
/**
* Hostname template for the instance.
* This field is used to generate the FQDN value of instance.
* The hostname must be unique within the network and region.
* If not specified, the hostname will be equal to id of the instance
* and FQDN will be `<id>.auto.internal`. Otherwise FQDN will be `<hostname>.<region_id>.internal`.
* In order to be unique it must contain at least on of instance unique placeholders:
* {instance.short_id}
* {instance.index}
* combination of {instance.zone_id} and {instance.index_in_zone}
* Example: my-instance-{instance.index}
* If not set, `name` value will be used
* It may also contain another placeholders, see metadata doc for full list.
*/
hostname?: pulumi.Input<string>;
/**
* A map of labels of metric.
*/
labels?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
/**
* A set of metadata key/value pairs to make available from within the instance.
*/
metadata?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
/**
* Name template of the instance.
* In order to be unique it must contain at least one of instance unique placeholders:
* {instance.short_id}
* {instance.index}
* combination of {instance.zone_id} and {instance.index_in_zone}
* Example: my-instance-{instance.index}
* If not set, default is used: {instance_group.id}-{instance.short_id}
* It may also contain another placeholders, see metadata doc for full list.
*/
name?: pulumi.Input<string>;
/**
* Network specifications for the instance. This can be used multiple times for adding multiple interfaces. The structure is documented below.
*/
networkInterfaces: pulumi.Input<pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateNetworkInterface>[]>;
/**
* Network acceleration type for instance. The structure is documented below.
*/
networkSettings?: pulumi.Input<pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateNetworkSetting>[]>;
/**
* The placement policy configuration. The structure is documented below.
*/
placementPolicy?: pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplatePlacementPolicy>;
/**
* The ID of the hardware platform configuration for the instance. The default is 'standard-v1'.
*/
platformId?: pulumi.Input<string>;
/**
* Compute resource specifications for the instance. The structure is documented below.
*/
resources: pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateResources>;
/**
* The scheduling policy configuration. The structure is documented below.
*/
schedulingPolicy?: pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateSchedulingPolicy>;
/**
* A list of disks to attach to the instance. The structure is documented below.
*/
secondaryDisks?: pulumi.Input<pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateSecondaryDisk>[]>;
/**
* The ID of the service account authorized for this instance.
*/
serviceAccountId?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupInstanceTemplateBootDisk {
/**
* This value can be used to reference the device under `/dev/disk/by-id/`.
*/
deviceName?: pulumi.Input<string>;
/**
* ID of the existing disk. To set use variables.
*/
diskId?: pulumi.Input<string>;
/**
* Parameters for creating a disk alongside the instance. The structure is documented below.
*/
initializeParams?: pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateBootDiskInitializeParams>;
/**
* The access mode to the disk resource. By default a disk is attached in `READ_WRITE` mode.
*/
mode?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupInstanceTemplateBootDiskInitializeParams {
/**
* A description of the boot disk.
*/
description?: pulumi.Input<string>;
/**
* The disk image to initialize this disk from.
*/
imageId?: pulumi.Input<string>;
/**
* The number of instances in the instance group.
*/
size?: pulumi.Input<number>;
/**
* The snapshot to initialize this disk from.
*/
snapshotId?: pulumi.Input<string>;
/**
* Network acceleration type. By default a network is in `STANDARD` mode.
*/
type?: pulumi.Input<string>;
}
export interface ComputeInstanceGroupInstanceTemplateNetworkInterface {
/**
* List of dns records. The structure is documented below.
*/
dnsRecords?: pulumi.Input<pulumi.Input<inputs.ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecord>[]>;
/**
* Manual set static IP address.
*/
ipAddress?: pulumi.Input<string>;
/**
* True if IPv4 address allocated for the network interface.
*/
ipv4?: pulumi.In