@pulumiverse/cpln
Version:
A Pulumi package for creating and managing Control Plane (cpln) resources.
1,505 lines • 232 kB
TypeScript
import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
export interface CatalogTemplateResource {
/**
* The kind of resource (e.g., 'workload', 'secret', 'gvc').
*/
kind?: pulumi.Input<string>;
/**
* The full Control Plane link to the resource.
*/
link?: pulumi.Input<string>;
/**
* The name of the resource.
*/
name?: pulumi.Input<string>;
}
export interface CloudAccountAws {
/**
* Amazon Resource Name (ARN) Role.
*/
roleArn?: pulumi.Input<string>;
}
export interface CloudAccountAzure {
/**
* Full link to an Azure secret. (e.g., /org/ORG_NAME/secret/AZURE_SECRET).
*/
secretLink?: pulumi.Input<string>;
}
export interface CloudAccountGcp {
/**
* GCP project ID. Obtained from the GCP cloud console.
*/
projectId?: pulumi.Input<string>;
}
export interface CloudAccountNgs {
/**
* Full link to a NATS Account Secret secret. (e.g., /org/ORG_NAME/secret/NATS_ACCOUNT_SECRET).
*/
secretLink?: pulumi.Input<string>;
}
export interface CloudAccountStatus {
/**
* ISO-8601 timestamp of the last time the Cloud Account credentials were validated.
*/
lastChecked?: pulumi.Input<string>;
/**
* The last error message reported when validating the Cloud Account credentials.
*/
lastError?: pulumi.Input<string>;
/**
* Whether the Cloud Account credentials are valid and usable by Control Plane.
*/
usable?: pulumi.Input<boolean>;
}
export interface CustomLocationGeo {
/**
* City of the location.
*/
city?: pulumi.Input<string>;
/**
* Continent of the location.
*/
continent?: pulumi.Input<string>;
/**
* Country of the location.
*/
country?: pulumi.Input<string>;
/**
* Latitude of the location.
*/
lat?: pulumi.Input<number>;
/**
* Longitude of the location.
*/
lon?: pulumi.Input<number>;
/**
* State of the location.
*/
state?: pulumi.Input<string>;
}
export interface DomainRouteCanary {
/**
* The port to send canary traffic to. If not provided, the first configured port on the workload is used.
*/
port?: pulumi.Input<number>;
/**
* The percentage of traffic to send to this canary workload. A weight of 0 disables the canary so it can be toggled on and off without removing it.
*/
weight: pulumi.Input<number>;
/**
* The canary workload to route a weighted percentage of traffic to.
*/
workloadLink: pulumi.Input<string>;
}
export interface DomainRouteHeaders {
/**
* Manipulates HTTP headers.
*/
request?: pulumi.Input<inputs.DomainRouteHeadersRequest>;
}
export interface DomainRouteHeadersRequest {
/**
* Sets or overrides headers to all http requests for this route.
*/
set?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
}
export interface DomainRouteMirror {
/**
* The percentage of traffic to mirror to the specified workload.
*/
percent: pulumi.Input<number>;
/**
* The port on the mirrored workload to send traffic to. If not provided, traffic will be mirrored to the first discovered port on the mirrored workload.
*/
port?: pulumi.Input<number>;
/**
* The workload to mirror traffic to.
*/
workloadLink: pulumi.Input<string>;
}
export interface DomainSpec {
/**
* Allows domain to accept wildcards. The associated GVC must have dedicated load balancing enabled.
*/
acceptAllHosts?: pulumi.Input<boolean>;
/**
* Accept all subdomains will accept any host that is a sub domain of the domain so *.$DOMAIN
*/
acceptAllSubdomains?: pulumi.Input<boolean>;
/**
* Defines the method used to prove domain ownership for certificate issuance.
*/
certChallengeType?: pulumi.Input<string>;
/**
* In `cname` dnsMode, Control Plane will configure workloads to accept traffic for the domain but will not manage DNS records for the domain. End users must configure CNAME records in their own DNS pointed to the canonical workload endpoint. Currently `cname` dnsMode requires that a TLS server certificate be configured when subdomain based routing is used. In `ns` dnsMode, Control Plane will manage the subdomains and create all necessary DNS records. End users configure NS records to forward DNS requests to the Control Plane managed DNS servers. Valid values: `cname`, `ns`. Default: `cname`.
*/
dnsMode?: pulumi.Input<string>;
/**
* This value is set to a target GVC (using a full link) for use by subdomain based routing. Each workload in the GVC will receive a subdomain in the form ${workload.name}.${domain.name}. **Do not include if path based routing is used.**
*/
gvcLink?: pulumi.Input<string>;
/**
* Domain port specifications.
*/
ports?: pulumi.Input<pulumi.Input<inputs.DomainSpecPort>[]>;
/**
* Creates a unique subdomain for each replica of a stateful workload, enabling direct access to individual instances.
*/
workloadLink?: pulumi.Input<string>;
}
export interface DomainSpecPort {
/**
* A security feature implemented by web browsers to allow resources on a web page to be requested from another domain outside the domain from which the resource originated.
*/
cors?: pulumi.Input<inputs.DomainSpecPortCors>;
/**
* Sets or overrides headers to all http requests for this route.
*/
number?: pulumi.Input<number>;
/**
* Allowed protocol. Valid values: `http`, `http2`, `tcp`. Default: `http2`.
*/
protocol?: pulumi.Input<string>;
/**
* Inline routes for this port. Can coexist with separate cpln.DomainRoute resources on the same domain and port.
*/
routes?: pulumi.Input<pulumi.Input<inputs.DomainSpecPortRoute>[]>;
/**
* Used for TLS connections for this Domain. End users are responsible for certificate updates.
*/
tls?: pulumi.Input<inputs.DomainSpecPortTls>;
}
export interface DomainSpecPortCors {
/**
* Determines whether the client-side code (typically running in a web browser) is allowed to include credentials (such as cookies, HTTP authentication, or client-side SSL certificates) in cross-origin requests.
*/
allowCredentials?: pulumi.Input<boolean>;
/**
* Specifies the custom HTTP headers that are allowed in a cross-origin request to a specific resource.
*/
allowHeaders?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Specifies the HTTP methods (such as `GET`, `POST`, `PUT`, `DELETE`, etc.) that are allowed for a cross-origin request to a specific resource.
*/
allowMethods?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Determines which origins are allowed to access a particular resource on a server from a web browser.
*/
allowOrigins?: pulumi.Input<pulumi.Input<inputs.DomainSpecPortCorsAllowOrigin>[]>;
/**
* The HTTP headers that a server allows to be exposed to the client in response to a cross-origin request. These headers provide additional information about the server's capabilities or requirements, aiding in proper handling of the request by the client's browser or application.
*/
exposeHeaders?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Maximum amount of time that a preflight request result can be cached by the client browser. Input is expected as a duration string (i.e, 24h, 20m, etc.).
*/
maxAge?: pulumi.Input<string>;
}
export interface DomainSpecPortCorsAllowOrigin {
/**
* Value of allowed origin.
*/
exact?: pulumi.Input<string>;
regex?: pulumi.Input<string>;
}
export interface DomainSpecPortRoute {
/**
* Routes a weighted percentage of traffic to one or more additional workloads. The combined weight of all canaries on a route must not exceed 100; the remaining weight goes to the primary workload. Only supported on http and http2 ports.
*/
canaries?: pulumi.Input<pulumi.Input<inputs.DomainSpecPortRouteCanary>[]>;
/**
* Modify the headers for all http requests for this route.
*/
headers?: pulumi.Input<inputs.DomainSpecPortRouteHeaders>;
/**
* This option allows forwarding traffic for different host headers to different workloads.
*/
hostPrefix?: pulumi.Input<string>;
/**
* A regex to match the host header.
*/
hostRegex?: pulumi.Input<string>;
/**
* Mirror the traffic to the specified workload(s). Only works for workloads running in the same location as the primary workload(s).
*/
mirrors?: pulumi.Input<pulumi.Input<inputs.DomainSpecPortRouteMirror>[]>;
/**
* For the linked workload, the port to route traffic to.
*/
port?: pulumi.Input<number>;
/**
* The path will match any unmatched path prefixes for the subdomain.
*/
prefix?: pulumi.Input<string>;
/**
* Used to match URI paths. Uses the google re2 regex syntax.
*/
regex?: pulumi.Input<string>;
/**
* A path prefix can be configured to be replaced when forwarding the request to the Workload.
*/
replacePrefix?: pulumi.Input<string>;
/**
* The replica number of a stateful workload to route to. If not provided, traffic will be routed to all replicas.
*/
replica?: pulumi.Input<number>;
/**
* The link of the workload to map the prefix to.
*/
workloadLink: pulumi.Input<string>;
}
export interface DomainSpecPortRouteCanary {
/**
* The port to send canary traffic to. If not provided, the first configured port on the workload is used.
*/
port?: pulumi.Input<number>;
/**
* The percentage of traffic to send to this canary workload. A weight of 0 disables the canary so it can be toggled on and off without removing it.
*/
weight: pulumi.Input<number>;
/**
* The canary workload to route a weighted percentage of traffic to.
*/
workloadLink: pulumi.Input<string>;
}
export interface DomainSpecPortRouteHeaders {
/**
* Manipulates HTTP headers.
*/
request?: pulumi.Input<inputs.DomainSpecPortRouteHeadersRequest>;
}
export interface DomainSpecPortRouteHeadersRequest {
/**
* Sets or overrides headers to all http requests for this route.
*/
set?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
}
export interface DomainSpecPortRouteMirror {
/**
* The percentage of traffic to mirror to the specified workload.
*/
percent: pulumi.Input<number>;
/**
* The port on the mirrored workload to send traffic to. If not provided, traffic will be mirrored to the first discovered port on the mirrored workload.
*/
port?: pulumi.Input<number>;
/**
* The workload to mirror traffic to.
*/
workloadLink: pulumi.Input<string>;
}
export interface DomainSpecPortTls {
/**
* Allowed cipher suites. Refer to the [Domain Reference](https://docs.controlplane.com/reference/domain#cipher-suites) for details.
*/
cipherSuites?: pulumi.Input<pulumi.Input<string>[]>;
/**
* The certificate authority PEM, stored as a TLS Secret, used to verify the authority of the client certificate. The only verification performed checks that the CN of the PEM matches the Domain (i.e., CN=*.DOMAIN).
*/
clientCertificate?: pulumi.Input<inputs.DomainSpecPortTlsClientCertificate>;
/**
* Minimum TLS version to accept. Minimum is `1.0`. Default: `1.2`.
*/
minProtocolVersion?: pulumi.Input<string>;
/**
* Configure an optional custom server certificate for the domain. When the port number is 443 and this is not supplied, a certificate is provisioned automatically.
*/
serverCertificate?: pulumi.Input<inputs.DomainSpecPortTlsServerCertificate>;
}
export interface DomainSpecPortTlsClientCertificate {
/**
* The secret will include a client certificate authority cert in PEM format used to verify requests which include client certificates. The key subject must match the domain and the key usage properties must be configured for client certificate authorization. The secret type must be keypair.
*/
secretLink?: pulumi.Input<string>;
}
export interface DomainSpecPortTlsServerCertificate {
/**
* When provided, this is used as the server certificate authority. The secret type must be keypair and the content must be PEM encoded.
*/
secretLink?: pulumi.Input<string>;
}
export interface DomainStatus {
/**
* List of required DNS record entries.
*/
dnsConfigs?: pulumi.Input<pulumi.Input<inputs.DomainStatusDnsConfig>[]>;
/**
* List of configured domain endpoints.
*/
endpoints?: pulumi.Input<pulumi.Input<inputs.DomainStatusEndpoint>[]>;
fingerprint?: pulumi.Input<string>;
/**
* Contains the cloud provider name, region, and certificate status.
*/
locations?: pulumi.Input<pulumi.Input<inputs.DomainStatusLocation>[]>;
/**
* Status of Domain. Possible values: `initializing`, `ready`, `pendingDnsConfig`, `pendingCertificate`, `usedByGvc`.
*/
status?: pulumi.Input<string>;
/**
* Warning message.
*/
warning?: pulumi.Input<string>;
}
export interface DomainStatusDnsConfig {
/**
* The host in DNS terminology refers to the domain or subdomain that the DNS record is associated with. It's essentially the name that is being queried or managed. For example, in a DNS record for `www.example.com`, `www` is a host in the domain `example.com`.
*/
host?: pulumi.Input<string>;
/**
* Time to live (TTL) is a value that signifies how long (in seconds) a DNS record should be cached by a resolver or a browser before a new request should be sent to refresh the data. Lower TTL values mean records are updated more frequently, which is beneficial for dynamic DNS configurations or during DNS migrations. Higher TTL values reduce the load on DNS servers and improve the speed of name resolution for end users by relying on cached data.
*/
ttl?: pulumi.Input<number>;
/**
* The DNS record type specifies the type of data the DNS record contains. Valid values: `CNAME`, `NS`, `TXT`.
*/
type?: pulumi.Input<string>;
/**
* The value of a DNS record contains the data the record is meant to convey, based on the type of the record.
*/
value?: pulumi.Input<string>;
}
export interface DomainStatusEndpoint {
/**
* URL of endpoint.
*/
url?: pulumi.Input<string>;
/**
* Full link to associated workload.
*/
workloadLink?: pulumi.Input<string>;
}
export interface DomainStatusLocation {
/**
* The current validity or status of the SSL/TLS certificate.
*/
certificateStatus?: pulumi.Input<string>;
/**
* The name of the location.
*/
name?: pulumi.Input<string>;
}
export interface GetGvcControlplaneTracing {
/**
* Key-value map of custom tags.
*/
customTags?: {
[key: string]: string;
};
/**
* Determines what percentage of requests should be traced.
*/
sampling: number;
}
export interface GetGvcControlplaneTracingArgs {
/**
* Key-value map of custom tags.
*/
customTags?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
/**
* Determines what percentage of requests should be traced.
*/
sampling: pulumi.Input<number>;
}
export interface GetGvcKeda {
/**
* Enable KEDA for this GVC. KEDA is a Kubernetes-based event-driven autoscaler that allows you to scale workloads based on external events. When enabled, a keda operator will be deployed in the GVC and workloads in the GVC can use KEDA to scale based on external metrics.
*/
enabled?: boolean;
/**
* A link to an Identity resource that will be used for KEDA. This will allow the keda operator to access cloud and network resources.
*/
identityLink?: string;
/**
* A list of secrets to be used as TriggerAuthentication objects. The TriggerAuthentication object will be named after the secret and can be used by triggers on workloads in this GVC.
*/
secrets?: string[];
}
export interface GetGvcKedaArgs {
/**
* Enable KEDA for this GVC. KEDA is a Kubernetes-based event-driven autoscaler that allows you to scale workloads based on external events. When enabled, a keda operator will be deployed in the GVC and workloads in the GVC can use KEDA to scale based on external metrics.
*/
enabled?: pulumi.Input<boolean>;
/**
* A link to an Identity resource that will be used for KEDA. This will allow the keda operator to access cloud and network resources.
*/
identityLink?: pulumi.Input<string>;
/**
* A list of secrets to be used as TriggerAuthentication objects. The TriggerAuthentication object will be named after the secret and can be used by triggers on workloads in this GVC.
*/
secrets?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface GetGvcLightstepTracing {
/**
* Full link to referenced Opaque Secret.
*/
credentials?: string;
/**
* Key-value map of custom tags.
*/
customTags?: {
[key: string]: string;
};
/**
* Tracing Endpoint Workload. Either the canonical endpoint or internal endpoint.
*/
endpoint: string;
/**
* Determines what percentage of requests should be traced.
*/
sampling: number;
}
export interface GetGvcLightstepTracingArgs {
/**
* Full link to referenced Opaque Secret.
*/
credentials?: pulumi.Input<string>;
/**
* Key-value map of custom tags.
*/
customTags?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
/**
* Tracing Endpoint Workload. Either the canonical endpoint or internal endpoint.
*/
endpoint: pulumi.Input<string>;
/**
* Determines what percentage of requests should be traced.
*/
sampling: pulumi.Input<number>;
}
export interface GetGvcLoadBalancer {
/**
* Creates a dedicated load balancer in each location and enables additional Domain features: custom ports, protocols and wildcard hostnames. Charges apply for each location.
*/
dedicated?: boolean;
/**
* The link or the name of the IP Set that will be used for this load balancer.
*/
ipset?: string;
multiZone?: inputs.GetGvcLoadBalancerMultiZone;
/**
* Specify the url to be redirected to for different http status codes.
*/
redirect?: inputs.GetGvcLoadBalancerRedirect;
/**
* Controls the address used for request logging and for setting the X-Envoy-External-Address header. If set to 1, then the last address in an existing X-Forwarded-For header will be used in place of the source client IP address. If set to 2, then the second to last address in an existing X-Forwarded-For header will be used in place of the source client IP address. If the XFF header does not have at least two addresses or does not exist then the source client IP address will be used instead.
*/
trustedProxies?: number;
}
export interface GetGvcLoadBalancerArgs {
/**
* Creates a dedicated load balancer in each location and enables additional Domain features: custom ports, protocols and wildcard hostnames. Charges apply for each location.
*/
dedicated?: pulumi.Input<boolean>;
/**
* The link or the name of the IP Set that will be used for this load balancer.
*/
ipset?: pulumi.Input<string>;
multiZone?: pulumi.Input<inputs.GetGvcLoadBalancerMultiZoneArgs>;
/**
* Specify the url to be redirected to for different http status codes.
*/
redirect?: pulumi.Input<inputs.GetGvcLoadBalancerRedirectArgs>;
/**
* Controls the address used for request logging and for setting the X-Envoy-External-Address header. If set to 1, then the last address in an existing X-Forwarded-For header will be used in place of the source client IP address. If set to 2, then the second to last address in an existing X-Forwarded-For header will be used in place of the source client IP address. If the XFF header does not have at least two addresses or does not exist then the source client IP address will be used instead.
*/
trustedProxies?: pulumi.Input<number>;
}
export interface GetGvcLoadBalancerMultiZone {
enabled?: boolean;
}
export interface GetGvcLoadBalancerMultiZoneArgs {
enabled?: pulumi.Input<boolean>;
}
export interface GetGvcLoadBalancerRedirect {
/**
* Specify the redirect url for all status codes in a class.
*/
class?: inputs.GetGvcLoadBalancerRedirectClass;
}
export interface GetGvcLoadBalancerRedirectArgs {
/**
* Specify the redirect url for all status codes in a class.
*/
class?: pulumi.Input<inputs.GetGvcLoadBalancerRedirectClassArgs>;
}
export interface GetGvcLoadBalancerRedirectClass {
/**
* An optional url redirect for 401 responses. Supports envoy format strings to include request information. E.g. https://your-oauth-server/oauth2/authorize?return_to=%REQ(:path)%&client_id=your-client-id
*/
status401?: string;
/**
* Specify the redirect url for any 500 level status code.
*/
status5xx?: string;
}
export interface GetGvcLoadBalancerRedirectClassArgs {
/**
* An optional url redirect for 401 responses. Supports envoy format strings to include request information. E.g. https://your-oauth-server/oauth2/authorize?return_to=%REQ(:path)%&client_id=your-client-id
*/
status401?: pulumi.Input<string>;
/**
* Specify the redirect url for any 500 level status code.
*/
status5xx?: pulumi.Input<string>;
}
export interface GetGvcLocationOption {
/**
* Artificial latency offset in milliseconds added to measured latency. Positive values push traffic away from this location, negative values attract traffic. Default: `0`.
*/
latencyOffsetMs?: number;
/**
* Maximum acceptable latency in milliseconds. If measured latency exceeds this value, the location is treated as unavailable for DNS geo routing.
*/
latencyToleranceMs?: number;
/**
* Name of the location these options apply to.
*/
name?: string;
/**
* Routing tier for DNS geo routing. Lower value = higher priority. Locations with the same `routingTier` form a group; within a group, lowest latency wins. If all locations in the highest-priority group are unavailable, the next group is used.
*/
routingTier?: number;
}
export interface GetGvcLocationOptionArgs {
/**
* Artificial latency offset in milliseconds added to measured latency. Positive values push traffic away from this location, negative values attract traffic. Default: `0`.
*/
latencyOffsetMs?: pulumi.Input<number>;
/**
* Maximum acceptable latency in milliseconds. If measured latency exceeds this value, the location is treated as unavailable for DNS geo routing.
*/
latencyToleranceMs?: pulumi.Input<number>;
/**
* Name of the location these options apply to.
*/
name?: pulumi.Input<string>;
/**
* Routing tier for DNS geo routing. Lower value = higher priority. Locations with the same `routingTier` form a group; within a group, lowest latency wins. If all locations in the highest-priority group are unavailable, the next group is used.
*/
routingTier?: pulumi.Input<number>;
}
export interface GetGvcLocationQuery {
/**
* Type of fetch. Specify either: `links` or `items`. Default: `items`.
*/
fetch?: string;
specs?: inputs.GetGvcLocationQuerySpec[];
}
export interface GetGvcLocationQueryArgs {
/**
* Type of fetch. Specify either: `links` or `items`. Default: `items`.
*/
fetch?: pulumi.Input<string>;
specs?: pulumi.Input<pulumi.Input<inputs.GetGvcLocationQuerySpecArgs>[]>;
}
export interface GetGvcLocationQuerySpec {
/**
* Type of match. Available values: `all`, `any`, `none`. Default: `all`.
*/
match?: string;
/**
* Terms can only contain one of the following attributes: `property`, `rel`, `tag`.
*/
terms?: inputs.GetGvcLocationQuerySpecTerm[];
}
export interface GetGvcLocationQuerySpecArgs {
/**
* Type of match. Available values: `all`, `any`, `none`. Default: `all`.
*/
match?: pulumi.Input<string>;
/**
* Terms can only contain one of the following attributes: `property`, `rel`, `tag`.
*/
terms?: pulumi.Input<pulumi.Input<inputs.GetGvcLocationQuerySpecTermArgs>[]>;
}
export interface GetGvcLocationQuerySpecTerm {
/**
* Type of query operation. Available values: `=`, `>`, `>=`, `<`, `<=`, `!=`, `~`, `=~`, `exists`, `!exists`, `contains`. Default: `=`.
*/
op?: string;
/**
* Property to use for query evaluation.
*/
property?: string;
/**
* Relation to use for query evaluation.
*/
rel?: string;
/**
* Tag key to use for query evaluation.
*/
tag?: string;
/**
* Testing value for query evaluation.
*/
value?: string;
}
export interface GetGvcLocationQuerySpecTermArgs {
/**
* Type of query operation. Available values: `=`, `>`, `>=`, `<`, `<=`, `!=`, `~`, `=~`, `exists`, `!exists`, `contains`. Default: `=`.
*/
op?: pulumi.Input<string>;
/**
* Property to use for query evaluation.
*/
property?: pulumi.Input<string>;
/**
* Relation to use for query evaluation.
*/
rel?: pulumi.Input<string>;
/**
* Tag key to use for query evaluation.
*/
tag?: pulumi.Input<string>;
/**
* Testing value for query evaluation.
*/
value?: pulumi.Input<string>;
}
export interface GetGvcOtelTracing {
/**
* Key-value map of custom tags.
*/
customTags?: {
[key: string]: string;
};
/**
* Tracing Endpoint Workload. Either the canonical endpoint or internal endpoint.
*/
endpoint: string;
/**
* Determines what percentage of requests should be traced.
*/
sampling: number;
}
export interface GetGvcOtelTracingArgs {
/**
* Key-value map of custom tags.
*/
customTags?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
/**
* Tracing Endpoint Workload. Either the canonical endpoint or internal endpoint.
*/
endpoint: pulumi.Input<string>;
/**
* Determines what percentage of requests should be traced.
*/
sampling: pulumi.Input<number>;
}
export interface GetGvcSidecar {
envoy: string;
}
export interface GetGvcSidecarArgs {
envoy: pulumi.Input<string>;
}
export interface GetHelmTemplatePostrender {
/**
* Arguments to the post-renderer.
*/
args?: string[];
/**
* The path to an executable to be used for post rendering.
*/
binaryPath: string;
}
export interface GetHelmTemplatePostrenderArgs {
/**
* Arguments to the post-renderer.
*/
args?: pulumi.Input<pulumi.Input<string>[]>;
/**
* The path to an executable to be used for post rendering.
*/
binaryPath: pulumi.Input<string>;
}
export interface GetImagesQuery {
/**
* Type of fetch. Specify either: `links` or `items`. Default: `items`.
*/
fetch?: string;
/**
* The specification of the query.
*/
spec?: inputs.GetImagesQuerySpec;
}
export interface GetImagesQueryArgs {
/**
* Type of fetch. Specify either: `links` or `items`. Default: `items`.
*/
fetch?: pulumi.Input<string>;
/**
* The specification of the query.
*/
spec?: pulumi.Input<inputs.GetImagesQuerySpecArgs>;
}
export interface GetImagesQuerySpec {
/**
* Type of match. Available values: `all`, `any`, `none`. Default: `all`.
*/
match?: string;
/**
* Terms can only contain one of the following attributes: `property`, `rel`, `tag`.
*/
terms?: inputs.GetImagesQuerySpecTerm[];
}
export interface GetImagesQuerySpecArgs {
/**
* Type of match. Available values: `all`, `any`, `none`. Default: `all`.
*/
match?: pulumi.Input<string>;
/**
* Terms can only contain one of the following attributes: `property`, `rel`, `tag`.
*/
terms?: pulumi.Input<pulumi.Input<inputs.GetImagesQuerySpecTermArgs>[]>;
}
export interface GetImagesQuerySpecTerm {
/**
* Type of query operation. Available values: `=`, `>`, `>=`, `<`, `<=`, `!=`, `exists`, `!exists`. Default: `=`.
*/
op?: string;
/**
* Property to use for query evaluation.
*/
property?: string;
/**
* Relation to use for query evaluation.
*/
rel?: string;
/**
* Tag key to use for query evaluation.
*/
tag?: string;
/**
* Testing value for query evaluation.
*/
value?: string;
}
export interface GetImagesQuerySpecTermArgs {
/**
* Type of query operation. Available values: `=`, `>`, `>=`, `<`, `<=`, `!=`, `exists`, `!exists`. Default: `=`.
*/
op?: pulumi.Input<string>;
/**
* Property to use for query evaluation.
*/
property?: pulumi.Input<string>;
/**
* Relation to use for query evaluation.
*/
rel?: pulumi.Input<string>;
/**
* Tag key to use for query evaluation.
*/
tag?: pulumi.Input<string>;
/**
* Testing value for query evaluation.
*/
value?: pulumi.Input<string>;
}
export interface GetOrgAuthConfig {
/**
* List of domains which will auto-provision users when authenticating using SAML.
*/
domainAutoMembers?: string[];
/**
* Enforce SAML only authentication.
*/
samlOnly?: boolean;
}
export interface GetOrgAuthConfigArgs {
/**
* List of domains which will auto-provision users when authenticating using SAML.
*/
domainAutoMembers?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Enforce SAML only authentication.
*/
samlOnly?: pulumi.Input<boolean>;
}
export interface GetOrgObservability {
/**
* These emails are configured as alert recipients in Grafana when the 'grafana-default-email' contact delivery type is 'Email'.
*/
defaultAlertEmails?: string[];
/**
* Log retention days. Min: 0. Max: 3650. Default: 30
*/
logsRetentionDays?: number;
/**
* Metrics retention days. Min: 0. Max: 3650. Default: 30
*/
metricsRetentionDays?: number;
/**
* Traces retention days. Min: 0. Max: 3650. Default: 30
*/
tracesRetentionDays?: number;
}
export interface GetOrgObservabilityArgs {
/**
* These emails are configured as alert recipients in Grafana when the 'grafana-default-email' contact delivery type is 'Email'.
*/
defaultAlertEmails?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Log retention days. Min: 0. Max: 3650. Default: 30
*/
logsRetentionDays?: pulumi.Input<number>;
/**
* Metrics retention days. Min: 0. Max: 3650. Default: 30
*/
metricsRetentionDays?: pulumi.Input<number>;
/**
* Traces retention days. Min: 0. Max: 3650. Default: 30
*/
tracesRetentionDays?: pulumi.Input<number>;
}
export interface GetOrgSecurity {
threatDetection?: inputs.GetOrgSecurityThreatDetection;
}
export interface GetOrgSecurityArgs {
threatDetection?: pulumi.Input<inputs.GetOrgSecurityThreatDetectionArgs>;
}
export interface GetOrgSecurityThreatDetection {
/**
* Indicates whether threat detection should be forwarded or not.
*/
enabled?: boolean;
/**
* Any threats with this severity and more severe will be sent. Others will be ignored. Valid values: `warning`, `error`, or `critical`.
*/
minimumSeverity?: string;
/**
* Configuration for syslog forwarding.
*/
syslog?: inputs.GetOrgSecurityThreatDetectionSyslog;
}
export interface GetOrgSecurityThreatDetectionArgs {
/**
* Indicates whether threat detection should be forwarded or not.
*/
enabled?: pulumi.Input<boolean>;
/**
* Any threats with this severity and more severe will be sent. Others will be ignored. Valid values: `warning`, `error`, or `critical`.
*/
minimumSeverity?: pulumi.Input<string>;
/**
* Configuration for syslog forwarding.
*/
syslog?: pulumi.Input<inputs.GetOrgSecurityThreatDetectionSyslogArgs>;
}
export interface GetOrgSecurityThreatDetectionSyslog {
/**
* The hostname to send syslog messages to.
*/
host?: string;
/**
* The port to send syslog messages to. Min: 1. Max: 100000.
*/
port?: number;
/**
* The transport-layer protocol to send the syslog messages over. If TCP is chosen, messages will be sent with TLS. Default: `tcp`.
*/
transport?: string;
}
export interface GetOrgSecurityThreatDetectionSyslogArgs {
/**
* The hostname to send syslog messages to.
*/
host?: pulumi.Input<string>;
/**
* The port to send syslog messages to. Min: 1. Max: 100000.
*/
port?: pulumi.Input<number>;
/**
* The transport-layer protocol to send the syslog messages over. If TCP is chosen, messages will be sent with TLS. Default: `tcp`.
*/
transport?: pulumi.Input<string>;
}
export interface GetSecretAw {
/**
* Access Key provided by AWS.
*/
accessKey?: string;
/**
* AWS IAM Role External ID.
*/
externalId?: string;
/**
* Role ARN provided by AWS.
*/
roleArn?: string;
/**
* Secret Key provided by AWS.
*/
secretKey?: string;
}
export interface GetSecretAwArgs {
/**
* Access Key provided by AWS.
*/
accessKey?: pulumi.Input<string>;
/**
* AWS IAM Role External ID.
*/
externalId?: pulumi.Input<string>;
/**
* Role ARN provided by AWS.
*/
roleArn?: pulumi.Input<string>;
/**
* Secret Key provided by AWS.
*/
secretKey?: pulumi.Input<string>;
}
export interface GetSecretAzureConnector {
/**
* Code/Key to authenticate to deployment URL.
*/
code?: string;
/**
* Deployment URL.
*/
url?: string;
}
export interface GetSecretAzureConnectorArgs {
/**
* Code/Key to authenticate to deployment URL.
*/
code?: pulumi.Input<string>;
/**
* Deployment URL.
*/
url?: pulumi.Input<string>;
}
export interface GetSecretEcr {
/**
* Access Key provided by AWS.
*/
accessKey?: string;
/**
* AWS IAM Role External ID. Used when setting up cross-account access to your ECR repositories.
*/
externalId?: string;
/**
* List of ECR repositories.
*/
repos?: string[];
/**
* Role ARN provided by AWS.
*/
roleArn?: string;
/**
* Secret Key provided by AWS.
*/
secretKey?: string;
}
export interface GetSecretEcrArgs {
/**
* Access Key provided by AWS.
*/
accessKey?: pulumi.Input<string>;
/**
* AWS IAM Role External ID. Used when setting up cross-account access to your ECR repositories.
*/
externalId?: pulumi.Input<string>;
/**
* List of ECR repositories.
*/
repos?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Role ARN provided by AWS.
*/
roleArn?: pulumi.Input<string>;
/**
* Secret Key provided by AWS.
*/
secretKey?: pulumi.Input<string>;
}
export interface GetSecretKeypair {
/**
* Passphrase for private key.
*/
passphrase?: string;
/**
* Public Key.
*/
publicKey?: string;
/**
* Secret/Private Key.
*/
secretKey?: string;
}
export interface GetSecretKeypairArgs {
/**
* Passphrase for private key.
*/
passphrase?: pulumi.Input<string>;
/**
* Public Key.
*/
publicKey?: pulumi.Input<string>;
/**
* Secret/Private Key.
*/
secretKey?: pulumi.Input<string>;
}
export interface GetSecretNatsAccount {
/**
* Account ID.
*/
accountId?: string;
/**
* Private Key.
*/
privateKey?: string;
}
export interface GetSecretNatsAccountArgs {
/**
* Account ID.
*/
accountId?: pulumi.Input<string>;
/**
* Private Key.
*/
privateKey?: pulumi.Input<string>;
}
export interface GetSecretOpaque {
/**
* Available encodings: `plain`, `base64`. Default: `plain`.
*/
encoding?: string;
/**
* Plain text or base64 encoded string. Use `encoding` attribute to specify encoding.
*/
payload?: string;
}
export interface GetSecretOpaqueArgs {
/**
* Available encodings: `plain`, `base64`. Default: `plain`.
*/
encoding?: pulumi.Input<string>;
/**
* Plain text or base64 encoded string. Use `encoding` attribute to specify encoding.
*/
payload?: pulumi.Input<string>;
}
export interface GetSecretTl {
/**
* Public Certificate.
*/
cert?: string;
/**
* Chain Certificate.
*/
chain?: string;
/**
* Private Certificate.
*/
key?: string;
}
export interface GetSecretTlArgs {
/**
* Public Certificate.
*/
cert?: pulumi.Input<string>;
/**
* Chain Certificate.
*/
chain?: pulumi.Input<string>;
/**
* Private Certificate.
*/
key?: pulumi.Input<string>;
}
export interface GetSecretUserpass {
/**
* Available encodings: `plain`, `base64`. Default: `plain`.
*/
encoding?: string;
/**
* Password.
*/
password?: string;
/**
* Username.
*/
username?: string;
}
export interface GetSecretUserpassArgs {
/**
* Available encodings: `plain`, `base64`. Default: `plain`.
*/
encoding?: pulumi.Input<string>;
/**
* Password.
*/
password?: pulumi.Input<string>;
/**
* Username.
*/
username?: pulumi.Input<string>;
}
export interface GetWorkloadContainer {
/**
* Command line arguments passed to the container at runtime. Replaces the CMD arguments of the running container. It is an ordered list.
*/
args?: string[];
/**
* Override the entry point.
*/
command?: string;
/**
* Reserved CPU of the workload when capacityAI is disabled. Maximum CPU when CapacityAI is enabled. Default: "50m".
*/
cpu?: string;
/**
* Name-Value list of environment variables.
*/
env?: {
[key: string]: string;
};
gpuCustoms?: inputs.GetWorkloadContainerGpuCustom[];
/**
* GPUs manufactured by NVIDIA, which are specialized hardware accelerators used to offload and accelerate computationally intensive tasks within the workload.
*/
gpuNvidias?: inputs.GetWorkloadContainerGpuNvidia[];
/**
* The full image and tag path.
*/
image?: string;
/**
* Enables inheritance of GVC environment variables. A variable in spec.env will override a GVC variable with the same name.
*/
inheritEnv?: boolean;
/**
* Lifecycle [Reference Page](https://docs.controlplane.com/reference/workload#lifecycle).
*/
lifecycles?: inputs.GetWorkloadContainerLifecycle[];
/**
* Liveness Probe
*/
livenessProbes?: inputs.GetWorkloadContainerLivenessProbe[];
/**
* Reserved memory of the workload when capacityAI is disabled. Maximum memory when CapacityAI is enabled. Default: "128Mi".
*/
memory?: string;
/**
* [Reference Page](https://docs.controlplane.com/reference/workload#metrics).
*/
metrics?: inputs.GetWorkloadContainerMetric[];
/**
* Minimum CPU when capacity AI is enabled.
*/
minCpu?: string;
/**
* Minimum memory when capacity AI is enabled.
*/
minMemory?: string;
/**
* Name of the container.
*/
name?: string;
/**
* The port the container exposes. Only one container is allowed to specify a port. Min: `80`. Max: `65535`. Used by `serverless` Workload type. **DEPRECATED - Use `ports`.**
*
* @deprecated The 'port' attribute will be deprecated in the next major version. Use the 'ports' attribute instead.
*/
port?: number;
/**
* Communication endpoints used by the workload to send and receive network traffic.
*/
ports?: inputs.GetWorkloadContainerPort[];
/**
* Readiness Probe
*/
readinessProbes?: inputs.GetWorkloadContainerReadinessProbe[];
/**
* Mount Object Store (S3, GCS, AzureBlob) buckets as file system.
*/
volumes?: inputs.GetWorkloadContainerVolume[];
/**
* Override the working directory. Must be an absolute path.
*/
workingDirectory?: string;
}
export interface GetWorkloadContainerArgs {
/**
* Command line arguments passed to the container at runtime. Replaces the CMD arguments of the running container. It is an ordered list.
*/
args?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Override the entry point.
*/
command?: pulumi.Input<string>;
/**
* Reserved CPU of the workload when capacityAI is disabled. Maximum CPU when CapacityAI is enabled. Default: "50m".
*/
cpu?: pulumi.Input<string>;
/**
* Name-Value list of environment variables.
*/
env?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
gpuCustoms?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerGpuCustomArgs>[]>;
/**
* GPUs manufactured by NVIDIA, which are specialized hardware accelerators used to offload and accelerate computationally intensive tasks within the workload.
*/
gpuNvidias?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerGpuNvidiaArgs>[]>;
/**
* The full image and tag path.
*/
image?: pulumi.Input<string>;
/**
* Enables inheritance of GVC environment variables. A variable in spec.env will override a GVC variable with the same name.
*/
inheritEnv?: pulumi.Input<boolean>;
/**
* Lifecycle [Reference Page](https://docs.controlplane.com/reference/workload#lifecycle).
*/
lifecycles?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLifecycleArgs>[]>;
/**
* Liveness Probe
*/
livenessProbes?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLivenessProbeArgs>[]>;
/**
* Reserved memory of the workload when capacityAI is disabled. Maximum memory when CapacityAI is enabled. Default: "128Mi".
*/
memory?: pulumi.Input<string>;
/**
* [Reference Page](https://docs.controlplane.com/reference/workload#metrics).
*/
metrics?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerMetricArgs>[]>;
/**
* Minimum CPU when capacity AI is enabled.
*/
minCpu?: pulumi.Input<string>;
/**
* Minimum memory when capacity AI is enabled.
*/
minMemory?: pulumi.Input<string>;
/**
* Name of the container.
*/
name?: pulumi.Input<string>;
/**
* The port the container exposes. Only one container is allowed to specify a port. Min: `80`. Max: `65535`. Used by `serverless` Workload type. **DEPRECATED - Use `ports`.**
*
* @deprecated The 'port' attribute will be deprecated in the next major version. Use the 'ports' attribute instead.
*/
port?: pulumi.Input<number>;
/**
* Communication endpoints used by the workload to send and receive network traffic.
*/
ports?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerPortArgs>[]>;
/**
* Readiness Probe
*/
readinessProbes?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerReadinessProbeArgs>[]>;
/**
* Mount Object Store (S3, GCS, AzureBlob) buckets as file system.
*/
volumes?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerVolumeArgs>[]>;
/**
* Override the working directory. Must be an absolute path.
*/
workingDirectory?: pulumi.Input<string>;
}
export interface GetWorkloadContainerGpuCustom {
/**
* Number of GPUs.
*/
quantity?: number;
resource?: string;
runtimeClass?: string;
}
export interface GetWorkloadContainerGpuCustomArgs {
/**
* Number of GPUs.
*/
quantity?: pulumi.Input<number>;
resource?: pulumi.Input<string>;
runtimeClass?: pulumi.Input<string>;
}
export interface GetWorkloadContainerGpuNvidia {
/**
* GPU Model (i.e.: t4)
*/
model?: string;
/**
* Number of GPUs.
*/
quantity?: number;
}
export interface GetWorkloadContainerGpuNvidiaArgs {
/**
* GPU Model (i.e.: t4)
*/
model?: pulumi.Input<string>;
/**
* Number of GPUs.
*/
quantity?: pulumi.Input<number>;
}
export interface GetWorkloadContainerLifecycle {
postStarts?: inputs.GetWorkloadContainerLifecyclePostStart[];
preStops?: inputs.GetWorkloadContainerLifecyclePreStop[];
}
export interface GetWorkloadContainerLifecycleArgs {
postStarts?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLifecyclePostStartArgs>[]>;
preStops?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLifecyclePreStopArgs>[]>;
}
export interface GetWorkloadContainerLifecyclePostStart {
execs?: inputs.GetWorkloadContainerLifecyclePostStartExec[];
}
export interface GetWorkloadContainerLifecyclePostStartArgs {
execs?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLifecyclePostStartExecArgs>[]>;
}
export interface GetWorkloadContainerLifecyclePostStartExec {
/**
* Command and arguments executed immediately after the container is created.
*/
commands?: string[];
}
export interface GetWorkloadContainerLifecyclePostStartExecArgs {
/**
* Command and arguments executed immediately after the container is created.
*/
commands?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface GetWorkloadContainerLifecyclePreStop {
execs?: inputs.GetWorkloadContainerLifecyclePreStopExec[];
}
export interface GetWorkloadContainerLifecyclePreStopArgs {
execs?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLifecyclePreStopExecArgs>[]>;
}
export interface GetWorkloadContainerLifecyclePreStopExec {
/**
* Command and arguments executed immediately before the container is stopped.
*/
commands?: string[];
}
export interface GetWorkloadContainerLifecyclePreStopExecArgs {
/**
* Command and arguments executed immediately before the container is stopped.
*/
commands?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface GetWorkloadContainerLivenessProbe {
execs?: inputs.GetWorkloadContainerLivenessProbeExec[];
failureThreshold?: number;
grpcs?: inputs.GetWorkloadContainerLivenessProbeGrpc[];
httpGets?: inputs.GetWorkloadContainerLivenessProbeHttpGet[];
initialDelaySeconds?: number;
periodSeconds?: number;
successThreshold?: number;
tcpSockets?: inputs.GetWorkloadContainerLivenessProbeTcpSocket[];
timeoutSeconds?: number;
}
export interface GetWorkloadContainerLivenessProbeArgs {
execs?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLivenessProbeExecArgs>[]>;
failureThreshold?: pulumi.Input<number>;
grpcs?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLivenessProbeGrpcArgs>[]>;
httpGets?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLivenessProbeHttpGetArgs>[]>;
initialDelaySeconds?: pulumi.Input<number>;
periodSeconds?: pulumi.Input<number>;
successThreshold?: pulumi.Input<number>;
tcpSockets?: pulumi.Input<pulumi.Input<inputs.GetWorkloadContainerLivenessProbeTcpSocketArgs>[]>;
timeoutSeconds?: pulumi.Input<number>;
}
export interface GetWorkloadContainerLivenessProbeExec {
commands?: string[];
}
export interface GetWorkloadContainerLivenessProbeExecArgs {
commands?: pulumi.Input<pulumi.Input<string>[]>;
}
export interface GetWorkloadContainerLivenessProbeGrpc {
port?: number;
}
export interface GetWorkloadContainerLivenessProbeGrpcArgs {
port?: pulumi.Input<number>;
}
export interface GetWorkloadContainerLivenessProbeHttpGet {
httpHeaders?: {
[key: string]: string;
};
path?: string;
port?: number;
scheme?: string;
}
export interface GetWorkloadContainerLivenessProbeHttpGetArgs {
httpHeaders?: pulumi.Input<{
[key: string]: pulumi.Input<string>;
}>;
path?: pulumi.Input<string>;
port?: pulumi.Input<number>;
scheme?: pulumi.Input<string>;
}
export interface GetWorkloadContainerLivenessProbeTcpSocket {
port?: number;
}
export interface GetWorkloadContainerLivenessProbeTcpSocketArgs {
port?: pulumi.Input<number>;
}
export interface GetWorkloadContainerMetric {
/**
* Drop metrics that match given patterns.
*/
dropMetrics?: string[];
/**
* Path from container emitting custom metrics.
*/
path?: string;
/**
* Port from container emitting custom metrics.
*/
port?: number;
}
export interface GetWorkloadContainerMetricArgs {
/**
* Drop metrics that match given patterns.
*/
dropMetrics?: pulumi.Input<pulumi.Input<string>[]>;
/**
* Path from container emitting custom metrics.
*/
path?: pulumi.Input<string>;
/**
* Port from container emitting custom metrics.
*/
port?: pulumi.Input<number>;
}
export interface GetWorkloadContainerPort {
/**
* Port to expose.
*/
number?: number;
/**
* Protocol. Choice of: `http`, `http2`, `tcp`, or `grpc`.
*/
protocol?: string;
}
export interface GetWorkloadContainerPortArgs {
/**
* Port to expose.
*/
number?: pulumi.Input<number>;
/**
* Protocol. Choice of: `http`, `http2`, `tcp`, or `grpc`.
*/
protocol?: pulumi.Input<string>;
}
export interface GetWorkloadContainerReadinessProbe {
execs?: inputs.GetWorkloadContainerReadinessProbeExec[];
failureThreshold?