@pulumiverse/scaleway/container.d.ts

A Pulumi package for creating and managing Scaleway cloud resources.

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<pulumi.ID>, 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<string[] | 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.
     */
    readonly commands: pulumi.Output<string[] | undefined>;
    /**
     * The amount of vCPU computing resources to allocate to each container.
     */
    readonly cpuLimit: pulumi.Output<number>;
    /**
     * The cron status
     *
     * @deprecated Please refer to the scaleway.containers.Trigger resource instead.
     */
    readonly cronStatus: pulumi.Output<string>;
    /**
     * 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<boolean | undefined>;
    /**
     * The description of the container.
     */
    readonly description: pulumi.Output<string | undefined>;
    /**
     * The native domain name of the container
     *
     * @deprecated This attribute will be removed in the future, please use publicEndpoint instead
     */
    readonly domainName: pulumi.Output<string>;
    /**
     * 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<string>;
    /**
     * Health check configuration block of the container.
     *
     * @deprecated Please use livenessProbe instead
     */
    readonly healthChecks: pulumi.Output<outputs.ContainerHealthCheck[]>;
    /**
     * 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<string>;
    /**
     * Allows both HTTP and HTTPS (`false`) or redirect HTTP to HTTPS (`true`). Defaults to `false`.
     */
    readonly httpsConnectionsOnly: pulumi.Output<boolean>;
    /**
     * The image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`)
     */
    readonly image: pulumi.Output<string>;
    /**
     * Defines how to check if the container is running.
     */
    readonly livenessProbe: pulumi.Output<outputs.ContainerLivenessProbe>;
    /**
     * 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<number>;
    /**
     * Local storage limit of the container (in bytes).
     */
    readonly localStorageLimitBytes: pulumi.Output<number>;
    /**
     * The maximum number of instances this container can scale to.
     */
    readonly maxScale: pulumi.Output<number>;
    /**
     * 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<number>;
    /**
     * The memory resources in bytes to allocate to each container.
     */
    readonly memoryLimitBytes: pulumi.Output<number>;
    /**
     * The minimum number of container instances running continuously.
     */
    readonly minScale: pulumi.Output<number>;
    /**
     * The unique name of the container name.
     *
     * > **Important** Updating the `name` argument will recreate the container.
     */
    readonly name: pulumi.Output<string>;
    /**
     * The Containers namespace ID of the container.
     */
    readonly namespaceId: pulumi.Output<string>;
    /**
     * The port to expose the container.
     */
    readonly port: pulumi.Output<number>;
    /**
     * 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<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * The native domain name of the container
     */
    readonly publicEndpoint: pulumi.Output<string>;
    /**
     * (Defaults to provider `region`) The region in which the container was created.
     */
    readonly region: pulumi.Output<string | undefined>;
    /**
     * 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<string>;
    /**
     * The sha256 of your source registry image, changing it will re-apply the deployment. Can be any string.
     */
    readonly registrySha256: pulumi.Output<string | undefined>;
    /**
     * Execution environment of the container.
     */
    readonly sandbox: pulumi.Output<string>;
    /**
     * Configuration block used to decide when to scale up or down. Possible values:
     */
    readonly scalingOptions: pulumi.Output<outputs.ContainerScalingOption[]>;
    /**
     * 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<outputs.ContainerStartupProbe | undefined>;
    /**
     * 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<string>;
    /**
     * The list of tags associated with the container.
     */
    readonly tags: pulumi.Output<string[] | undefined>;
    /**
     * 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<number>;
    /**
     * 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<pulumi.Input<string>[] | 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<pulumi.Input<string>[] | undefined>;
    /**
     * The amount of vCPU computing resources to allocate to each container.
     */
    cpuLimit?: pulumi.Input<number | undefined>;
    /**
     * The cron status
     *
     * @deprecated Please refer to the scaleway.containers.Trigger resource instead.
     */
    cronStatus?: pulumi.Input<string | undefined>;
    /**
     * 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<boolean | undefined>;
    /**
     * The description of the container.
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * The native domain name of the container
     *
     * @deprecated This attribute will be removed in the future, please use publicEndpoint instead
     */
    domainName?: pulumi.Input<string | undefined>;
    /**
     * The [environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#environment-variables) of the container.
     */
    environmentVariables?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * The error message of the container.
     */
    errorMessage?: pulumi.Input<string | undefined>;
    /**
     * Health check configuration block of the container.
     *
     * @deprecated Please use livenessProbe instead
     */
    healthChecks?: pulumi.Input<pulumi.Input<inputs.ContainerHealthCheck>[] | 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<string | undefined>;
    /**
     * Allows both HTTP and HTTPS (`false`) or redirect HTTP to HTTPS (`true`). Defaults to `false`.
     */
    httpsConnectionsOnly?: pulumi.Input<boolean | undefined>;
    /**
     * The image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`)
     */
    image?: pulumi.Input<string | undefined>;
    /**
     * Defines how to check if the container is running.
     */
    livenessProbe?: pulumi.Input<inputs.ContainerLivenessProbe | undefined>;
    /**
     * 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<number | undefined>;
    /**
     * Local storage limit of the container (in bytes).
     */
    localStorageLimitBytes?: pulumi.Input<number | undefined>;
    /**
     * The maximum number of instances this container can scale to.
     */
    maxScale?: pulumi.Input<number | undefined>;
    /**
     * 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<number | undefined>;
    /**
     * The memory resources in bytes to allocate to each container.
     */
    memoryLimitBytes?: pulumi.Input<number | undefined>;
    /**
     * The minimum number of container instances running continuously.
     */
    minScale?: pulumi.Input<number | undefined>;
    /**
     * The unique name of the container name.
     *
     * > **Important** Updating the `name` argument will recreate the container.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * The Containers namespace ID of the container.
     */
    namespaceId?: pulumi.Input<string | undefined>;
    /**
     * The port to expose the container.
     */
    port?: pulumi.Input<number | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * The native domain name of the container
     */
    publicEndpoint?: pulumi.Input<string | undefined>;
    /**
     * (Defaults to provider `region`) The region in which the container was created.
     */
    region?: pulumi.Input<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * The sha256 of your source registry image, changing it will re-apply the deployment. Can be any string.
     */
    registrySha256?: pulumi.Input<string | undefined>;
    /**
     * Execution environment of the container.
     */
    sandbox?: pulumi.Input<string | undefined>;
    /**
     * Configuration block used to decide when to scale up or down. Possible values:
     */
    scalingOptions?: pulumi.Input<pulumi.Input<inputs.ContainerScalingOption>[] | 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<string>;
    } | undefined>;
    /**
     * Defines how to check if the container has started successfully.
     */
    startupProbe?: pulumi.Input<inputs.ContainerStartupProbe | undefined>;
    /**
     * The container status. In case the status is different from `ready`, a warning will be displayed when Terraform reads the resource.
     */
    status?: pulumi.Input<string | undefined>;
    /**
     * The list of tags associated with the container.
     */
    tags?: pulumi.Input<pulumi.Input<string>[] | 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<number | undefined>;
}
/**
 * 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<pulumi.Input<string>[] | 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<pulumi.Input<string>[] | undefined>;
    /**
     * The amount of vCPU computing resources to allocate to each container.
     */
    cpuLimit?: pulumi.Input<number | undefined>;
    /**
     * 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<boolean | undefined>;
    /**
     * The description of the container.
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * The [environment variables](https://www.scaleway.com/en/docs/serverless-containers/concepts/#environment-variables) of the container.
     */
    environmentVariables?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * Health check configuration block of the container.
     *
     * @deprecated Please use livenessProbe instead
     */
    healthChecks?: pulumi.Input<pulumi.Input<inputs.ContainerHealthCheck>[] | 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<string | undefined>;
    /**
     * Allows both HTTP and HTTPS (`false`) or redirect HTTP to HTTPS (`true`). Defaults to `false`.
     */
    httpsConnectionsOnly?: pulumi.Input<boolean | undefined>;
    /**
     * The image address (e.g., `rg.fr-par.scw.cloud/$NAMESPACE/$IMAGE`)
     */
    image?: pulumi.Input<string | undefined>;
    /**
     * Defines how to check if the container is running.
     */
    livenessProbe?: pulumi.Input<inputs.ContainerLivenessProbe | undefined>;
    /**
     * 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<number | undefined>;
    /**
     * Local storage limit of the container (in bytes).
     */
    localStorageLimitBytes?: pulumi.Input<number | undefined>;
    /**
     * The maximum number of instances this container can scale to.
     */
    maxScale?: pulumi.Input<number | undefined>;
    /**
     * 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<number | undefined>;
    /**
     * The memory resources in bytes to allocate to each container.
     */
    memoryLimitBytes?: pulumi.Input<number | undefined>;
    /**
     * The minimum number of container instances running continuously.
     */
    minScale?: pulumi.Input<number | undefined>;
    /**
     * The unique name of the container name.
     *
     * > **Important** Updating the `name` argument will recreate the container.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * The Containers namespace ID of the container.
     */
    namespaceId: pulumi.Input<string>;
    /**
     * The port to expose the container.
     */
    port?: pulumi.Input<number | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * (Defaults to provider `region`) The region in which the container was created.
     */
    region?: pulumi.Input<string | undefined>;
    /**
     * 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<string | undefined>;
    /**
     * The sha256 of your source registry image, changing it will re-apply the deployment. Can be any string.
     */
    registrySha256?: pulumi.Input<string | undefined>;
    /**
     * Execution environment of the container.
     */
    sandbox?: pulumi.Input<string | undefined>;
    /**
     * Configuration block used to decide when to scale up or down. Possible values:
     */
    scalingOptions?: pulumi.Input<pulumi.Input<inputs.ContainerScalingOption>[] | 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<string>;
    } | undefined>;
    /**
     * Defines how to check if the container has started successfully.
     */
    startupProbe?: pulumi.Input<inputs.ContainerStartupProbe | undefined>;
    /**
     * The list of tags associated with the container.
     */
    tags?: pulumi.Input<pulumi.Input<string>[] | 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<number | undefined>;
}
//# sourceMappingURL=container.d.ts.map