import * as pulumi from "@pulumi/pulumi"; import * as inputs from "./types/input"; import * as outputs from "./types/output"; /** * The `scaleway.containers.Container` resource allows you to create and manage [Serverless Containers](https://www.scaleway.com/en/docs/serverless/containers/). * * Refer to the Serverless Containers [product documentation](https://www.scaleway.com/en/docs/serverless/containers/) and [API documentation](https://www.scaleway.com/en/developers/api/serverless-containers/) for more information. * * For more information on the limitations of Serverless Containers, refer to the [dedicated documentation](https://www.scaleway.com/en/docs/serverless-containers/reference-content/containers-limitations/). * * ## Example Usage * * ### Basic * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * * const main = new scaleway.containers.Namespace("main", {}); * const mainContainer = new scaleway.containers.Container("main", { * name: "my-container", * description: "This container has a description.", * tags: [ * "tag1", * "tag2", * ], * namespaceId: main.id, * image: "nginx:latest", * port: 80, * cpuLimit: 1024, * memoryLimitBytes: 2048000000, * minScale: 3, * maxScale: 5, * timeout: 600, * protocol: "http1", * commands: [ * "bash", * "-c", * "script.sh", * ], * args: [ * "some", * "args", * ], * environmentVariables: { * foo: "var", * }, * secretEnvironmentVariables: { * key: "secret", * }, * }); * ``` * * ### VPC integration * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * * const vpc = new scaleway.network.Vpc("vpc", {}); * const pn = new scaleway.network.PrivateNetwork("pn", {vpcId: vpc.id}); * const withPn = new scaleway.containers.Namespace("with_pn", {}); * const withPnContainer = new scaleway.containers.Container("with_pn", { * namespaceId: withPn.id, * name: "container-with-private-network", * image: "my-image:latest", * privateNetworkId: pn.id, * }); * ``` * * ### Redeploy the container everytime an update is made * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * import * as std from "@pulumi/std"; * * const main = scaleway.registry.getNamespace({ * name: "my-registry", * }); * const mainGetImage = main.then(main => scaleway.registry.getImage({ * namespaceId: main.id, * name: "nginx-1-29-2-alpine", * })); * const mainNamespace = new scaleway.containers.Namespace("main", {}); * const mainContainer = new scaleway.containers.Container("main", { * name: "my-container", * namespaceId: mainNamespace.id, * image: Promise.all([main, mainGetImage, mainGetImage]).then(([main, mainGetImage, mainGetImage1]) => `${main.endpoint}/${mainGetImage.name}:${mainGetImage1.tags?.[0]}`), * port: 80, * registrySha256: std.timestamp({}).result, * }); * ``` * * ### Redeploy the container when the image changes * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * * // When using mutable images (e.g., `latest` tag), you can use the `scaleway_registry_image_tag` data source along * // with the `registry_sha256` argument to trigger container redeployments when the image is updated. * // Ideally, you would create the namespace separately. * // For demonstration purposes, this example assumes the "nginx:latest" image is already available * // in the referenced namespace. * const main = new scaleway.registry.Namespace("main", {name: "some-unique-name"}); * const nginx = scaleway.registry.getImageOutput({ * namespaceId: main.id, * name: "nginx", * }); * const nginxLatest = nginx.apply(nginx => scaleway.registry.getImageTagOutput({ * imageId: nginx.id, * name: "latest", * })); * const mainNamespace = new scaleway.containers.Namespace("main", {name: "my-container-namespace"}); * const mainContainer = new scaleway.containers.Container("main", { * name: "nginx-latest", * namespaceId: mainNamespace.id, * image: pulumi.all([nginx, nginxLatest]).apply(([nginx, nginxLatest]) => `${mainScalewayRegistryNamespace.endpoint}/${nginx.name}:${nginxLatest.name}`), * port: 80, * registrySha256: nginxLatest.apply(nginxLatest => nginxLatest.digest), * }); * ``` * * ### Managing authentication of private containers with IAM * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * * // Project to be referenced in the IAM policy * const _default = scaleway.account.getProject({ * name: "default", * }); * // IAM resources * const containerAuth = new scaleway.iam.Application("container_auth", {name: "container-auth"}); * const accessPrivateContainers = new scaleway.iam.Policy("access_private_containers", { * applicationId: containerAuth.id, * rules: [{ * projectIds: [_default.then(_default => _default.id)], * permissionSetNames: ["ContainersPrivateAccess"], * }], * }); * const apiKey = new scaleway.iam.ApiKey("api_key", {applicationId: containerAuth.id}); * // Container resources * const _private = new scaleway.containers.Namespace("private", {name: "private-container-namespace"}); * const privateContainer = new scaleway.containers.Container("private", { * namespaceId: _private.id, * image: "rg.fr-par.scw.cloud/my-registry-ns/my-image:latest", * privacy: "private", * }); * export const secretKey = apiKey.secretKey; * export const containerEndpoint = privateContainer.domainName; * ``` * * ## Protocols * * The following protocols are supported: * * - `h2c`: HTTP/2 over TCP. * - `http1`: Hypertext Transfer Protocol. * * > **Important:** Refer to the official [Apache documentation](https://httpd.apache.org/docs/2.4/howto/http2.html) for more information. * * ## Privacy * * By default, creating a container will make it `public`, meaning that anybody knowing the endpoint can execute it. * * A container can be made `private` with the privacy parameter. * * Refer to the [technical information](https://www.scaleway.com/en/developers/api/serverless-containers/#protocol-9dd4c8) for more information on container authentication. * * ## Memory and vCPUs configuration * * The vCPU represents a portion of the underlying, physical CPU that is assigned to a particular virtual machine (VM). * * You can determine the computing resources to allocate to each container. * * The `memoryLimitBytes` must correspond with the right amount of vCPU. Refer to the table below to determine the right memory/vCPU combination. * * | Memory (in MB) | vCPU | * |----------------|------| * | 128 | 70m | * | 256 | 140m | * | 512 | 280m | * | 1024 | 560m | * | 2048 | 1120 | * | 3072 | 1680 | * | 4096 | 2240 | * * ~>**Important:** Make sure to select the right resources, as you will be billed based on compute usage over time and the number of Containers executions. * Refer to the [Serverless Containers pricing](https://www.scaleway.com/en/docs/faq/serverless-containers/#prices) for more information. * * ## Health check configuration * * Custom health checks can be configured on the container. * * It's possible to specify the HTTP path that the probe will listen to and the number of failures before considering the container as unhealthy. * During a deployment, if a newly created container fails to pass the health check, the deployment is aborted. * As a result, lowering this value can help to reduce the time it takes to detect a failed deployment. * The period between health checks is also configurable. * * Example: * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * * const main = new scaleway.containers.Container("main", { * name: "my-container", * namespaceId: mainScalewayContainerNamespace.id, * image: "nginx:latest", * livenessProbe: { * http: { * path: "/ping", * }, * failureThreshold: 40, * interval: "5s", * timeout: "1m", * }, * }); * ``` * * ~>**Important:** Another probe type can be set to TCP with the API, but currently the SDK has not been updated with this parameter. * This is why the only probe that can be used here is the HTTP probe. * Refer to the [Serverless Containers pricing](https://www.scaleway.com/en/docs/faq/serverless-containers/#prices) for more information. * * ## Scaling option configuration * * Scaling option block configuration allows you to choose which parameter will scale up/down containers. * Options are number of concurrent requests, CPU or memory usage. * * Example: * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as scaleway from "@pulumiverse/scaleway"; * * const main = new scaleway.containers.Container("main", { * name: "my-container-02", * namespaceId: mainScalewayContainerNamespace.id, * scalingOptions: [{ * concurrentRequestsThreshold: 15, * }], * }); * ``` * * ~>**Important**: A maximum of one of these parameters may be set. Also, when `cpuUsageThreshold` or `memoryUsageThreshold` are used, `minScale` can't be set to 0. * Refer to the [API Reference](https://www.scaleway.com/en/developers/api/serverless-containers/#path-containers-create-a-new-container) for more information. * * ## Import * * Containers can be imported using, `{region}/{id}`, as shown below: * * ```sh * $ pulumi import scaleway:index/container:Container main fr-par/11111111-1111-1111-1111-111111111111 * ``` * * @deprecated scaleway.index/container.Container has been deprecated in favor of scaleway.containers/container.Container */ export declare class Container extends pulumi.CustomResource { /** * Get an existing Container resource's state with the given name, ID, and optional extra * properties used to qualify the lookup. * * @param name The _unique_ name of the resulting resource. * @param id The _unique_ provider ID of the resource to lookup. * @param state Any extra arguments used during the lookup. * @param opts Optional settings to control the behavior of the CustomResource. */ static get(name: string, id: pulumi.Input, state?: ContainerState, opts?: pulumi.CustomResourceOptions): Container; /** * Returns true if the given object is an instance of Container. This is designed to work even * when multiple copies of the Pulumi SDK have been loaded into the same process. */ static isInstance(obj: any): obj is Container; /** * Arguments passed to the command specified in the `command` field. These override the default arguments from the container image, and behave like command-line parameters. */ readonly args: pulumi.Output; /** * Command executed when the container starts. This overrides the default command defined in the container image. This is usually the main executable, or entry point script to run. */ readonly commands: pulumi.Output; /** * The amount of vCPU computing resources to allocate to each container. */ readonly cpuLimit: pulumi.Output; /** * The cron status * * @deprecated Please refer to the scaleway.containers.Trigger resource instead. */ readonly cronStatus: pulumi.Output; /** * Boolean indicating whether the container is in a production environment. * * > **Important:** Containers are now automatically deployed and redeployed; setting this attribute will not have any effect. * * @deprecated Containers are now automatically deployed or redeployed; setting this attribute will not have any effect. */ readonly deploy: pulumi.Output; /** * The description of the container. */ readonly description: pulumi.Output; /** * The native domain name of the container * * @deprecated This attribute will be removed in the future, please use publicEndpoint instead */ readonly domainName: pulumi.Output; /** * The [environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#environment-variables) of the container. */ readonly environmentVariables: pulumi.Output<{ [key: string]: string; }>; /** * The error message of the container. */ readonly errorMessage: pulumi.Output; /** * Health check configuration block of the container. * * @deprecated Please use livenessProbe instead */ readonly healthChecks: pulumi.Output; /** * Allows both HTTP and HTTPS (`enabled`) or redirect HTTP to HTTPS (`redirected`). Defaults to `enabled`. * * > **Important:** Only one of `httpsConnectionsOnly` or `httpOption` can be set at a time. * * @deprecated Please use httpsConnectionsOnly instead */ readonly httpOption: pulumi.Output; /** * Allows both HTTP and HTTPS (`false`) or redirect HTTP to HTTPS (`true`). Defaults to `false`. */ readonly httpsConnectionsOnly: pulumi.Output; /** * The image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`) */ readonly image: pulumi.Output; /** * Defines how to check if the container is running. */ readonly livenessProbe: pulumi.Output; /** * Local storage limit of the container (in MB) * * > **Important:** Only one of `localStorageLimitBytes` or `localStorageLimit` can be set at a time. * * @deprecated Please use localStorageLimitBytes instead */ readonly localStorageLimit: pulumi.Output; /** * Local storage limit of the container (in bytes). */ readonly localStorageLimitBytes: pulumi.Output; /** * The maximum number of instances this container can scale to. */ readonly maxScale: pulumi.Output; /** * The memory resources in MB to allocate to each container. * * > **Important:** Only one of `memoryLimit` or `memoryLimitBytes` can be set at a time. * * @deprecated Please use memoryLimitBytes instead */ readonly memoryLimit: pulumi.Output; /** * The memory resources in bytes to allocate to each container. */ readonly memoryLimitBytes: pulumi.Output; /** * The minimum number of container instances running continuously. */ readonly minScale: pulumi.Output; /** * The unique name of the container name. * * > **Important** Updating the `name` argument will recreate the container. */ readonly name: pulumi.Output; /** * The Containers namespace ID of the container. */ readonly namespaceId: pulumi.Output; /** * The port to expose the container. */ readonly port: pulumi.Output; /** * The privacy type defines the way to authenticate to your container. Please check our dedicated [section](https://www.scaleway.com/en/developers/api/serverless-containers/#protocol-9dd4c8). */ readonly privacy: pulumi.Output; /** * The ID of the Private Network the container is connected to. * * Note that if you want to use your own configuration, you must consult our configuration [restrictions](https://www.scaleway.com/en/docs/serverless-containers/reference-content/containers-limitations/#configuration-restrictions) section. */ readonly privateNetworkId: pulumi.Output; /** * The communication [protocol](https://www.scaleway.com/en/developers/api/serverless-containers/#path-containers-update-an-existing-container) `http1` or `h2c`. Defaults to `http1`. */ readonly protocol: pulumi.Output; /** * The native domain name of the container */ readonly publicEndpoint: pulumi.Output; /** * (Defaults to provider `region`) The region in which the container was created. */ readonly region: pulumi.Output; /** * The registry image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`) * * - > **Important:** Exactly one of `image` or `registryImage` must be set. * * @deprecated Please use image instead */ readonly registryImage: pulumi.Output; /** * The sha256 of your source registry image, changing it will re-apply the deployment. Can be any string. */ readonly registrySha256: pulumi.Output; /** * Execution environment of the container. */ readonly sandbox: pulumi.Output; /** * Configuration block used to decide when to scale up or down. Possible values: */ readonly scalingOptions: pulumi.Output; /** * The [secret environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#secrets) of the container. */ readonly secretEnvironmentVariables: pulumi.Output<{ [key: string]: string; } | undefined>; /** * Defines how to check if the container has started successfully. */ readonly startupProbe: pulumi.Output; /** * The container status. In case the status is different from `ready`, a warning will be displayed when Terraform reads the resource. */ readonly status: pulumi.Output; /** * The list of tags associated with the container. */ readonly tags: pulumi.Output; /** * The maximum amount of time in seconds your container can spend processing a request before being stopped. Default to `300` seconds. */ readonly timeout: pulumi.Output; /** * Create a Container resource with the given unique name, arguments, and options. * * @param name The _unique_ name of the resource. * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ /** @deprecated scaleway.index/container.Container has been deprecated in favor of scaleway.containers/container.Container */ constructor(name: string, args: ContainerArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering Container resources. */ export interface ContainerState { /** * Arguments passed to the command specified in the `command` field. These override the default arguments from the container image, and behave like command-line parameters. */ args?: pulumi.Input[] | undefined>; /** * Command executed when the container starts. This overrides the default command defined in the container image. This is usually the main executable, or entry point script to run. */ commands?: pulumi.Input[] | undefined>; /** * The amount of vCPU computing resources to allocate to each container. */ cpuLimit?: pulumi.Input; /** * The cron status * * @deprecated Please refer to the scaleway.containers.Trigger resource instead. */ cronStatus?: pulumi.Input; /** * Boolean indicating whether the container is in a production environment. * * > **Important:** Containers are now automatically deployed and redeployed; setting this attribute will not have any effect. * * @deprecated Containers are now automatically deployed or redeployed; setting this attribute will not have any effect. */ deploy?: pulumi.Input; /** * The description of the container. */ description?: pulumi.Input; /** * The native domain name of the container * * @deprecated This attribute will be removed in the future, please use publicEndpoint instead */ domainName?: pulumi.Input; /** * The [environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#environment-variables) of the container. */ environmentVariables?: pulumi.Input<{ [key: string]: pulumi.Input; } | undefined>; /** * The error message of the container. */ errorMessage?: pulumi.Input; /** * Health check configuration block of the container. * * @deprecated Please use livenessProbe instead */ healthChecks?: pulumi.Input[] | undefined>; /** * Allows both HTTP and HTTPS (`enabled`) or redirect HTTP to HTTPS (`redirected`). Defaults to `enabled`. * * > **Important:** Only one of `httpsConnectionsOnly` or `httpOption` can be set at a time. * * @deprecated Please use httpsConnectionsOnly instead */ httpOption?: pulumi.Input; /** * Allows both HTTP and HTTPS (`false`) or redirect HTTP to HTTPS (`true`). Defaults to `false`. */ httpsConnectionsOnly?: pulumi.Input; /** * The image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`) */ image?: pulumi.Input; /** * Defines how to check if the container is running. */ livenessProbe?: pulumi.Input; /** * Local storage limit of the container (in MB) * * > **Important:** Only one of `localStorageLimitBytes` or `localStorageLimit` can be set at a time. * * @deprecated Please use localStorageLimitBytes instead */ localStorageLimit?: pulumi.Input; /** * Local storage limit of the container (in bytes). */ localStorageLimitBytes?: pulumi.Input; /** * The maximum number of instances this container can scale to. */ maxScale?: pulumi.Input; /** * The memory resources in MB to allocate to each container. * * > **Important:** Only one of `memoryLimit` or `memoryLimitBytes` can be set at a time. * * @deprecated Please use memoryLimitBytes instead */ memoryLimit?: pulumi.Input; /** * The memory resources in bytes to allocate to each container. */ memoryLimitBytes?: pulumi.Input; /** * The minimum number of container instances running continuously. */ minScale?: pulumi.Input; /** * The unique name of the container name. * * > **Important** Updating the `name` argument will recreate the container. */ name?: pulumi.Input; /** * The Containers namespace ID of the container. */ namespaceId?: pulumi.Input; /** * The port to expose the container. */ port?: pulumi.Input; /** * The privacy type defines the way to authenticate to your container. Please check our dedicated [section](https://www.scaleway.com/en/developers/api/serverless-containers/#protocol-9dd4c8). */ privacy?: pulumi.Input; /** * The ID of the Private Network the container is connected to. * * Note that if you want to use your own configuration, you must consult our configuration [restrictions](https://www.scaleway.com/en/docs/serverless-containers/reference-content/containers-limitations/#configuration-restrictions) section. */ privateNetworkId?: pulumi.Input; /** * The communication [protocol](https://www.scaleway.com/en/developers/api/serverless-containers/#path-containers-update-an-existing-container) `http1` or `h2c`. Defaults to `http1`. */ protocol?: pulumi.Input; /** * The native domain name of the container */ publicEndpoint?: pulumi.Input; /** * (Defaults to provider `region`) The region in which the container was created. */ region?: pulumi.Input; /** * The registry image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`) * * - > **Important:** Exactly one of `image` or `registryImage` must be set. * * @deprecated Please use image instead */ registryImage?: pulumi.Input; /** * The sha256 of your source registry image, changing it will re-apply the deployment. Can be any string. */ registrySha256?: pulumi.Input; /** * Execution environment of the container. */ sandbox?: pulumi.Input; /** * Configuration block used to decide when to scale up or down. Possible values: */ scalingOptions?: pulumi.Input[] | undefined>; /** * The [secret environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#secrets) of the container. */ secretEnvironmentVariables?: pulumi.Input<{ [key: string]: pulumi.Input; } | undefined>; /** * Defines how to check if the container has started successfully. */ startupProbe?: pulumi.Input; /** * The container status. In case the status is different from `ready`, a warning will be displayed when Terraform reads the resource. */ status?: pulumi.Input; /** * The list of tags associated with the container. */ tags?: pulumi.Input[] | undefined>; /** * The maximum amount of time in seconds your container can spend processing a request before being stopped. Default to `300` seconds. */ timeout?: pulumi.Input; } /** * The set of arguments for constructing a Container resource. */ export interface ContainerArgs { /** * Arguments passed to the command specified in the `command` field. These override the default arguments from the container image, and behave like command-line parameters. */ args?: pulumi.Input[] | undefined>; /** * Command executed when the container starts. This overrides the default command defined in the container image. This is usually the main executable, or entry point script to run. */ commands?: pulumi.Input[] | undefined>; /** * The amount of vCPU computing resources to allocate to each container. */ cpuLimit?: pulumi.Input; /** * Boolean indicating whether the container is in a production environment. * * > **Important:** Containers are now automatically deployed and redeployed; setting this attribute will not have any effect. * * @deprecated Containers are now automatically deployed or redeployed; setting this attribute will not have any effect. */ deploy?: pulumi.Input; /** * The description of the container. */ description?: pulumi.Input; /** * The [environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#environment-variables) of the container. */ environmentVariables?: pulumi.Input<{ [key: string]: pulumi.Input; } | undefined>; /** * Health check configuration block of the container. * * @deprecated Please use livenessProbe instead */ healthChecks?: pulumi.Input[] | undefined>; /** * Allows both HTTP and HTTPS (`enabled`) or redirect HTTP to HTTPS (`redirected`). Defaults to `enabled`. * * > **Important:** Only one of `httpsConnectionsOnly` or `httpOption` can be set at a time. * * @deprecated Please use httpsConnectionsOnly instead */ httpOption?: pulumi.Input; /** * Allows both HTTP and HTTPS (`false`) or redirect HTTP to HTTPS (`true`). Defaults to `false`. */ httpsConnectionsOnly?: pulumi.Input; /** * The image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`) */ image?: pulumi.Input; /** * Defines how to check if the container is running. */ livenessProbe?: pulumi.Input; /** * Local storage limit of the container (in MB) * * > **Important:** Only one of `localStorageLimitBytes` or `localStorageLimit` can be set at a time. * * @deprecated Please use localStorageLimitBytes instead */ localStorageLimit?: pulumi.Input; /** * Local storage limit of the container (in bytes). */ localStorageLimitBytes?: pulumi.Input; /** * The maximum number of instances this container can scale to. */ maxScale?: pulumi.Input; /** * The memory resources in MB to allocate to each container. * * > **Important:** Only one of `memoryLimit` or `memoryLimitBytes` can be set at a time. * * @deprecated Please use memoryLimitBytes instead */ memoryLimit?: pulumi.Input; /** * The memory resources in bytes to allocate to each container. */ memoryLimitBytes?: pulumi.Input; /** * The minimum number of container instances running continuously. */ minScale?: pulumi.Input; /** * The unique name of the container name. * * > **Important** Updating the `name` argument will recreate the container. */ name?: pulumi.Input; /** * The Containers namespace ID of the container. */ namespaceId: pulumi.Input; /** * The port to expose the container. */ port?: pulumi.Input; /** * The privacy type defines the way to authenticate to your container. Please check our dedicated [section](https://www.scaleway.com/en/developers/api/serverless-containers/#protocol-9dd4c8). */ privacy?: pulumi.Input; /** * The ID of the Private Network the container is connected to. * * Note that if you want to use your own configuration, you must consult our configuration [restrictions](https://www.scaleway.com/en/docs/serverless-containers/reference-content/containers-limitations/#configuration-restrictions) section. */ privateNetworkId?: pulumi.Input; /** * The communication [protocol](https://www.scaleway.com/en/developers/api/serverless-containers/#path-containers-update-an-existing-container) `http1` or `h2c`. Defaults to `http1`. */ protocol?: pulumi.Input; /** * (Defaults to provider `region`) The region in which the container was created. */ region?: pulumi.Input; /** * The registry image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`) * * - > **Important:** Exactly one of `image` or `registryImage` must be set. * * @deprecated Please use image instead */ registryImage?: pulumi.Input; /** * The sha256 of your source registry image, changing it will re-apply the deployment. Can be any string. */ registrySha256?: pulumi.Input; /** * Execution environment of the container. */ sandbox?: pulumi.Input; /** * Configuration block used to decide when to scale up or down. Possible values: */ scalingOptions?: pulumi.Input[] | undefined>; /** * The [secret environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#secrets) of the container. */ secretEnvironmentVariables?: pulumi.Input<{ [key: string]: pulumi.Input; } | undefined>; /** * Defines how to check if the container has started successfully. */ startupProbe?: pulumi.Input; /** * The list of tags associated with the container. */ tags?: pulumi.Input[] | undefined>; /** * The maximum amount of time in seconds your container can spend processing a request before being stopped. Default to `300` seconds. */ timeout?: pulumi.Input; } //# sourceMappingURL=container.d.ts.map