@upcloud/pulumi-upcloud
Version:
A Pulumi package for creating and managing UpCloud resources.
1,640 lines • 138 kB
TypeScript
import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
export interface GatewayAddress {
/**
* IP addresss
*/
address?: pulumi.Input<string>;
/**
* Name of the IP address
*/
name?: pulumi.Input<string>;
}
export interface GatewayConnectionLocalRoute {
/**
* Name of the route
*/
name: pulumi.Input<string>;
/**
* Destination prefix of the route; needs to be a valid IPv4 prefix
*/
staticNetwork: pulumi.Input<string>;
/**
* Type of route; currently the only supported type is 'static'
*/
type?: pulumi.Input<string>;
}
export interface GatewayConnectionRemoteRoute {
/**
* Name of the route
*/
name: pulumi.Input<string>;
/**
* Destination prefix of the route; needs to be a valid IPv4 prefix
*/
staticNetwork: pulumi.Input<string>;
/**
* Type of route; currently the only supported type is 'static'
*/
type?: pulumi.Input<string>;
}
export interface GatewayConnectionTunnelIpsecAuthPsk {
/**
* The pre-shared key. This value is only used during resource creation and is not returned in the state. It is not possible to update this value. If you need to update it, delete the connection and create a new one.
*/
psk: pulumi.Input<string>;
}
export interface GatewayConnectionTunnelIpsecProperties {
/**
* IKE child SA rekey time in seconds.
*/
childRekeyTime?: pulumi.Input<number>;
/**
* Delay before sending Dead Peer Detection packets if no traffic is detected, in seconds.
*/
dpdDelay?: pulumi.Input<number>;
/**
* Timeout period for DPD reply before considering the peer to be dead, in seconds.
*/
dpdTimeout?: pulumi.Input<number>;
/**
* Maximum IKE SA lifetime in seconds.
*/
ikeLifetime?: pulumi.Input<number>;
/**
* List of Phase 1: Proposal algorithms.
*/
phase1Algorithms?: pulumi.Input<pulumi.Input<string>[]>;
/**
* List of Phase 1 Diffie-Hellman group numbers.
*/
phase1DhGroupNumbers?: pulumi.Input<pulumi.Input<number>[]>;
/**
* List of Phase 1 integrity algorithms.
*/
phase1IntegrityAlgorithms?: pulumi.Input<pulumi.Input<string>[]>;
/**
* List of Phase 2: Security Association algorithms.
*/
phase2Algorithms?: pulumi.Input<pulumi.Input<string>[]>;
/**
* List of Phase 2 Diffie-Hellman group numbers.
*/
phase2DhGroupNumbers?: pulumi.Input<pulumi.Input<number>[]>;
/**
* List of Phase 2 integrity algorithms.
*/
phase2IntegrityAlgorithms?: pulumi.Input<pulumi.Input<string>[]>;
/**
* IKE SA rekey time in seconds.
*/
rekeyTime?: pulumi.Input<number>;
}
export interface GatewayRouter {
/**
* ID of the router attached to the gateway.
*/
id: pulumi.Input<string>;
}
export interface GetHostsHost {
/**
* Free form text describing the host
*/
description?: string;
/**
* The unique id of the host
*/
hostId?: number;
statistics?: inputs.GetHostsHostStatistic[];
/**
* If true, this node can be used as a host for Windows servers.
*/
windowsEnabled?: boolean;
/**
* The zone the host is in, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
*/
zone?: string;
}
export interface GetHostsHostArgs {
/**
* Free form text describing the host
*/
description?: pulumi.Input<string>;
/**
* The unique id of the host
*/
hostId?: pulumi.Input<number>;
statistics?: pulumi.Input<pulumi.Input<inputs.GetHostsHostStatisticArgs>[]>;
/**
* If true, this node can be used as a host for Windows servers.
*/
windowsEnabled?: pulumi.Input<boolean>;
/**
* The zone the host is in, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
*/
zone?: pulumi.Input<string>;
}
export interface GetHostsHostStatistic {
/**
* The name of the statistic
*/
name?: string;
/**
* The timestamp of the statistic
*/
timestamp?: string;
/**
* The value of the statistic
*/
value?: number;
}
export interface GetHostsHostStatisticArgs {
/**
* The name of the statistic
*/
name?: pulumi.Input<string>;
/**
* The timestamp of the statistic
*/
timestamp?: pulumi.Input<string>;
/**
* The value of the statistic
*/
value?: pulumi.Input<number>;
}
export interface GetIpAddressesAddress {
/**
* Is address for utility or public network
*/
access?: string;
/**
* An UpCloud assigned IP Address
*/
address?: string;
/**
* IP address family
*/
family?: string;
/**
* Does the IP Address represents a floating IP Address
*/
floating?: boolean;
/**
* MAC address of server interface to assign address to
*/
mac?: string;
/**
* Is the address a part of a plan
*/
partOfPlan?: boolean;
/**
* A reverse DNS record entry
*/
ptrRecord?: string;
/**
* The unique identifier for a server
*/
server?: string;
/**
* Zone of address, required when assigning a detached floating IP address, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
*/
zone?: string;
}
export interface GetIpAddressesAddressArgs {
/**
* Is address for utility or public network
*/
access?: pulumi.Input<string>;
/**
* An UpCloud assigned IP Address
*/
address?: pulumi.Input<string>;
/**
* IP address family
*/
family?: pulumi.Input<string>;
/**
* Does the IP Address represents a floating IP Address
*/
floating?: pulumi.Input<boolean>;
/**
* MAC address of server interface to assign address to
*/
mac?: pulumi.Input<string>;
/**
* Is the address a part of a plan
*/
partOfPlan?: pulumi.Input<boolean>;
/**
* A reverse DNS record entry
*/
ptrRecord?: pulumi.Input<string>;
/**
* The unique identifier for a server
*/
server?: pulumi.Input<string>;
/**
* Zone of address, required when assigning a detached floating IP address, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
*/
zone?: pulumi.Input<string>;
}
export interface GetManagedDatabaseMysqlSessionsSession {
/**
* Name of the application that is connected to this service.
*/
applicationName?: string;
/**
* IP address of the client connected to this service.
*/
clientAddr?: string;
/**
* Name of the database this service is connected to.
*/
datname?: string;
/**
* Process ID of this service.
*/
id?: string;
/**
* Text of this service's most recent query. If state is active this field shows the currently executing query. In all other states, it shows an empty string.
*/
query?: string;
/**
* The active query current duration.
*/
queryDuration?: string;
/**
* Current overall state of this service: active: The service is executing a query, idle: The service is waiting for a new client command.
*/
state?: string;
/**
* Name of the user logged into this service.
*/
usename?: string;
}
export interface GetManagedDatabaseMysqlSessionsSessionArgs {
/**
* Name of the application that is connected to this service.
*/
applicationName?: pulumi.Input<string>;
/**
* IP address of the client connected to this service.
*/
clientAddr?: pulumi.Input<string>;
/**
* Name of the database this service is connected to.
*/
datname?: pulumi.Input<string>;
/**
* Process ID of this service.
*/
id?: pulumi.Input<string>;
/**
* Text of this service's most recent query. If state is active this field shows the currently executing query. In all other states, it shows an empty string.
*/
query?: pulumi.Input<string>;
/**
* The active query current duration.
*/
queryDuration?: pulumi.Input<string>;
/**
* Current overall state of this service: active: The service is executing a query, idle: The service is waiting for a new client command.
*/
state?: pulumi.Input<string>;
/**
* Name of the user logged into this service.
*/
usename?: pulumi.Input<string>;
}
export interface GetManagedDatabaseOpensearchIndicesIndex {
/**
* Timestamp indicating the creation time of the index.
*/
createTime?: string;
/**
* Number of documents stored in the index.
*/
docs?: number;
/**
* Health status of the index e.g. `green`, `yellow`, or `red`.
*/
health?: string;
/**
* Name of the index.
*/
indexName?: string;
/**
* Number of replicas configured for the index.
*/
numberOfReplicas?: number;
/**
* Number of shards configured & used by the index.
*/
numberOfShards?: number;
/**
* Indicates whether the index is in a read-only state that permits deletion of the entire index. This attribute can be automatically set to true in certain scenarios where the node disk space exceeds the flood stage.
*/
readOnlyAllowDelete?: boolean;
/**
* Size of the index in bytes.
*/
size?: number;
/**
* Status of the index e.g. `open` or `closed`.
*/
status?: string;
}
export interface GetManagedDatabaseOpensearchIndicesIndexArgs {
/**
* Timestamp indicating the creation time of the index.
*/
createTime?: pulumi.Input<string>;
/**
* Number of documents stored in the index.
*/
docs?: pulumi.Input<number>;
/**
* Health status of the index e.g. `green`, `yellow`, or `red`.
*/
health?: pulumi.Input<string>;
/**
* Name of the index.
*/
indexName?: pulumi.Input<string>;
/**
* Number of replicas configured for the index.
*/
numberOfReplicas?: pulumi.Input<number>;
/**
* Number of shards configured & used by the index.
*/
numberOfShards?: pulumi.Input<number>;
/**
* Indicates whether the index is in a read-only state that permits deletion of the entire index. This attribute can be automatically set to true in certain scenarios where the node disk space exceeds the flood stage.
*/
readOnlyAllowDelete?: pulumi.Input<boolean>;
/**
* Size of the index in bytes.
*/
size?: pulumi.Input<number>;
/**
* Status of the index e.g. `open` or `closed`.
*/
status?: pulumi.Input<string>;
}
export interface GetManagedDatabasePostgresqlSessionsSession {
/**
* Name of the application that is connected to this service.
*/
applicationName?: string;
/**
* Time when this process was started, i.e., when the client connected to the server.
*/
backendStart?: string;
/**
* Type of current service.
*/
backendType?: string;
/**
* Top-level transaction identifier of this service, if any.
*/
backendXid?: number;
/**
* The current service's xmin horizon.
*/
backendXmin?: number;
/**
* IP address of the client connected to this service. If this field is null, it indicates either that the client is connected via a Unix socket on the server machine or that this is an internal process such as autovacuum.
*/
clientAddr?: string;
/**
* Host name of the connected client, as reported by a reverse DNS lookup of `clientAddr`.
*/
clientHostname?: string;
/**
* TCP port number that the client is using for communication with this service, or -1 if a Unix socket is used.
*/
clientPort?: number;
/**
* OID of the database this service is connected to.
*/
datid?: number;
/**
* Name of the database this service is connected to.
*/
datname?: string;
/**
* Process ID of this service.
*/
id?: string;
/**
* Text of this service's most recent query. If state is active this field shows the currently executing query. In all other states, it shows the last query that was executed.
*/
query?: string;
/**
* The active query current duration.
*/
queryDuration?: string;
/**
* Time when the currently active query was started, or if state is not active, when the last query was started.
*/
queryStart?: string;
/**
* Current overall state of this service: active: The service is executing a query, idle: The service is waiting for a new client command.
*/
state?: string;
/**
* Time when the state was last changed.
*/
stateChange?: string;
/**
* Name of the user logged into this service.
*/
usename?: string;
/**
* OID of the user logged into this service.
*/
usesysid?: number;
/**
* Wait event name if service is currently waiting.
*/
waitEvent?: string;
/**
* The type of event for which the service is waiting, if any; otherwise NULL.
*/
waitEventType?: string;
/**
* Time when this process' current transaction was started, or null if no transaction is active.
*/
xactStart?: string;
}
export interface GetManagedDatabasePostgresqlSessionsSessionArgs {
/**
* Name of the application that is connected to this service.
*/
applicationName?: pulumi.Input<string>;
/**
* Time when this process was started, i.e., when the client connected to the server.
*/
backendStart?: pulumi.Input<string>;
/**
* Type of current service.
*/
backendType?: pulumi.Input<string>;
/**
* Top-level transaction identifier of this service, if any.
*/
backendXid?: pulumi.Input<number>;
/**
* The current service's xmin horizon.
*/
backendXmin?: pulumi.Input<number>;
/**
* IP address of the client connected to this service. If this field is null, it indicates either that the client is connected via a Unix socket on the server machine or that this is an internal process such as autovacuum.
*/
clientAddr?: pulumi.Input<string>;
/**
* Host name of the connected client, as reported by a reverse DNS lookup of `clientAddr`.
*/
clientHostname?: pulumi.Input<string>;
/**
* TCP port number that the client is using for communication with this service, or -1 if a Unix socket is used.
*/
clientPort?: pulumi.Input<number>;
/**
* OID of the database this service is connected to.
*/
datid?: pulumi.Input<number>;
/**
* Name of the database this service is connected to.
*/
datname?: pulumi.Input<string>;
/**
* Process ID of this service.
*/
id?: pulumi.Input<string>;
/**
* Text of this service's most recent query. If state is active this field shows the currently executing query. In all other states, it shows the last query that was executed.
*/
query?: pulumi.Input<string>;
/**
* The active query current duration.
*/
queryDuration?: pulumi.Input<string>;
/**
* Time when the currently active query was started, or if state is not active, when the last query was started.
*/
queryStart?: pulumi.Input<string>;
/**
* Current overall state of this service: active: The service is executing a query, idle: The service is waiting for a new client command.
*/
state?: pulumi.Input<string>;
/**
* Time when the state was last changed.
*/
stateChange?: pulumi.Input<string>;
/**
* Name of the user logged into this service.
*/
usename?: pulumi.Input<string>;
/**
* OID of the user logged into this service.
*/
usesysid?: pulumi.Input<number>;
/**
* Wait event name if service is currently waiting.
*/
waitEvent?: pulumi.Input<string>;
/**
* The type of event for which the service is waiting, if any; otherwise NULL.
*/
waitEventType?: pulumi.Input<string>;
/**
* Time when this process' current transaction was started, or null if no transaction is active.
*/
xactStart?: pulumi.Input<string>;
}
export interface GetManagedDatabaseRedisSessionsSession {
/**
* Number of active channel subscriptions
*/
activeChannelSubscriptions?: number;
/**
* Current database ID
*/
activeDatabase?: string;
/**
* Number of pattern matching subscriptions.
*/
activePatternMatchingChannelSubscriptions?: number;
/**
* Name of the application that is connected to this service.
*/
applicationName?: string;
/**
* Number of pattern matching subscriptions.
*/
clientAddr?: string;
/**
* Total duration of the connection in nanoseconds.
*/
connectionAge?: number;
/**
* Idle time of the connection in nanoseconds.
*/
connectionIdle?: number;
/**
* A set containing flags' descriptions.
*/
flags?: string[];
/**
* Client connection flags in raw string format.
*/
flagsRaw?: string;
/**
* Process ID of this session.
*/
id?: string;
/**
* Number of commands in a MULTI/EXEC context.
*/
multiExecCommands?: number;
/**
* Output buffer length.
*/
outputBuffer?: number;
/**
* Output buffer memory usage.
*/
outputBufferMemory?: number;
/**
* Output list length (replies are queued in this list when the buffer is full).
*/
outputListLength?: number;
/**
* The last executed command.
*/
query?: string;
/**
* Query buffer length (0 means no query pending).
*/
queryBuffer?: number;
/**
* Free space of the query buffer (0 means the buffer is full).
*/
queryBufferFree?: number;
}
export interface GetManagedDatabaseRedisSessionsSessionArgs {
/**
* Number of active channel subscriptions
*/
activeChannelSubscriptions?: pulumi.Input<number>;
/**
* Current database ID
*/
activeDatabase?: pulumi.Input<string>;
/**
* Number of pattern matching subscriptions.
*/
activePatternMatchingChannelSubscriptions?: pulumi.Input<number>;
/**
* Name of the application that is connected to this service.
*/
applicationName?: pulumi.Input<string>;
/**
* Number of pattern matching subscriptions.
*/
clientAddr?: pulumi.Input<string>;
/**
* Total duration of the connection in nanoseconds.
*/
connectionAge?: pulumi.Input<number>;
/**
* Idle time of the connection in nanoseconds.
*/
connectionIdle?: pulumi.Input<number>;
/**
* A set containing flags' descriptions.
*/
flags?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Client connection flags in raw string format.
*/
flagsRaw?: pulumi.Input<string>;
/**
* Process ID of this session.
*/
id?: pulumi.Input<string>;
/**
* Number of commands in a MULTI/EXEC context.
*/
multiExecCommands?: pulumi.Input<number>;
/**
* Output buffer length.
*/
outputBuffer?: pulumi.Input<number>;
/**
* Output buffer memory usage.
*/
outputBufferMemory?: pulumi.Input<number>;
/**
* Output list length (replies are queued in this list when the buffer is full).
*/
outputListLength?: pulumi.Input<number>;
/**
* The last executed command.
*/
query?: pulumi.Input<string>;
/**
* Query buffer length (0 means no query pending).
*/
queryBuffer?: pulumi.Input<number>;
/**
* Free space of the query buffer (0 means the buffer is full).
*/
queryBufferFree?: pulumi.Input<number>;
}
export interface GetManagedDatabaseValkeySessionsSession {
/**
* Number of active channel subscriptions
*/
activeChannelSubscriptions?: number;
/**
* Current database ID
*/
activeDatabase?: string;
/**
* Number of pattern matching subscriptions.
*/
activePatternMatchingChannelSubscriptions?: number;
/**
* Name of the application that is connected to this service.
*/
applicationName?: string;
/**
* Number of pattern matching subscriptions.
*/
clientAddr?: string;
/**
* Total duration of the connection in nanoseconds.
*/
connectionAge?: number;
/**
* Idle time of the connection in nanoseconds.
*/
connectionIdle?: number;
/**
* A set containing flags' descriptions.
*/
flags?: string[];
/**
* Client connection flags in raw string format.
*/
flagsRaw?: string;
/**
* Process ID of this session.
*/
id?: string;
/**
* Number of commands in a MULTI/EXEC context.
*/
multiExecCommands?: number;
/**
* Output buffer length.
*/
outputBuffer?: number;
/**
* Output buffer memory usage.
*/
outputBufferMemory?: number;
/**
* Output list length (replies are queued in this list when the buffer is full).
*/
outputListLength?: number;
/**
* The last executed command.
*/
query?: string;
/**
* Query buffer length (0 means no query pending).
*/
queryBuffer?: number;
/**
* Free space of the query buffer (0 means the buffer is full).
*/
queryBufferFree?: number;
}
export interface GetManagedDatabaseValkeySessionsSessionArgs {
/**
* Number of active channel subscriptions
*/
activeChannelSubscriptions?: pulumi.Input<number>;
/**
* Current database ID
*/
activeDatabase?: pulumi.Input<string>;
/**
* Number of pattern matching subscriptions.
*/
activePatternMatchingChannelSubscriptions?: pulumi.Input<number>;
/**
* Name of the application that is connected to this service.
*/
applicationName?: pulumi.Input<string>;
/**
* Number of pattern matching subscriptions.
*/
clientAddr?: pulumi.Input<string>;
/**
* Total duration of the connection in nanoseconds.
*/
connectionAge?: pulumi.Input<number>;
/**
* Idle time of the connection in nanoseconds.
*/
connectionIdle?: pulumi.Input<number>;
/**
* A set containing flags' descriptions.
*/
flags?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Client connection flags in raw string format.
*/
flagsRaw?: pulumi.Input<string>;
/**
* Process ID of this session.
*/
id?: pulumi.Input<string>;
/**
* Number of commands in a MULTI/EXEC context.
*/
multiExecCommands?: pulumi.Input<number>;
/**
* Output buffer length.
*/
outputBuffer?: pulumi.Input<number>;
/**
* Output buffer memory usage.
*/
outputBufferMemory?: pulumi.Input<number>;
/**
* Output list length (replies are queued in this list when the buffer is full).
*/
outputListLength?: pulumi.Input<number>;
/**
* The last executed command.
*/
query?: pulumi.Input<string>;
/**
* Query buffer length (0 means no query pending).
*/
queryBuffer?: pulumi.Input<number>;
/**
* Free space of the query buffer (0 means the buffer is full).
*/
queryBufferFree?: pulumi.Input<number>;
}
export interface GetManagedObjectStorageRegionsRegion {
/**
* Name of the region.
*/
name?: string;
/**
* Primary zone of the region.
*/
primaryZone?: string;
/**
* List of zones in the region.
*/
zones?: string[];
}
export interface GetManagedObjectStorageRegionsRegionArgs {
/**
* Name of the region.
*/
name?: pulumi.Input<string>;
/**
* Primary zone of the region.
*/
primaryZone?: pulumi.Input<string>;
/**
* List of zones in the region.
*/
zones?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface KubernetesNodeGroupCustomPlan {
/**
* The number of CPU cores dedicated to individual node group nodes when using custom plan
*/
cores: pulumi.Input<number>;
/**
* The amount of memory in megabytes to assign to individual node group node when using custom plan. Value needs to be divisible by 1024.
*/
memory: pulumi.Input<number>;
/**
* The size of the storage device in gigabytes.
*/
storageSize: pulumi.Input<number>;
/**
* The storage tier to use. Defaults to maxiops
*/
storageTier?: pulumi.Input<string>;
}
export interface KubernetesNodeGroupKubeletArg {
/**
* Kubelet argument key.
*/
key: pulumi.Input<string>;
/**
* Kubelet argument value.
*/
value: pulumi.Input<string>;
}
export interface KubernetesNodeGroupTaint {
/**
* Taint effect.
*/
effect: pulumi.Input<string>;
/**
* Taint key.
*/
key: pulumi.Input<string>;
/**
* Taint value.
*/
value: pulumi.Input<string>;
}
export interface LoadbalancerBackendProperties {
/**
* Expected HTTP status code returned by the customer application to mark server as healthy. Ignored for `tcp` `healthCheckType`.
*/
healthCheckExpectedStatus?: pulumi.Input<number>;
/**
* Sets how many failed health checks are allowed until the backend member is taken off from the rotation.
*/
healthCheckFall?: pulumi.Input<number>;
/**
* Interval between health checks in seconds.
*/
healthCheckInterval?: pulumi.Input<number>;
/**
* Sets how many successful health checks are required to put the backend member back into rotation.
*/
healthCheckRise?: pulumi.Input<number>;
/**
* Enables certificate verification with the system CA certificate bundle. Works with https scheme in health_check_url, otherwise ignored.
*/
healthCheckTlsVerify?: pulumi.Input<boolean>;
/**
* Health check type.
*/
healthCheckType?: pulumi.Input<string>;
/**
* Target path for health check HTTP GET requests. Ignored for `tcp` `healthCheckType`.
*/
healthCheckUrl?: pulumi.Input<string>;
/**
* Allow HTTP/2 connections to backend members by utilizing ALPN extension of TLS protocol, therefore it can only be enabled when tlsEnabled is set to true. Note: members should support HTTP/2 for this setting to work.
*/
http2Enabled?: pulumi.Input<boolean>;
/**
* Enable outbound proxy protocol by setting the desired version. Defaults to empty string. Empty string disables proxy protocol.
*/
outboundProxyProtocol?: pulumi.Input<string>;
/**
* Sets sticky session cookie name. Empty string disables sticky session.
*/
stickySessionCookieName?: pulumi.Input<string>;
/**
* Backend server timeout in seconds.
*/
timeoutServer?: pulumi.Input<number>;
/**
* Maximum inactivity time on the client and server side for tunnels in seconds.
*/
timeoutTunnel?: pulumi.Input<number>;
/**
* Enables TLS connection from the load balancer to backend servers.
*/
tlsEnabled?: pulumi.Input<boolean>;
/**
* If enabled, then the system CA certificate bundle will be used for the certificate verification.
*/
tlsUseSystemCa?: pulumi.Input<boolean>;
/**
* Enables backend servers certificate verification. Please make sure that TLS config with the certificate bundle of type authority attached to the backend or `tlsUseSystemCa` enabled. Note: `tlsVerify` has preference over `healthCheckTlsVerify` when `tlsEnabled` in true.
*/
tlsVerify?: pulumi.Input<boolean>;
}
export interface LoadbalancerFrontendNetwork {
/**
* Name of the load balancer network.
*/
name: pulumi.Input<string>;
}
export interface LoadbalancerFrontendProperties {
/**
* Enable or disable HTTP/2 support.
*/
http2Enabled?: pulumi.Input<boolean>;
/**
* Enable or disable inbound proxy protocol support.
*/
inboundProxyProtocol?: pulumi.Input<boolean>;
/**
* Client request timeout in seconds.
*/
timeoutClient?: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleActions {
/**
* Redirects HTTP requests to specified location or URL scheme. Only either location or scheme can be defined at a time.
*/
httpRedirects?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsHttpRedirect>[]>;
/**
* Returns HTTP response with specified HTTP status.
*/
httpReturns?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsHttpReturn>[]>;
/**
* Adds 'X-Forwarded-For / -Proto / -Port' headers in your forwarded requests
*/
setForwardedHeaders?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsSetForwardedHeader>[]>;
/**
* Set request header
*/
setRequestHeaders?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsSetRequestHeader>[]>;
/**
* Set response header
*/
setResponseHeaders?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsSetResponseHeader>[]>;
/**
* Terminates a connection.
*/
tcpRejects?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsTcpReject>[]>;
/**
* Routes traffic to specified `backend`.
*/
useBackends?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleActionsUseBackend>[]>;
}
export interface LoadbalancerFrontendRuleActionsHttpRedirect {
/**
* Target location.
*/
location?: pulumi.Input<string>;
/**
* Target scheme.
*/
scheme?: pulumi.Input<string>;
/**
* HTTP status code.
*/
status?: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleActionsHttpReturn {
/**
* Content type.
*/
contentType: pulumi.Input<string>;
/**
* The payload.
*/
payload: pulumi.Input<string>;
/**
* HTTP status code.
*/
status: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleActionsSetForwardedHeader {
active?: pulumi.Input<boolean>;
}
export interface LoadbalancerFrontendRuleActionsSetRequestHeader {
/**
* Header name.
*/
header: pulumi.Input<string>;
/**
* Header value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleActionsSetResponseHeader {
/**
* Header name.
*/
header: pulumi.Input<string>;
/**
* Header value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleActionsTcpReject {
/**
* Indicates if the rule is active.
*/
active?: pulumi.Input<boolean>;
}
export interface LoadbalancerFrontendRuleActionsUseBackend {
/**
* The name of the backend where traffic will be routed.
*/
backendName: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchers {
/**
* Matches by range of HTTP request body sizes.
*/
bodySizeRanges?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersBodySizeRange>[]>;
/**
* Matches by HTTP request body size.
*/
bodySizes?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersBodySize>[]>;
/**
* Matches by HTTP cookie value. Cookie name must be provided.
*/
cookies?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersCookie>[]>;
/**
* Matches by HTTP header value. Header name must be provided.
*
* @deprecated Use `requestHeader` instead.
*/
headers?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersHeader>[]>;
/**
* Matches by hostname. Header extracted from HTTP Headers or from TLS certificate in case of secured connection.
*/
hosts?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersHost>[]>;
/**
* Matches by HTTP method.
*/
httpMethods?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersHttpMethod>[]>;
/**
* Matches by range of HTTP statuses.
*/
httpStatusRanges?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersHttpStatusRange>[]>;
/**
* Matches by HTTP status.
*/
httpStatuses?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersHttpStatus>[]>;
/**
* Matches by number of healthy backend members.
*/
numMembersUps?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersNumMembersUp>[]>;
/**
* Matches by URL path.
*/
paths?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersPath>[]>;
/**
* Matches by HTTP request header value. Header name must be provided.
*/
requestHeaders?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersRequestHeader>[]>;
/**
* Matches by HTTP response header value. Header name must be provided.
*/
responseHeaders?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersResponseHeader>[]>;
/**
* Matches by source IP address.
*/
srcIps?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersSrcIp>[]>;
/**
* Matches by range of source port numbers.
*/
srcPortRanges?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersSrcPortRange>[]>;
/**
* Matches by source port number.
*/
srcPorts?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersSrcPort>[]>;
/**
* Matches by URL query parameter value. Query parameter name must be provided
*/
urlParams?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersUrlParam>[]>;
/**
* Matches by URL query string.
*/
urlQueries?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersUrlQuery>[]>;
/**
* Matches by URL without schema, e.g. `example.com/dashboard`.
*/
urls?: pulumi.Input<pulumi.Input<inputs.LoadbalancerFrontendRuleMatchersUrl>[]>;
}
export interface LoadbalancerFrontendRuleMatchersBodySize {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`equal`, `greater`, `greaterOrEqual`, `less`, `lessOrEqual`).
*/
method: pulumi.Input<string>;
/**
* Integer value.
*/
value: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersBodySizeRange {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Integer value.
*/
rangeEnd: pulumi.Input<number>;
/**
* Integer value.
*/
rangeStart: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersCookie {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* Name of the argument.
*/
name: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersHeader {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* Name of the argument.
*/
name: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersHost {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* String value.
*/
value: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersHttpMethod {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* String value (`GET`, `HEAD`, `POST`, `PUT`, `PATCH`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`).
*/
value: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersHttpStatus {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`equal`, `greater`, `greaterOrEqual`, `less`, `lessOrEqual`).
*/
method: pulumi.Input<string>;
/**
* Integer value.
*/
value: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersHttpStatusRange {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Integer value.
*/
rangeEnd: pulumi.Input<number>;
/**
* Integer value.
*/
rangeStart: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersNumMembersUp {
/**
* The name of the `backend`.
*/
backendName: pulumi.Input<string>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`equal`, `greater`, `greaterOrEqual`, `less`, `lessOrEqual`).
*/
method: pulumi.Input<string>;
/**
* Integer value.
*/
value: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersPath {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersRequestHeader {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* Name of the argument.
*/
name: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersResponseHeader {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* Name of the argument.
*/
name: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersSrcIp {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* IP address. CIDR masks are supported, e.g. `192.168.0.0/24`.
*/
value: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersSrcPort {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`equal`, `greater`, `greaterOrEqual`, `less`, `lessOrEqual`).
*/
method: pulumi.Input<string>;
/**
* Integer value.
*/
value: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersSrcPortRange {
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Integer value.
*/
rangeEnd: pulumi.Input<number>;
/**
* Integer value.
*/
rangeStart: pulumi.Input<number>;
}
export interface LoadbalancerFrontendRuleMatchersUrl {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersUrlParam {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* Name of the argument.
*/
name: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerFrontendRuleMatchersUrlQuery {
/**
* Defines if case should be ignored. Defaults to `false`.
*/
ignoreCase?: pulumi.Input<boolean>;
/**
* Defines if the condition should be inverted. Works similarly to logical NOT operator.
*/
inverse?: pulumi.Input<boolean>;
/**
* Match method (`exact`, `substring`, `regexp`, `starts`, `ends`, `domain`, `ip`, `exists`). Matcher with `exists` and `ip` methods must be used without `value` and `ignoreCase` fields.
*/
method: pulumi.Input<string>;
/**
* String value.
*/
value?: pulumi.Input<string>;
}
export interface LoadbalancerNetwork {
/**
* DNS name of the load balancer network
*/
dnsName?: pulumi.Input<string>;
/**
* Network family. Currently only `IPv4` is supported.
*/
family: pulumi.Input<string>;
/**
* The unique identifier of the network.
*/
id?: pulumi.Input<string>;
/**
* The name of the network. Must be unique within the service.
*/
name: pulumi.Input<string>;
/**
* Private network UUID. Required for private networks and must reside in loadbalancer zone. For public network the field should be omitted.
*/
network?: pulumi.Input<string>;
/**
* The type of the network. Only one public network can be attached and at least one private network must be attached.
*/
type: pulumi.Input<string>;
}
export interface LoadbalancerNode {
/**
* Networks attached to the node
*/
networks?: pulumi.Input<pulumi.Input<inputs.LoadbalancerNodeNetwork>[]>;
/**
* Node's operational state. Managed by the system.
*/
operationalState?: pulumi.Input<string>;
}
export interface LoadbalancerNodeNetwork {
/**
* IP addresses attached to the network
*/
ipAddresses?: pulumi.Input<pulumi.Input<inputs.LoadbalancerNodeNetworkIpAddress>[]>;
/**
* The name of the network
*/
name?: pulumi.Input<string>;
/**
* The type of the network
*/
type?: pulumi.Input<string>;
}
export interface LoadbalancerNodeNetworkIpAddress {
/**
* Node's IP address
*/
address?: pulumi.Input<string>;
/**
* Whether the node listens to the traffic
*/
listen?: pulumi.Input<boolean>;
}
export interface ManagedDatabaseMysqlComponent {
/**
* Type of the component
*/
component?: pulumi.Input<string>;
/**
* Hostname of the component
*/
host?: pulumi.Input<string>;
/**
* Port number of the component
*/
port?: pulumi.Input<number>;
/**
* Component network route type
*/
route?: pulumi.Input<string>;
/**
* Usage of the component
*/
usage?: pulumi.Input<string>;
}
export interface ManagedDatabaseMysqlNetwork {
/**
* Network family. Currently only `IPv4` is supported.
*/
family: pulumi.Input<string>;
/**
* The name of the network. Must be unique within the service.
*/
name: pulumi.Input<string>;
/**
* The type of the network. Must be private.
*/
type: pulumi.Input<string>;
/**
* Private network UUID. Must reside in the same zone as the database.
*/
uuid: pulumi.Input<string>;
}
export interface ManagedDatabaseMysqlNodeState {
/**
* Name plus a node iteration
*/
name?: pulumi.Input<string>;
/**
* Role of the node
*/
role?: pulumi.Input<string>;
/**
* State of the node
*/
state?: pulumi.Input<string>;
}
export interface ManagedDatabaseMysqlProperties {
/**
* Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
*/
adminPassword?: pulumi.Input<string>;
/**
* Custom username for admin user. This must be set only when a new service is being created.
*/
adminUsername?: pulumi.Input<string>;
/**
* Automatic utility network IP Filter. Automatically allow connections from servers in the utility network within the same zone.
*/
automaticUtilityNetworkIpFilter?: pulumi.Input<boolean>;
/**
* The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
*/
backupHour?: pulumi.Input<number>;
/**
* The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
*/
backupMinute?: pulumi.Input<number>;
/**
* The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector.
*/
binlogRetentionPeriod?: pulumi.Input<number>;
/**
* The number of seconds that the mysqld server waits for a connect packet before responding with Bad handshake.
*/
connectTimeout?: pulumi.Input<number>;
/**
* Default server time zone as an offset from UTC (from -12:00 to +12:00), a time zone name, or 'SYSTEM' to use the MySQL server default.
*/
defaultTimeZone?: pulumi.Input<string>;
/**
* The maximum permitted result length in bytes for the GROUP_CONCAT() function.
*/
groupConcatMaxLen?: pulumi.Input<number>;
/**
* The time, in seconds, before cached statistics expire.
*/
informationSchemaStatsExpiry?: pulumi.Input<number>;
/**
* Maximum size for the InnoDB change buffer, as a percentage of the total size of the buffer pool. Default is 25.
*/
innodbChangeBufferMaxSize?: pulumi.Input<number>;
/**
* Specifies whether flushing a page from the InnoDB buffer pool also flushes other dirty pages in the same extent (default is 1): 0 - dirty pages in the same extent are not flushed, 1 - flush contiguous dirty pages in the same extent, 2 - flush dirty pages in the same extent.
*/
innodbFlushNeighbors?: pulumi.Input<number>;
/**
* Minimum length of words that are stored in an InnoDB FULLTEXT index. Changing this parameter will lead to a restart of the MySQL service.
*/
innodbFtMinTokenSize?: pulumi.Input<number>;
/**
* This option is used to specify your own InnoDB FULLTEXT index stopword list for all InnoDB tables.
*/
innodbFtServerStopwordTable?: pulumi.Input<string>;
/**
* The length of time in seconds an InnoDB transaction waits for a row lock before giving up. Default is 120.
*/
innodbLockWaitTimeout?: pulumi.Input<number>;
/**
* The size in bytes of the buffer that InnoDB uses to write to the log files on disk.
*/
innodbLogBufferSize?: pulumi.Input<number>;
/**
* The upper limit in bytes on the size of the temporary log files used during online DDL operations for InnoDB tables.
*/
innodbOnlineAlterLogMaxSize?: pulumi.Input<number>;
/**
* When enabled, information about all deadlocks in InnoDB user transactions is recorded in the error log. Disabled by default.
*/
innodbPrintAllDeadloc